bsp_stm32f4_discovery_lcd.c

#if defined (BOARD_STM32F4_DISCOVERY_LCD)
#include "heivs/config.h"
#include "heivs/bsp.h"
#include "heivs/time.h"
#include "heivs/delay.h"
#include "heivs/retarget.h"
#include "stm32/usb/usb_core.h"
#include "stm32/stm32f4xx_rcc.h"
#include "stm32/stm32f4xx_fsmc.h"
#include "heivs/lightness_to_pwm.h"

<<<<<<< .mine
static struct gpio_t sram_gpios[] =
{
        GPIO_FSMC_A0_PF0,
        GPIO_FSMC_A1_PF1,
        GPIO_FSMC_A2_PF2,
        GPIO_FSMC_A3_PF3,
        GPIO_FSMC_A4_PF4,
        GPIO_FSMC_A5_PF5,
        GPIO_FSMC_A6_PF12,
        GPIO_FSMC_A7_PF13,
        GPIO_FSMC_A8_PF14,
        GPIO_FSMC_A9_PF15,
        GPIO_FSMC_A10_PG0,
        GPIO_FSMC_A11_PG1,
        GPIO_FSMC_A12_PG2,
        GPIO_FSMC_A13_PG3,
        GPIO_FSMC_A14_PG4,
        GPIO_FSMC_A15_PG5,
        GPIO_FSMC_A16_PD11,
        GPIO_FSMC_A17_PD12,
//      GPIO_FSMC_A18_PD13,
        GPIO_FSMC_A19_PE3,
        GPIO_FSMC_A20_PE4,
        GPIO_FSMC_A21_PE5,

        GPIO_FSMC_D0_PD14,
        GPIO_FSMC_D1_PD15,
        GPIO_FSMC_D2_PD0,
        GPIO_FSMC_D3_PD1,
        GPIO_FSMC_D4_PE7,
        GPIO_FSMC_D5_PE8,
        GPIO_FSMC_D6_PE9,
        GPIO_FSMC_D7_PE10,
        GPIO_FSMC_D8_PE11,
        GPIO_FSMC_D9_PE12,
        GPIO_FSMC_D10_PE13,
        GPIO_FSMC_D11_PE14,
        GPIO_FSMC_D12_PE15,
        GPIO_FSMC_D13_PD8,
        GPIO_FSMC_D14_PD9,
        GPIO_FSMC_D15_PD10,

        GPIO_FSMC_NE1_FSMC_NCE2_PD7,
        GPIO_FSMC_NWE_PD5,
        GPIO_FSMC_NOE_PD4,
        GPIO_FSMC_BLN1_PE1,
        GPIO_FSMC_NBL0_PE0,
};
static status_e bsp_init_FSMC(void)
{
    // Setup gpios used by our RAM and LCD
    gpio_setup_list(sram_gpios, ARRAY_SIZE(sram_gpios));
    // enable the clock peripheral
    RCC_AHB3PeriphClockCmd(RCC_AHB3ENR_FSMCEN, ENABLE);

    FSMC_NORSRAMInitTypeDef fscm;
    FSMC_NORSRAMTimingInitTypeDef timings;

    // init the FSMC for LCD
    timings.FSMC_AddressSetupTime = 6;
    timings.FSMC_AddressHoldTime = 0;
    timings.FSMC_DataSetupTime = 6;

//  timings.FSMC_AddressSetupTime = 12;
//  timings.FSMC_AddressHoldTime = 6;
//  timings.FSMC_DataSetupTime = 12;

    timings.FSMC_BusTurnAroundDuration = 1;
    timings.FSMC_CLKDivision = 0;
    timings.FSMC_DataLatency = 0;
    timings.FSMC_AccessMode = FSMC_AccessMode_A;

    fscm.FSMC_Bank = FSMC_Bank1_NORSRAM1;
    fscm.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
    fscm.FSMC_MemoryType = FSMC_MemoryType_SRAM;
    fscm.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
    fscm.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
    fscm.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
    fscm.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
    fscm.FSMC_WrapMode = FSMC_WrapMode_Disable;
    fscm.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
    fscm.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
    fscm.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
    fscm.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
    fscm.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
    fscm.FSMC_ReadWriteTimingStruct = &timings;
    fscm.FSMC_WriteTimingStruct = &timings;
    FSMC_NORSRAMInit(&fscm);
    FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);

    return NO_ERROR;
}

static status_e bsp_pwm_leds_init(uint32_t frequency, uint32_t steps, uint32_t initial)
=======
static void bsp_pwm_leds_init(uint32_t frequency, uint32_t steps, uint32_t initial)
>>>>>>> .r213
{
    const struct gpio_t pins[] =
    {
            GPIO_TIM4_CH1_PD12,
            GPIO_TIM4_CH2_PD13,
//          GPIO_TIM4_CH3_PD14,
//          GPIO_TIM4_CH4_PD15,
    };

    /* Pin setup */
    gpio_setup_list(pins, ARRAY_SIZE(pins));

    /* Enable the timer clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

    /* Reset the timer */
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, DISABLE);

    TIM4->CCER =
              TIM_CCER_CC1E
            | TIM_CCER_CC2E
            | TIM_CCER_CC3E
            | TIM_CCER_CC4E
        ;

    /**
     * Timer frequency = steps * input_frequency
     */
    TIM4->PSC = (((SystemClock.timer)/steps)/frequency) - 1;

    /**
     * Count steps (from zero to steps - 1)
     */
    TIM4->ARR = steps - 1;

    /* Set the output value to 50 % */
    TIM4->CCR1 = initial;
    TIM4->CCR2 = initial;
    TIM4->CCR3 = initial;
    TIM4->CCR4 = initial;

    TIM4->CCMR1 =
                TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1PE
              | TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2PE;
        ;
    TIM4->CCMR2 =
                TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3PE
              | TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4PE
        ;

    /* Update registers now */
    TIM4->EGR |= TIM_EGR_UG;

    /* Start the timer */
    TIM4->CR1 = TIM_CR1_ARPE | TIM_CR1_CEN;
}

