/**
* @brief SPI initialization function
* @param obj : pointer to spi_t structure
* @param speed : spi output speed
* @param mode : one of the spi modes
* @param msb : set to 1 in msb first
* @retval None
*/
void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
{
if(obj == NULL)
return;
SPI_HandleTypeDef *handle = &(obj->handle);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_TypeDef *port;
uint32_t spi_freq = 0;
// Determine the SPI to use
SPI_TypeDef *spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI);
SPI_TypeDef *spi_miso = pinmap_peripheral(obj->pin_miso, PinMap_SPI_MISO);
SPI_TypeDef *spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK);
SPI_TypeDef *spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL);
/* Pins MOSI/MISO/SCLK must not be NP. ssel can be NP. */
if(spi_mosi == NP || spi_miso == NP || spi_sclk == NP) {
printf("ERROR: at least one SPI pin has no peripheral\n");
return;
}
SPI_TypeDef *spi_data = pinmap_merge_peripheral(spi_mosi, spi_miso);
SPI_TypeDef *spi_cntl = pinmap_merge_peripheral(spi_sclk, spi_ssel);
obj->spi = pinmap_merge_peripheral(spi_data, spi_cntl);
// Are all pins connected to the same SPI instance?
if(obj->spi == NP) {
printf("ERROR: SPI pins mismatch\n");
return;
}
// Configure the SPI pins
if (obj->pin_ssel != NC) {
handle->Init.NSS = SPI_NSS_HARD_OUTPUT;
} else {
handle->Init.NSS = SPI_NSS_SOFT;
}
/* Fill default value */
handle->Instance = obj->spi;
handle->Init.Mode = SPI_MODE_MASTER;
spi_freq = spi_getClkFreqInst(obj->spi);
if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
} else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
} else {
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
}
handle->Init.Direction = SPI_DIRECTION_2LINES;
if((mode == SPI_MODE_0)||(mode == SPI_MODE_2)) {
handle->Init.CLKPhase = SPI_PHASE_1EDGE;
} else {
handle->Init.CLKPhase = SPI_PHASE_2EDGE;
}
if((mode == SPI_MODE_0)||(mode == SPI_MODE_1)) {
handle->Init.CLKPolarity = SPI_POLARITY_LOW;
} else {
handle->Init.CLKPolarity = SPI_POLARITY_HIGH;
}
handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
handle->Init.CRCPolynomial = 7;
handle->Init.DataSize = SPI_DATASIZE_8BIT;
if(msb == 0) {
handle->Init.FirstBit = SPI_FIRSTBIT_LSB;
} else {
handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
}
handle->Init.TIMode = SPI_TIMODE_DISABLE;
#if defined(STM32F0xx) || defined(STM32F3xx) || defined(STM32F7xx) || defined(STM32L4xx)
handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
#endif
if(obj->pin_mosi != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_miso != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_sclk != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
/*
* According the STM32 Datasheet for SPI peripheral we need to PULLDOWN
* or PULLUP the SCK pin according the polarity used.
*/
if(handle->Init.CLKPolarity == SPI_POLARITY_LOW) {
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
} else {
GPIO_InitStruct.Pull = GPIO_PULLUP;
}
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
if(obj->pin_ssel != NC) {
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel));
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel);
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
#ifdef STM32F1xx
pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)));
#else
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
#endif /* STM32F1xx */
HAL_GPIO_Init(port, &GPIO_InitStruct);
}
#if defined SPI1_BASE
// Enable SPI clock
if (handle->Instance == SPI1) {
__HAL_RCC_SPI1_CLK_ENABLE();
}
#endif
#if defined SPI2_BASE
if (handle->Instance == SPI2) {
__HAL_RCC_SPI2_CLK_ENABLE();
}
#endif
#if defined SPI3_BASE
if (handle->Instance == SPI3) {
__HAL_RCC_SPI3_CLK_ENABLE();
}
#endif
#if defined SPI4_BASE
if (handle->Instance == SPI4) {
__HAL_RCC_SPI4_CLK_ENABLE();
}
#endif
#if defined SPI5_BASE
if (handle->Instance == SPI5) {
__HAL_RCC_SPI5_CLK_ENABLE();
}
#endif
#if defined SPI6_BASE
if (handle->Instance == SPI6) {
__HAL_RCC_SPI6_CLK_ENABLE();
}
#endif
HAL_SPI_Init(handle);
/* In order to set correctly the SPI polarity we need to enable the peripheral */
__HAL_SPI_ENABLE(handle);
}
/* Private functions */
static void TM_SPIx_Init(SPI_TypeDef* SPIx, TM_SPI_PinsPack_t pinspack, TM_SPI_Mode_t SPI_Mode, uint16_t SPI_BaudRatePrescaler, uint16_t SPI_MasterSlave, uint16_t SPI_FirstBit) {
SPI_HandleTypeDef SPIHandle;
/* Save instance */
SPIHandle.Instance = SPIx;
#ifdef SPI1
if (SPIx == SPI1) {
/* Enable SPI clock */
__HAL_RCC_SPI1_CLK_ENABLE();
/* Init pins */
TM_SPI1_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI1_DATASIZE;
}
#endif
#ifdef SPI2
if (SPIx == SPI2) {
/* Enable SPI clock */
__HAL_RCC_SPI2_CLK_ENABLE();
/* Init pins */
TM_SPI2_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI2_DATASIZE;
}
#endif
#ifdef SPI3
if (SPIx == SPI3) {
/* Enable SPI clock */
__HAL_RCC_SPI3_CLK_ENABLE();
/* Init pins */
TM_SPI3_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI3_DATASIZE;
}
#endif
#ifdef SPI4
if (SPIx == SPI4) {
/* Enable SPI clock */
__HAL_RCC_SPI4_CLK_ENABLE();
/* Init pins */
TM_SPI4_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI4_DATASIZE;
}
#endif
#ifdef SPI5
if (SPIx == SPI5) {
/* Enable SPI clock */
__HAL_RCC_SPI5_CLK_ENABLE();
/* Init pins */
TM_SPI5_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI5_DATASIZE;
}
#endif
#ifdef SPI6
if (SPIx == SPI6) {
/* Enable SPI clock */
__HAL_RCC_SPI6_CLK_ENABLE();
/* Init pins */
TM_SPI6_INT_InitPins(pinspack);
/* Set options */
SPIHandle.Init.DataSize = TM_SPI6_DATASIZE;
}
#endif
/* Fill SPI settings */
SPIHandle.Init.BaudRatePrescaler = SPI_BaudRatePrescaler;
SPIHandle.Init.FirstBit = SPI_FirstBit;
SPIHandle.Init.Mode = SPI_MasterSlave;
SPIHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
SPIHandle.Init.CRCPolynomial = 7;
SPIHandle.Init.TIMode = SPI_TIMODE_DISABLE;
SPIHandle.Init.NSS = SPI_NSS_SOFT;
SPIHandle.Init.Direction = SPI_DIRECTION_2LINES;
#if defined(STM32F7xx)
SPIHandle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
SPIHandle.Init.CRCLength = SPI_CRC_LENGTH_8BIT;
#endif
/* SPI mode */
if (SPI_Mode == TM_SPI_Mode_0) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
} else if (SPI_Mode == TM_SPI_Mode_1) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
} else if (SPI_Mode == TM_SPI_Mode_2) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
} else if (SPI_Mode == TM_SPI_Mode_3) {
SPIHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SPIHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
}
/* Disable first */
__HAL_SPI_DISABLE(&SPIHandle);
/* Init SPI */
HAL_SPI_Init(&SPIHandle);
/* Enable SPI */
__HAL_SPI_ENABLE(&SPIHandle);
}
int
hal_spi_config(int spi_num, struct hal_spi_settings *settings)
{
struct stm32_hal_spi *spi;
struct stm32_hal_spi_cfg *cfg;
SPI_InitTypeDef *init;
GPIO_InitTypeDef gpio;
uint32_t gpio_speed;
IRQn_Type irq;
uint32_t prescaler;
int rc;
int sr;
__HAL_DISABLE_INTERRUPTS(sr);
STM32_HAL_SPI_RESOLVE(spi_num, spi);
init = &spi->handle.Init;
cfg = spi->cfg;
if (!spi->slave) {
spi->handle.Init.NSS = SPI_NSS_HARD_OUTPUT;
spi->handle.Init.Mode = SPI_MODE_MASTER;
} else {
spi->handle.Init.NSS = SPI_NSS_SOFT;
spi->handle.Init.Mode = SPI_MODE_SLAVE;
}
gpio.Mode = GPIO_MODE_AF_PP;
gpio.Pull = GPIO_NOPULL;
/* TODO: also VERY_HIGH for STM32L1x */
if (settings->baudrate <= 2000) {
gpio_speed = GPIO_SPEED_FREQ_LOW;
} else if (settings->baudrate <= 12500) {
gpio_speed = GPIO_SPEED_FREQ_MEDIUM;
} else {
gpio_speed = GPIO_SPEED_FREQ_HIGH;
}
/* Enable the clocks for this SPI */
switch (spi_num) {
#if SPI_0_ENABLED
case 0:
__HAL_RCC_SPI1_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF5_SPI1;
#endif
spi->handle.Instance = SPI1;
break;
#endif
#if SPI_1_ENABLED
case 1:
__HAL_RCC_SPI2_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF5_SPI2;
#endif
spi->handle.Instance = SPI2;
break;
#endif
#if SPI_2_ENABLED
case 2:
__HAL_RCC_SPI3_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF6_SPI3;
#endif
spi->handle.Instance = SPI3;
break;
#endif
#if SPI_3_ENABLED
case 3:
__HAL_RCC_SPI4_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF5_SPI4;
#endif
spi->handle.Instance = SPI4;
break;
#endif
#if SPI_4_ENABLED
case 4:
__HAL_RCC_SPI5_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF5_SPI5;
#endif
spi->handle.Instance = SPI5;
break;
#endif
#if SPI_5_ENABLED
case 5:
__HAL_RCC_SPI6_CLK_ENABLE();
#if !defined(STM32F1)
gpio.Alternate = GPIO_AF5_SPI6;
#endif
spi->handle.Instance = SPI6;
break;
#endif
default:
assert(0);
rc = -1;
goto err;
}
if (!spi->slave) {
if (settings->data_mode == HAL_SPI_MODE2 ||
settings->data_mode == HAL_SPI_MODE3) {
gpio.Pull = GPIO_PULLUP;
} else {
gpio.Pull = GPIO_PULLDOWN;
}
}
/* NOTE: Errata ES0125: STM32L100x6/8/B, STM32L151x6/8/B and
* STM32L152x6/8/B ultra-low-power device limitations.
*
* 2.6.6 - Corrupted last bit of data and or CRC, received in Master
* mode with delayed SCK feedback
*
* This driver is always using very high speed for SCK on STM32L1x
*/
#if defined(STM32L152xC)
if (!spi->slave) {
gpio.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
} else {
gpio.Speed = gpio_speed;
}
#else
gpio.Speed = gpio_speed;
#endif
rc = hal_gpio_init_stm(cfg->sck_pin, &gpio);
if (rc != 0) {
goto err;
}
#if defined(STM32L152xC)
if (!spi->slave) {
gpio.Speed = gpio_speed;
}
#endif
if (!spi->slave) {
gpio.Pull = GPIO_NOPULL;
} else {
gpio.Mode = GPIO_MODE_AF_OD;
}
rc = hal_gpio_init_stm(cfg->mosi_pin, &gpio);
if (rc != 0) {
goto err;
}
if (!spi->slave) {
gpio.Mode = GPIO_MODE_AF_OD;
} else {
gpio.Mode = GPIO_MODE_AF_PP;
}
rc = hal_gpio_init_stm(cfg->miso_pin, &gpio);
if (rc != 0) {
goto err;
}
switch (settings->data_mode) {
case HAL_SPI_MODE0:
init->CLKPolarity = SPI_POLARITY_LOW;
init->CLKPhase = SPI_PHASE_1EDGE;
break;
case HAL_SPI_MODE1:
init->CLKPolarity = SPI_POLARITY_LOW;
init->CLKPhase = SPI_PHASE_2EDGE;
break;
case HAL_SPI_MODE2:
init->CLKPolarity = SPI_POLARITY_HIGH;
init->CLKPhase = SPI_PHASE_1EDGE;
break;
case HAL_SPI_MODE3:
init->CLKPolarity = SPI_POLARITY_HIGH;
init->CLKPhase = SPI_PHASE_2EDGE;
break;
default:
rc = -1;
goto err;
}
switch (settings->data_order) {
case HAL_SPI_MSB_FIRST:
init->FirstBit = SPI_FIRSTBIT_MSB;
break;
case HAL_SPI_LSB_FIRST:
init->FirstBit = SPI_FIRSTBIT_LSB;
break;
default:
rc = -1;
goto err;
}
switch (settings->word_size) {
case HAL_SPI_WORD_SIZE_8BIT:
init->DataSize = SPI_DATASIZE_8BIT;
break;
case HAL_SPI_WORD_SIZE_9BIT:
init->DataSize = SPI_DATASIZE_16BIT;
break;
default:
rc = -1;
goto err;
}
rc = stm32_spi_resolve_prescaler(spi_num, settings->baudrate * 1000, &prescaler);
if (rc != 0) {
goto err;
}
init->BaudRatePrescaler = prescaler;
/* Add default values */
init->Direction = SPI_DIRECTION_2LINES;
init->TIMode = SPI_TIMODE_DISABLE;
init->CRCCalculation = SPI_CRCCALCULATION_DISABLE;
init->CRCPolynomial = 1;
#ifdef SPI_NSS_PULSE_DISABLE
init->NSSPMode = SPI_NSS_PULSE_DISABLE;
#endif
irq = stm32_resolve_spi_irq(&spi->handle);
NVIC_SetPriority(irq, cfg->irq_prio);
NVIC_SetVector(irq, stm32_resolve_spi_irq_handler(&spi->handle));
NVIC_EnableIRQ(irq);
/* Init, Enable */
rc = HAL_SPI_Init(&spi->handle);
if (rc != 0) {
goto err;
}
if (spi->slave) {
hal_spi_slave_set_def_tx_val(spi_num, 0);
rc = hal_gpio_irq_init(cfg->ss_pin, spi_ss_isr, spi, HAL_GPIO_TRIG_BOTH,
HAL_GPIO_PULL_UP);
spi_ss_isr(spi);
}
__HAL_ENABLE_INTERRUPTS(sr);
return (0);
err:
__HAL_ENABLE_INTERRUPTS(sr);
return (rc);
}
void enableGPIOPowerUsageAndNoiseReductions(void)
{
// AHB1
__HAL_RCC_BKPSRAM_CLK_ENABLE();
__HAL_RCC_DTCMRAMEN_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOI_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_DMA2D_CLK_ENABLE();
__HAL_RCC_GPIOJ_CLK_ENABLE();
__HAL_RCC_GPIOK_CLK_ENABLE();
#endif
//APB1
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_TIM5_CLK_ENABLE();
__HAL_RCC_TIM6_CLK_ENABLE();
__HAL_RCC_TIM7_CLK_ENABLE();
__HAL_RCC_TIM12_CLK_ENABLE();
__HAL_RCC_TIM13_CLK_ENABLE();
__HAL_RCC_TIM14_CLK_ENABLE();
__HAL_RCC_LPTIM1_CLK_ENABLE();
__HAL_RCC_SPI2_CLK_ENABLE();
__HAL_RCC_SPI3_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_UART5_CLK_ENABLE();
__HAL_RCC_I2C1_CLK_ENABLE();
__HAL_RCC_I2C2_CLK_ENABLE();
__HAL_RCC_I2C3_CLK_ENABLE();
__HAL_RCC_CAN1_CLK_ENABLE();
__HAL_RCC_DAC_CLK_ENABLE();
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_UART8_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_I2C4_CLK_ENABLE();
__HAL_RCC_CAN2_CLK_ENABLE();
__HAL_RCC_CEC_CLK_ENABLE();
#endif
//APB2
__HAL_RCC_TIM1_CLK_ENABLE();
__HAL_RCC_TIM8_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_ADC2_CLK_ENABLE();
__HAL_RCC_ADC3_CLK_ENABLE();
__HAL_RCC_SDMMC1_CLK_ENABLE();
__HAL_RCC_SPI1_CLK_ENABLE();
__HAL_RCC_SPI4_CLK_ENABLE();
__HAL_RCC_TIM9_CLK_ENABLE();
__HAL_RCC_TIM10_CLK_ENABLE();
__HAL_RCC_TIM11_CLK_ENABLE();
__HAL_RCC_SPI5_CLK_ENABLE();
__HAL_RCC_SAI1_CLK_ENABLE();
__HAL_RCC_SAI2_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_SPI6_CLK_ENABLE();
#endif
//
// GPIO_InitTypeDef GPIO_InitStructure;
// GPIO_StructInit(&GPIO_InitStructure);
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // default is un-pulled input
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_11 | GPIO_Pin_12); // leave USB D+/D- alone
//
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_13 | GPIO_Pin_14); // leave JTAG pins alone
// GPIO_Init(GPIOA, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOB, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOC, &GPIO_InitStructure);
// GPIO_Init(GPIOD, &GPIO_InitStructure);
// GPIO_Init(GPIOE, &GPIO_InitStructure);
}
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
{
struct spi_s *spiobj = SPI_S(obj);
SPI_HandleTypeDef *handle = &(spiobj->handle);
// Determine the SPI to use
SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI);
SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO);
SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK);
SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL);
SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso);
SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel);
spiobj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl);
MBED_ASSERT(spiobj->spi != (SPIName)NC);
#if defined SPI1_BASE
// Enable SPI clock
if (spiobj->spi == SPI_1) {
__HAL_RCC_SPI1_CLK_ENABLE();
spiobj->spiIRQ = SPI1_IRQn;
}
#endif
#if defined SPI2_BASE
if (spiobj->spi == SPI_2) {
__HAL_RCC_SPI2_CLK_ENABLE();
spiobj->spiIRQ = SPI2_IRQn;
}
#endif
#if defined SPI3_BASE
if (spiobj->spi == SPI_3) {
__HAL_RCC_SPI3_CLK_ENABLE();
spiobj->spiIRQ = SPI3_IRQn;
}
#endif
#if defined SPI4_BASE
if (spiobj->spi == SPI_4) {
__HAL_RCC_SPI4_CLK_ENABLE();
spiobj->spiIRQ = SPI4_IRQn;
}
#endif
#if defined SPI5_BASE
if (spiobj->spi == SPI_5) {
__HAL_RCC_SPI5_CLK_ENABLE();
spiobj->spiIRQ = SPI5_IRQn;
}
#endif
#if defined SPI6_BASE
if (spiobj->spi == SPI_6) {
__HAL_RCC_SPI6_CLK_ENABLE();
spiobj->spiIRQ = SPI6_IRQn;
}
#endif
// Configure the SPI pins
pinmap_pinout(mosi, PinMap_SPI_MOSI);
pinmap_pinout(miso, PinMap_SPI_MISO);
pinmap_pinout(sclk, PinMap_SPI_SCLK);
spiobj->pin_miso = miso;
spiobj->pin_mosi = mosi;
spiobj->pin_sclk = sclk;
spiobj->pin_ssel = ssel;
if (ssel != NC) {
pinmap_pinout(ssel, PinMap_SPI_SSEL);
} else {
handle->Init.NSS = SPI_NSS_SOFT;
}
/* Fill default value */
handle->Instance = SPI_INST(obj);
handle->Init.Mode = SPI_MODE_MASTER;
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
handle->Init.Direction = SPI_DIRECTION_2LINES;
handle->Init.CLKPhase = SPI_PHASE_1EDGE;
handle->Init.CLKPolarity = SPI_POLARITY_LOW;
handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
handle->Init.CRCPolynomial = 7;
handle->Init.DataSize = SPI_DATASIZE_8BIT;
handle->Init.FirstBit = SPI_FIRSTBIT_MSB;
handle->Init.TIMode = SPI_TIMODE_DISABLED;
init_spi(obj);
}
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
{
// Determine the SPI to use
SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI);
SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO);
SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK);
SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL);
SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso);
SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel);
obj->spi = (SPIName)pinmap_merge(spi_data, spi_cntl);
MBED_ASSERT(obj->spi != (SPIName)NC);
// Enable SPI clock
if (obj->spi == SPI_1) {
__HAL_RCC_SPI1_CLK_ENABLE();
}
if (obj->spi == SPI_2) {
__HAL_RCC_SPI2_CLK_ENABLE();
}
if (obj->spi == SPI_3) {
__HAL_RCC_SPI3_CLK_ENABLE();
}
#if defined SPI4_BASE
if (obj->spi == SPI_4) {
__HAL_RCC_SPI4_CLK_ENABLE();
}
#endif
#if defined SPI5_BASE
if (obj->spi == SPI_5) {
__HAL_RCC_SPI5_CLK_ENABLE();
}
#endif
// Configure the SPI pins
pinmap_pinout(mosi, PinMap_SPI_MOSI);
pinmap_pinout(miso, PinMap_SPI_MISO);
pinmap_pinout(sclk, PinMap_SPI_SCLK);
// Save new values
obj->bits = SPI_DATASIZE_8BIT;
obj->cpol = SPI_POLARITY_LOW;
obj->cpha = SPI_PHASE_1EDGE;
obj->br_presc = SPI_BAUDRATEPRESCALER_256;
obj->pin_miso = miso;
obj->pin_mosi = mosi;
obj->pin_sclk = sclk;
obj->pin_ssel = ssel;
if (ssel != NC) {
pinmap_pinout(ssel, PinMap_SPI_SSEL);
} else {
obj->nss = SPI_NSS_SOFT;
}
init_spi(obj);
}
