kosmos/source/firmware/arch/stm32f4xx/board/stm32f4-discovery/include/stm32f4-discovery.h

/*! \file stm32f4-discovery.h
 *  \author tkl
 *  \date Mai 7, 2012
 *  \brief Header file of the board definition for the STM32F4-Discovery board.
 */
#ifndef BSP_STM32F4_DISCOVERY_H_
#define BSP_STM32F4_DISCOVERY_H_

#include <stddef.h>
#include <stdint.h>

#include "stm32f4xx.h"

#include "pwm.h"
#include "stm32f4_pwm.h"

#include "uart.h"
#include "stm32f4_uart.h"
#include "ringbuffer.h"

#include "timer.h"
#include "stm32_sys_tick.h"
#include "sys_tick.h"

#include "gpio.h"
#include "stm32f4_gpio.h"
#include "driver.h"

#if 0
// GPIO_D12
static const GPIO_InitTypeDef port_cfg_d12 = {
		.Pin = GPIO_PIN_12,
		.Mode = GPIO_MODE_OUTPUT_PP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Pull = GPIO_PULLUP,
};

static const struct stm32f4_gpio stm32_f4_gpio_d12 = {
		.port = GPIOD,
		.pin = &port_cfg_d12,
};

static const struct gpio __gpio_d12 = {
		(void*)&stm32_f4_gpio_d12,
		&gpio_fp
};

static const struct driver gpio_d12 = {
		DRIVER_TYPE_GPIO,
		&__gpio_d12,
};
#endif

// SYSTEM TICK
static const enum stm32_sys_tick_time_base stm23_sys_tick_time_base =
		STM32_SYS_TICK_TIME_BASE_MS;

static const struct stm32_sys_tick stm32_sys_tick = {
		.tick_time_base = &stm23_sys_tick_time_base,
		.sys_tick_cb = NULL,
		.sys_tick_cb_param = NULL,
};

static const struct loki_timer timer_1 = {
		.arch_dep_device = (void*)&stm32_sys_tick,
		.fp = &timer_fp
};

// PWM CHANNEL 4
/* apb1 clock = 84MHz */
/* period_reg = src_clk / presc   / cnt_clk     */
/*       4199 = 84MHZ   / (0 + 1) / 20kHz   - 1 */
static TIM_HandleTypeDef tim4_handle = {
		.Instance = TIM4,
		.Init.Prescaler = 0,
		.Init.CounterMode = TIM_COUNTERMODE_UP,
		.Init.Period = 4199,
		.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1,
		.Init.RepetitionCounter = 0,
};

static TIM_OC_InitTypeDef t4_output_compare_cfg = {
		.OCMode = TIM_OCMODE_PWM1,
		.Pulse = 0,
		.OCPolarity = TIM_OCPOLARITY_HIGH,
		.OCNPolarity = TIM_OCNPOLARITY_HIGH,
		.OCFastMode = TIM_OCFAST_DISABLE,
		.OCIdleState = TIM_OCIDLESTATE_SET,
		.OCNIdleState = TIM_OCNIDLESTATE_SET
};

static const GPIO_InitTypeDef port_cfg_D15 = {
		.Pin = GPIO_PIN_15,
		.Mode = GPIO_MODE_AF_PP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Pull = GPIO_PULLUP,
		.Alternate = GPIO_AF2_TIM4,
};

static const struct stm32f4_gpio t4c4_gpio = {
		.port = GPIOD,
		.pin = &port_cfg_D15,
};

static struct stm32f4_pwm str32f4_pwm_4 = {
		.pwm_gpio = &t4c4_gpio,
		.timer_handle = &tim4_handle,
		.output_compare_cfg = &t4_output_compare_cfg,
		.channel = TIM_CHANNEL_4,
};

static const struct pwm pwm_ch4 = {
		.arch_dep_device = &str32f4_pwm_4,
		.fp = &stm32f4_pwm_fp,
};