void bsp_led_set_pwm(uint32_t nr, uint32_t value)
{
    if (nr < 4)
    {
        volatile uint32_t *addr[] =
        {
                &TIM4->CCR1,
                &TIM4->CCR3,
                &TIM4->CCR4,
                &TIM4->CCR2,
        };

        *addr[nr] = lightness_to_pwm(value);
    }
}

void bsp_led_set(uint32_t nr, uint32_t value)
{

    bsp_led_set_pwm(nr, value > 0 ? 255 : 0);
}

void bsp_led_toggle(uint32_t nr)
{
    if (nr < 4)
    {
        volatile uint32_t *addr[] =
        {
                &TIM4->CCR1,
                &TIM4->CCR3,
                &TIM4->CCR4,
                &TIM4->CCR2,
        };

        if (*addr[nr])
        {
            *addr[nr] = 0;
        }
        else
        {
            *addr[nr] = 255;
        }
    }
}

static const struct gpio_t bsp_buttons[BSP_BUTTON_NR] =
{
    GPIO_MOD(0, 0, GPIO_INPUT | GPIO_PP | GPIO_SPEED_2),
};

static status_e bsp_buttons_init(void)
{
    gpio_setup_list(bsp_buttons, BSP_BUTTON_NR);

    return NO_ERROR;
}

static status_e bsp_lcd_backlight_init(uint32_t frequency, uint32_t steps, uint32_t initial)
{
    const struct gpio_t pins[] =
    {
            GPIO_TIM4_CH2_PD13,
    };

    /* Pin setup */
    gpio_setup_list(pins, ARRAY_SIZE(pins));

    /* Enable the timer clock */
    RCC_APB2PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    /* Reset the timer */
//  RCC_APB2PeriphResetCmd(RCC_APB1Periph_TIM4, ENABLE);
//  RCC_APB2PeriphResetCmd(RCC_APB1Periph_TIM4, DISABLE);

    TIM4->CCER |=
            TIM_CCER_CC2E /* Enable compare 1 output */
        ;

    /**
     * Timer frequency = steps * input_frequency
     */
    TIM4->PSC = (((SystemClock.timer)/steps)/frequency) - 1;

    /**
     * Count steps (from zero to steps - 1)
     */
    TIM4->ARR = steps - 1;

    /* Set the intial value */
    TIM4->CCR2 = steps-initial;

    TIM4->CCMR2 |=
              TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2M_1   /* PWM mode 1           */
            | TIM_CCMR1_OC2PE                       /* CCR2 shadow mode     */;

    /* Update registers now */
    TIM4->EGR |= TIM_EGR_UG;

    /* Start the timer */
    TIM4->CR1 |=
              TIM_CR1_ARPE
            | TIM_CR1_CEN;

    return NO_ERROR;
}

void bsp_lcd_backlight_set(uint32_t value)
{
    TIM4->CCR2 = lightness_to_pwm(value);
}

status_e bsp_init(void)
{
    status_e status;

    time_init();
    delay_wait_ms(1000);    // test purpose because of fucking processor
    bsp_init_FSMC();
    bsp_pwm_leds_init(50, 1000, 150);

    retarget_init();

<<<<<<< .mine
    status = bsp_pwm_leds_init(20000, LIGHTNESS_PWM_STEP, lightness_to_pwm(50));
    if (status != NO_ERROR)
    {
        return status;
    }
    status = bsp_lcd_backlight_init(20000,LIGHTNESS_PWM_STEP,lightness_to_pwm(50));
    if (status != NO_ERROR)
    {
        return status;
    }
=======
>>>>>>> .r213
    status = bsp_buttons_init();
    if (status != NO_ERROR)
    {
        return status;
    }

    return NO_ERROR;
}

uint32_t bsp_button_get(uint32_t nr)
{
    if (nr > BSP_LED_NR)
    {
        return 0;
    }

    return gpio_get(&bsp_buttons[nr]);
}

#if (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE)

static const struct gpio_t gpio_vbus_not = GPIO_MOD(2, 0, GPIO_OUTPUT_1);

void USB_OTG_BSP_DriveVBUS(USB_OTG_CORE_HANDLE *pdev, uint8_t state)
{
    gpio_set(&gpio_vbus_not, !state);
}

void  USB_OTG_BSP_ConfigVBUS(USB_OTG_CORE_HANDLE *pdev)
{
    gpio_setup(&gpio_vbus_not);
    /* By Default, DISABLE is needed on output of the Power Switch */
    USB_OTG_BSP_DriveVBUS (pdev, 0);

    delay_wait_ms(200);   /* Delay is need for stabilising the Vbus Low
    in Reset Condition, when Vbus=1 and Reset-button is pressed by user */
}
#endif /* (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE) */

#endif