#ifdef TEST_APP
static const struct driver pwm_4 = {
#else
const struct driver pwm_4 = {
#endif
		DRIVER_TYPE_PWM,
		&pwm_ch4,
};

// PWM Channel 3
static const GPIO_InitTypeDef port_cfg_D14 = {
		.Pin = GPIO_PIN_14,
		.Mode = GPIO_MODE_AF_PP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Pull = GPIO_PULLUP,
		.Alternate = GPIO_AF2_TIM4,
};
static const struct stm32f4_gpio stm32f4_pwm_t4c3_gpio = {
		.port = GPIOD,
		.pin = &port_cfg_D14,
};

static struct stm32f4_pwm str32f4_pwm_3 = {
		.pwm_gpio = &stm32f4_pwm_t4c3_gpio,
		.timer_handle = &tim4_handle,
		.output_compare_cfg = &t4_output_compare_cfg,
		.channel = TIM_CHANNEL_3,
};

static const struct pwm pwm_ch3 = {
		.arch_dep_device = &str32f4_pwm_3,
		.fp = &stm32f4_pwm_fp,
};

#ifdef TEST_APP
static const struct driver pwm_3 = {
#else
const struct driver pwm_3 = {
#endif
		DRIVER_TYPE_PWM,
		&pwm_ch3,
};

// PWM Channel 2
static const GPIO_InitTypeDef port_cfg_D13 = {
		.Pin = GPIO_PIN_13,
		.Mode = GPIO_MODE_AF_PP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Pull = GPIO_PULLUP,
		.Alternate = GPIO_AF2_TIM4,
};
static const struct stm32f4_gpio stm32f4_pwm_t4c2_gpio = {
		.port = GPIOD,
		.pin = &port_cfg_D13,
};

static struct stm32f4_pwm str32f4_pwm_2 = {
		.pwm_gpio = &stm32f4_pwm_t4c2_gpio,
		.timer_handle = &tim4_handle,
		.output_compare_cfg = &t4_output_compare_cfg,
		.channel = TIM_CHANNEL_2,
};

static const struct pwm pwm_ch2 = {
		.arch_dep_device = &str32f4_pwm_2,
		.fp = &stm32f4_pwm_fp,
};

#ifdef TEST_APP
static const struct driver pwm_2 = {
#else
const struct driver pwm_2 = {
#endif
		DRIVER_TYPE_PWM,
		&pwm_ch2,
};

// PWM Channel 1
static const GPIO_InitTypeDef port_cfg_D12 = {
		.Pin = GPIO_PIN_12,
		.Mode = GPIO_MODE_AF_PP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Pull = GPIO_PULLUP,
		.Alternate = GPIO_AF2_TIM4,
};
static const struct stm32f4_gpio stm32f4_pwm_t4c1_gpio = {
		.port = GPIOD,
		.pin = &port_cfg_D12,
};

static struct stm32f4_pwm str32f4_pwm_1 = {
		.pwm_gpio = &stm32f4_pwm_t4c1_gpio,
		.timer_handle = &tim4_handle,
		.output_compare_cfg = &t4_output_compare_cfg,
		.channel = TIM_CHANNEL_1,
};

static const struct pwm pwm_ch1 = {
		.arch_dep_device = &str32f4_pwm_1,
		.fp = &stm32f4_pwm_fp,
};

#ifdef TEST_APP
static const struct driver pwm_1 = {
#else
const struct driver pwm_1 = {
#endif
		DRIVER_TYPE_PWM,
		&pwm_ch1,
};

// UART 1
static const GPIO_InitTypeDef port_cfg_uart1 = {
		.Pin = GPIO_PIN_6 | GPIO_PIN_7,
		.Mode = GPIO_MODE_AF_PP,
		.Pull = GPIO_PULLUP,
		.Speed = GPIO_SPEED_FREQ_HIGH,
		.Alternate = GPIO_AF7_USART1,
};

static const struct stm32f4_gpio stm32f4_uart1_gpio = {
		.port = GPIOB,
		.pin = &port_cfg_uart1,
};

static UART_HandleTypeDef stm32f4_discovery_uart1_handle = {
		.Instance = USART1,
		.Init.BaudRate = 115200,
		.Init.WordLength = UART_WORDLENGTH_8B,
		.Init.StopBits = UART_STOPBITS_1,
		.Init.Parity = UART_PARITY_NONE,
		.Init.Mode = UART_MODE_TX_RX,
		.Init.HwFlowCtl = UART_HWCONTROL_NONE,
		.Init.OverSampling = UART_OVERSAMPLING_16,
		.pTxBuffPtr = NULL,
		.TxXferSize = 0,
		.TxXferCount = 0,
		.pRxBuffPtr = NULL,
		.RxXferSize = 0,
		.RxXferCount = 0,
		.hdmatx = NULL,
		.hdmarx = NULL,
		.Lock = HAL_UNLOCKED,
		.gState = HAL_UART_STATE_RESET,
		.ErrorCode = 0,
};

static const struct stm32f4_uart stm32f4_uart1 = {
		.uart_gpio = &stm32f4_uart1_gpio,
		.uart_handle = &stm32f4_discovery_uart1_handle,
};

static char console_linear_buffer[10];
static struct ringbuffer console_buffer = {
		console_linear_buffer,
		console_linear_buffer,
		console_linear_buffer,
		10,
		0
};

static const struct uart __uart_1 = {
		&stm32f4_uart1,
		&stm32f4_uart_fp,
		&console_buffer,
};

#ifdef TEST_APP
static const struct driver uart_1 = {
#else
const struct driver uart_1 = {
#endif
		DRIVER_TYPE_UART,
		&__uart_1,
};

#if 0
// GPIOC0
static const GPIO_InitTypeDef port_cfg_C0 = {
		GPIO_Pin_0,
		GPIO_Mode_OUT,
		GPIO_Speed_100MHz,
		GPIO_OType_PP,
		GPIO_PuPd_NOPULL
};

static const struct stm32f4_gpio stm32_f4_gpio_C0 = {
		GPIOC,
		&port_cfg_C0,
		NULL,
		NULL,
		NULL,
		NULL
};

static const struct gpio __gpio_c0 = {
		(void*)&stm32_f4_gpio_C0,
		&gpio_fp
};

#ifdef TEST_APP
static const struct driver gpio_c0 = {
#else
const struct driver gpio_c0 = {
#endif
		DRIVER_TYPE_GPIO,
		&__gpio_c0,
};
#endif
#if 0
// GPIO_C1
static const GPIO_InitTypeDef port_cfg_C1 = {
		GPIO_Pin_1,
		GPIO_Mode_OUT,
		GPIO_Speed_100MHz,
		GPIO_OType_PP,
		GPIO_PuPd_NOPULL
};

static const struct stm32f4_gpio stm32_f4_gpio_C1 = {
		GPIOC,
		&port_cfg_C1,
		NULL,
		NULL,
		NULL,
		NULL
};

static const struct gpio __gpio_c1 = {
		(void*)&stm32_f4_gpio_C1,
		&gpio_fp
};

#ifdef TEST_APP
static const struct driver gpio_c1 = {
#else
const struct driver gpio_c1 = {
#endif
		DRIVER_TYPE_GPIO,
		&__gpio_c1,
};
#endif
#if 0
// GPIO_C2
static const GPIO_InitTypeDef port_cfg_C2 = {
		GPIO_Pin_2,
		GPIO_Mode_OUT,
		GPIO_Speed_100MHz,
		GPIO_OType_PP,
		GPIO_PuPd_NOPULL
};

static const struct stm32f4_gpio stm32_f4_gpio_C2 = {
		GPIOC,
		&port_cfg_C2,
		NULL,
		NULL,
		NULL,
		NULL
};

static const struct gpio __gpio_c2 = {
		(void*)&stm32_f4_gpio_C2,
		&gpio_fp
};

#ifdef TEST_APP
static const struct driver gpio_c2 = {
#else
const struct driver gpio_c2 = {
#endif
		DRIVER_TYPE_GPIO,
		&__gpio_c2,
};
#endif
#if 0
// GPIO_C3
static const GPIO_InitTypeDef port_cfg_C3 = {
		GPIO_Pin_3,
		GPIO_Mode_OUT,
		GPIO_Speed_100MHz,
		GPIO_OType_PP,
		GPIO_PuPd_NOPULL
};

static const struct stm32f4_gpio stm32_f4_gpio_C3 = {
		GPIOC,
		&port_cfg_C3,
		NULL,
		NULL,
		NULL,
		NULL
};

static const struct gpio __gpio_c3 = {
		(void*)&stm32_f4_gpio_C3,
		&gpio_fp
};

#ifdef TEST_APP
static const struct driver gpio_c3 = {
#else
const struct driver gpio_c3 = {
#endif
		DRIVER_TYPE_GPIO,
		&__gpio_c3,
};
#endif
//! \brief Setup the hardware of the stm32f4-discovery board.
void board_init(void);

#endif /* BSP_STM32F4_DISCOVERY_H_ */