From 9c1c4fef331b59ddc12563551a88f96bc4e67962 Mon Sep 17 00:00:00 2001 From: blckmn Date: Fri, 3 Jun 2016 22:56:45 +1000 Subject: [PATCH] SPI to new IO (including SDCARD) --- src/main/drivers/accgyro_spi_mpu6000.c | 14 +- src/main/drivers/accgyro_spi_mpu6500.c | 40 +- src/main/drivers/bus_spi.c | 780 +++++++++---------------- src/main/drivers/bus_spi.h | 59 +- src/main/drivers/compass_ak8963.c | 16 +- src/main/drivers/compass_ak8975.c | 24 +- src/main/drivers/nvic.h | 2 + src/main/drivers/rcc.c | 57 +- src/main/drivers/rcc.h | 2 +- src/main/drivers/resource.h | 1 + src/main/drivers/sdcard.c | 26 +- src/main/main.c | 10 +- src/main/target/ALIENFLIGHTF3/target.h | 12 +- src/main/target/CHEBUZZF3/target.h | 15 +- src/main/target/COLIBRI_RACE/target.h | 19 +- src/main/target/LUX_RACE/target.h | 11 +- src/main/target/NAZE/target.h | 2 +- src/main/target/SPRACINGF3/target.h | 2 +- src/main/target/SPRACINGF3EVO/target.h | 36 +- 19 files changed, 471 insertions(+), 657 deletions(-) diff --git a/src/main/drivers/accgyro_spi_mpu6000.c b/src/main/drivers/accgyro_spi_mpu6000.c index c816bca9a..31c7ad6fb 100644 --- a/src/main/drivers/accgyro_spi_mpu6000.c +++ b/src/main/drivers/accgyro_spi_mpu6000.c @@ -32,9 +32,10 @@ #include "common/maths.h" #include "system.h" -#include "gpio.h" +#include "io.h" #include "exti.h" #include "bus_spi.h" + #include "gyro_sync.h" #include "sensor.h" @@ -96,9 +97,10 @@ static bool mpuSpi6000InitDone = false; #define MPU6000_REV_D9 0x59 #define MPU6000_REV_D10 0x5A -#define DISABLE_MPU6000 GPIO_SetBits(MPU6000_CS_GPIO, MPU6000_CS_PIN) -#define ENABLE_MPU6000 GPIO_ResetBits(MPU6000_CS_GPIO, MPU6000_CS_PIN) +#define DISABLE_MPU6000 IOHi(mpuSpi6000CsPin) +#define ENABLE_MPU6000 IOLo(mpuSpi6000CsPin) +static IO_t mpuSpi6000CsPin = IO_NONE; bool mpu6000WriteRegister(uint8_t reg, uint8_t data) { @@ -154,6 +156,12 @@ bool mpu6000SpiDetect(void) uint8_t in; uint8_t attemptsRemaining = 5; +#ifdef MPU6000_CS_PIN + mpuSpi6000CsPin = IOGetByTag(IO_TAG(MPU6000_CS_PIN)); +#endif + IOInit(mpuSpi6000CsPin, OWNER_SYSTEM, RESOURCE_SPI); + IOConfigGPIO(mpuSpi6000CsPin, SPI_IO_CS_CFG); + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); diff --git a/src/main/drivers/accgyro_spi_mpu6500.c b/src/main/drivers/accgyro_spi_mpu6500.c index 5b71f1725..3cc8ab1ed 100755 --- a/src/main/drivers/accgyro_spi_mpu6500.c +++ b/src/main/drivers/accgyro_spi_mpu6500.c @@ -26,7 +26,7 @@ #include "system.h" #include "exti.h" -#include "gpio.h" +#include "io.h" #include "bus_spi.h" #include "sensor.h" @@ -35,8 +35,10 @@ #include "accgyro_mpu6500.h" #include "accgyro_spi_mpu6500.h" -#define DISABLE_MPU6500 GPIO_SetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN) -#define ENABLE_MPU6500 GPIO_ResetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN) +#define DISABLE_MPU6500 IOHi(mpuSpi6500CsPin) +#define ENABLE_MPU6500 IOLo(mpuSpi6500CsPin) + +static IO_t mpuSpi6500CsPin = IO_NONE; extern uint16_t acc_1G; @@ -68,34 +70,16 @@ static void mpu6500SpiInit(void) return; } -#ifdef STM32F303xC - RCC_AHBPeriphClockCmd(MPU6500_CS_GPIO_CLK_PERIPHERAL, ENABLE); + mpuSpi6500CsPin = IOGetByTag(IO_TAG(MPU6500_CS_PIN)); + IOInit(mpuSpi6500CsPin, OWNER_SYSTEM, RESOURCE_SPI); + IOConfigGPIO(mpuSpi6500CsPin, SPI_IO_CS_CFG); - GPIO_InitTypeDef GPIO_InitStructure; - GPIO_InitStructure.GPIO_Pin = MPU6500_CS_PIN; - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - - GPIO_Init(MPU6500_CS_GPIO, &GPIO_InitStructure); +#if defined(STM32F4) + spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_SLOW_CLOCK); +#else + spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_STANDARD_CLOCK); #endif -#ifdef STM32F10X - RCC_APB2PeriphClockCmd(MPU6500_CS_GPIO_CLK_PERIPHERAL, ENABLE); - - gpio_config_t gpio; - // CS as output - gpio.mode = Mode_Out_PP; - gpio.pin = MPU6500_CS_PIN; - gpio.speed = Speed_50MHz; - gpioInit(MPU6500_CS_GPIO, &gpio); -#endif - - GPIO_SetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN); - - spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_9MHZ_CLOCK_DIVIDER); - hardwareInitialised = true; } diff --git a/src/main/drivers/bus_spi.c b/src/main/drivers/bus_spi.c index a3a2a8c5d..9dc5c4dff 100644 --- a/src/main/drivers/bus_spi.c +++ b/src/main/drivers/bus_spi.c @@ -22,457 +22,219 @@ #include "build_config.h" -#include "gpio.h" - #include "bus_spi.h" +#include "io.h" +#include "io_impl.h" +#include "rcc.h" +/* for F30x processors */ +#if defined(STM32F303xC) +#ifndef GPIO_AF_SPI1 +#define GPIO_AF_SPI1 GPIO_AF_5 +#endif +#ifndef GPIO_AF_SPI2 +#define GPIO_AF_SPI2 GPIO_AF_5 +#endif +#ifndef GPIO_AF_SPI3 +#define GPIO_AF_SPI3 GPIO_AF_6 +#endif +#endif + +#ifndef SPI1_SCK_PIN +#define SPI1_NSS_PIN PA4 +#define SPI1_SCK_PIN PA5 +#define SPI1_MISO_PIN PA6 +#define SPI1_MOSI_PIN PA7 +#endif + +#ifndef SPI2_SCK_PIN +#define SPI2_NSS_PIN PB12 +#define SPI2_SCK_PIN PB13 +#define SPI2_MISO_PIN PB14 +#define SPI2_MOSI_PIN PB15 +#endif + +#ifndef SPI3_SCK_PIN +#define SPI3_NSS_PIN PA15 +#define SPI3_SCK_PIN PB3 +#define SPI3_MISO_PIN PB4 +#define SPI3_MOSI_PIN PB5 +#endif + +#ifndef SPI1_NSS_PIN +#define SPI1_NSS_PIN NONE +#endif +#ifndef SPI2_NSS_PIN +#define SPI2_NSS_PIN NONE +#endif +#ifndef SPI3_NSS_PIN +#define SPI3_NSS_PIN NONE +#endif + +static spiDevice_t spiHardwareMap[] = { +#if defined(STM32F10X) + { .dev = SPI1, .nss = IO_TAG(SPI1_NSS_PIN), .sck = IO_TAG(SPI1_SCK_PIN), .miso = IO_TAG(SPI1_MISO_PIN), .mosi = IO_TAG(SPI1_MOSI_PIN), .rcc = RCC_APB2(SPI1), .af = 0, false }, + { .dev = SPI2, .nss = IO_TAG(SPI2_NSS_PIN), .sck = IO_TAG(SPI2_SCK_PIN), .miso = IO_TAG(SPI2_MISO_PIN), .mosi = IO_TAG(SPI2_MOSI_PIN), .rcc = RCC_APB1(SPI2), .af = 0, false }, +#else + { .dev = SPI1, .nss = IO_TAG(SPI1_NSS_PIN), .sck = IO_TAG(SPI1_SCK_PIN), .miso = IO_TAG(SPI1_MISO_PIN), .mosi = IO_TAG(SPI1_MOSI_PIN), .rcc = RCC_APB2(SPI1), .af = GPIO_AF_SPI1, false }, + { .dev = SPI2, .nss = IO_TAG(SPI2_NSS_PIN), .sck = IO_TAG(SPI2_SCK_PIN), .miso = IO_TAG(SPI2_MISO_PIN), .mosi = IO_TAG(SPI2_MOSI_PIN), .rcc = RCC_APB1(SPI2), .af = GPIO_AF_SPI2, false }, +#endif +#if defined(STM32F303xC) || defined(STM32F40_41xxx) || defined(STM32F411xE) + { .dev = SPI3, .nss = IO_TAG(SPI3_NSS_PIN), .sck = IO_TAG(SPI3_SCK_PIN), .miso = IO_TAG(SPI3_MISO_PIN), .mosi = IO_TAG(SPI3_MOSI_PIN), .rcc = RCC_APB1(SPI3), .af = GPIO_AF_SPI3, false } +#endif +}; + +SPIDevice spiDeviceByInstance(SPI_TypeDef *instance) +{ + if (instance == SPI1) + return SPIDEV_1; + + if (instance == SPI2) + return SPIDEV_2; + + if (instance == SPI3) + return SPIDEV_3; + + return SPIINVALID; +} + +void spiInitDevice(SPIDevice device) +{ + SPI_InitTypeDef spiInit; + + spiDevice_t *spi = &(spiHardwareMap[device]); + +#ifdef SDCARD_SPI_INSTANCE + if (spi->dev == SDCARD_SPI_INSTANCE) + spi->sdcard = true; +#endif + + // Enable SPI clock + RCC_ClockCmd(spi->rcc, ENABLE); + RCC_ResetCmd(spi->rcc, ENABLE); + + IOInit(IOGetByTag(spi->sck), OWNER_SYSTEM, RESOURCE_SPI); + IOInit(IOGetByTag(spi->miso), OWNER_SYSTEM, RESOURCE_SPI); + IOInit(IOGetByTag(spi->mosi), OWNER_SYSTEM, RESOURCE_SPI); + +#if defined(STM32F303xC) || defined(STM32F40_41xxx) || defined(STM32F411xE) + if (spi->sdcard) { + IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG, spi->af); + IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->af); + } + else { + IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_CFG, spi->af); + IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_CFG, spi->af); + } + IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af); + + if (spi->nss) + IOConfigGPIOAF(IOGetByTag(spi->nss), SPI_IO_CS_CFG, spi->af); +#endif +#if defined(STM32F10X) + IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_CFG); + IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_CFG); + IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_CFG); + + if (spi->nss) + IOConfigGPIO(IOGetByTag(spi->nss), SPI_IO_CS_CFG); +#endif + + // Init SPI hardware + SPI_I2S_DeInit(spi->dev); + + spiInit.SPI_Mode = SPI_Mode_Master; + spiInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex; + spiInit.SPI_DataSize = SPI_DataSize_8b; + spiInit.SPI_NSS = SPI_NSS_Soft; + spiInit.SPI_FirstBit = SPI_FirstBit_MSB; + spiInit.SPI_CRCPolynomial = 7; + spiInit.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; + + if (spi->sdcard) { + spiInit.SPI_CPOL = SPI_CPOL_Low; + spiInit.SPI_CPHA = SPI_CPHA_1Edge; + } + else { + spiInit.SPI_CPOL = SPI_CPOL_High; + spiInit.SPI_CPHA = SPI_CPHA_2Edge; + } + +#ifdef STM32F303xC + // Configure for 8-bit reads. + SPI_RxFIFOThresholdConfig(spi->dev, SPI_RxFIFOThreshold_QF); +#endif + + SPI_Init(spi->dev, &spiInit); + SPI_Cmd(spi->dev, ENABLE); + + if (spi->nss) + IOHi(IOGetByTag(spi->nss)); +} + +bool spiInit(SPIDevice device) +{ + switch (device) + { + case SPIINVALID: + return false; + case SPIDEV_1: #ifdef USE_SPI_DEVICE_1 - -#ifndef SPI1_GPIO -#define SPI1_GPIO GPIOA -#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOA -#define SPI1_NSS_PIN GPIO_Pin_4 -#define SPI1_NSS_PIN_SOURCE GPIO_PinSource4 -#define SPI1_SCK_PIN GPIO_Pin_5 -#define SPI1_SCK_PIN_SOURCE GPIO_PinSource5 -#define SPI1_MISO_PIN GPIO_Pin_6 -#define SPI1_MISO_PIN_SOURCE GPIO_PinSource6 -#define SPI1_MOSI_PIN GPIO_Pin_7 -#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource7 -#endif - -void initSpi1(void) -{ - // Specific to the STM32F103 - // SPI1 Driver - // PA4 14 SPI1_NSS - // PA5 15 SPI1_SCK - // PA6 16 SPI1_MISO - // PA7 17 SPI1_MOSI - - SPI_InitTypeDef spi; - - // Enable SPI1 clock - RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); - RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE); - -#ifdef STM32F303xC - GPIO_InitTypeDef GPIO_InitStructure; - - RCC_AHBPeriphClockCmd(SPI1_GPIO_PERIPHERAL, ENABLE); - - GPIO_PinAFConfig(SPI1_GPIO, SPI1_SCK_PIN_SOURCE, GPIO_AF_5); - GPIO_PinAFConfig(SPI1_GPIO, SPI1_MISO_PIN_SOURCE, GPIO_AF_5); - GPIO_PinAFConfig(SPI1_GPIO, SPI1_MOSI_PIN_SOURCE, GPIO_AF_5); - -#ifdef SPI1_NSS_PIN_SOURCE - GPIO_PinAFConfig(SPI1_GPIO, SPI1_NSS_PIN_SOURCE, GPIO_AF_5); -#endif - - // Init pins - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - -#ifdef USE_SDCARD_SPI1 - // Configure pins and pullups for SD-card use - - // No pull-up needed since we drive this pin as an output - GPIO_InitStructure.GPIO_Pin = SPI1_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); - - // Prevent MISO pin from floating when SDCard is deselected (high-Z) or not connected - GPIO_InitStructure.GPIO_Pin = SPI1_MISO_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; - GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); - - // In clock-low mode, STM32 manual says we should enable a pulldown to match - GPIO_InitStructure.GPIO_Pin = SPI1_SCK_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; - GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); + spiInitDevice(device); + return true; #else - // General-purpose pin config - GPIO_InitStructure.GPIO_Pin = SPI1_SCK_PIN | SPI1_MISO_PIN | SPI1_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); + break; #endif - -#ifdef SPI1_NSS_PIN - GPIO_InitStructure.GPIO_Pin = SPI1_NSS_PIN; - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - - GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); -#endif -#endif - -#ifdef STM32F10X - gpio_config_t gpio; - - // MOSI + SCK as output - gpio.mode = Mode_AF_PP; - gpio.pin = SPI1_MOSI_PIN | SPI1_SCK_PIN; - gpio.speed = Speed_50MHz; - gpioInit(SPI1_GPIO, &gpio); - - // MISO as input - gpio.pin = SPI1_MISO_PIN; - gpio.mode = Mode_IN_FLOATING; - gpioInit(SPI1_GPIO, &gpio); - -#ifdef SPI1_NSS_PIN - // NSS as gpio slave select - gpio.pin = SPI1_NSS_PIN; - gpio.mode = Mode_Out_PP; - gpioInit(SPI1_GPIO, &gpio); -#endif -#endif - - // Init SPI1 hardware - SPI_I2S_DeInit(SPI1); - - spi.SPI_Mode = SPI_Mode_Master; - spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex; - spi.SPI_DataSize = SPI_DataSize_8b; - spi.SPI_NSS = SPI_NSS_Soft; - spi.SPI_FirstBit = SPI_FirstBit_MSB; - spi.SPI_CRCPolynomial = 7; - spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; - -#ifdef USE_SDCARD_SPI1 - spi.SPI_CPOL = SPI_CPOL_Low; - spi.SPI_CPHA = SPI_CPHA_1Edge; -#else - spi.SPI_CPOL = SPI_CPOL_High; - spi.SPI_CPHA = SPI_CPHA_2Edge; -#endif - -#ifdef STM32F303xC - // Configure for 8-bit reads. - SPI_RxFIFOThresholdConfig(SPI1, SPI_RxFIFOThreshold_QF); -#endif - - SPI_Init(SPI1, &spi); - SPI_Cmd(SPI1, ENABLE); - -#ifdef SPI1_NSS_PIN - // Drive NSS high to disable connected SPI device. - GPIO_SetBits(SPI1_GPIO, SPI1_NSS_PIN); -#endif -} -#endif - + case SPIDEV_2: #ifdef USE_SPI_DEVICE_2 - -#ifndef SPI2_GPIO -#define SPI2_GPIO GPIOB -#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI2_NSS_PIN GPIO_Pin_12 -#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12 -#define SPI2_SCK_PIN GPIO_Pin_13 -#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13 -#define SPI2_MISO_PIN GPIO_Pin_14 -#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14 -#define SPI2_MOSI_PIN GPIO_Pin_15 -#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15 -#endif - -void initSpi2(void) -{ - // Specific to the STM32F103 / STM32F303 (AF5) - // SPI2 Driver - // PB12 25 SPI2_NSS - // PB13 26 SPI2_SCK - // PB14 27 SPI2_MISO - // PB15 28 SPI2_MOSI - - SPI_InitTypeDef spi; - - // Enable SPI2 clock - RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); - RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE); - -#ifdef STM32F303xC - GPIO_InitTypeDef GPIO_InitStructure; - - RCC_AHBPeriphClockCmd(SPI2_GPIO_PERIPHERAL, ENABLE); - - GPIO_PinAFConfig(SPI2_GPIO, SPI2_SCK_PIN_SOURCE, GPIO_AF_5); - GPIO_PinAFConfig(SPI2_GPIO, SPI2_MISO_PIN_SOURCE, GPIO_AF_5); - GPIO_PinAFConfig(SPI2_GPIO, SPI2_MOSI_PIN_SOURCE, GPIO_AF_5); - -#ifdef SPI2_NSS_PIN_SOURCE - GPIO_PinAFConfig(SPI2_GPIO, SPI2_NSS_PIN_SOURCE, GPIO_AF_5); -#endif - - // Init pins - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - -#ifdef USE_SDCARD_SPI2 - // Configure pins and pullups for SD-card use - - // No pull-up needed since we drive this pin as an output - GPIO_InitStructure.GPIO_Pin = SPI2_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI2_GPIO, &GPIO_InitStructure); - - // Prevent MISO pin from floating when SDCard is deselected (high-Z) or not connected - GPIO_InitStructure.GPIO_Pin = SPI2_MISO_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; - GPIO_Init(SPI2_GPIO, &GPIO_InitStructure); - - // In clock-low mode, STM32 manual says we should enable a pulldown to match - GPIO_InitStructure.GPIO_Pin = SPI2_SCK_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; - GPIO_Init(SPI2_GPIO, &GPIO_InitStructure); + spiInitDevice(device); + return true; #else - // General-purpose pin config - GPIO_InitStructure.GPIO_Pin = SPI2_SCK_PIN | SPI2_MISO_PIN | SPI2_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI2_GPIO, &GPIO_InitStructure); + break; #endif - -#ifdef SPI2_NSS_PIN - GPIO_InitStructure.GPIO_Pin = SPI2_NSS_PIN; - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - - GPIO_Init(SPI2_GPIO, &GPIO_InitStructure); -#endif -#endif - -#ifdef STM32F10X - gpio_config_t gpio; - - // MOSI + SCK as output - gpio.mode = Mode_AF_PP; - gpio.pin = SPI2_SCK_PIN | SPI2_MOSI_PIN; - gpio.speed = Speed_50MHz; - gpioInit(SPI2_GPIO, &gpio); - - // MISO as input - gpio.pin = SPI2_MISO_PIN; - gpio.mode = Mode_IN_FLOATING; - gpioInit(SPI2_GPIO, &gpio); - -#ifdef SPI2_NSS_PIN - // NSS as gpio slave select - gpio.pin = SPI2_NSS_PIN; - gpio.mode = Mode_Out_PP; - gpioInit(SPI2_GPIO, &gpio); -#endif -#endif - - // Init SPI2 hardware - SPI_I2S_DeInit(SPI2); - - spi.SPI_Mode = SPI_Mode_Master; - spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex; - spi.SPI_DataSize = SPI_DataSize_8b; - spi.SPI_NSS = SPI_NSS_Soft; - spi.SPI_FirstBit = SPI_FirstBit_MSB; - spi.SPI_CRCPolynomial = 7; - spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; - -#ifdef USE_SDCARD_SPI2 - spi.SPI_CPOL = SPI_CPOL_Low; - spi.SPI_CPHA = SPI_CPHA_1Edge; + case SPIDEV_3: +#if defined(USE_SPI_DEVICE_3) && (defined(STM32F303xC) || defined(STM32F40_41xxx) || defined(STM32F411xE)) + spiInitDevice(device); + return true; #else - spi.SPI_CPOL = SPI_CPOL_High; - spi.SPI_CPHA = SPI_CPHA_2Edge; + break; #endif - -#ifdef STM32F303xC - // Configure for 8-bit reads. - SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_QF); -#endif - - SPI_Init(SPI2, &spi); - SPI_Cmd(SPI2, ENABLE); - -#ifdef SPI2_NSS_PIN - // Drive NSS high to disable connected SPI device. - GPIO_SetBits(SPI2_GPIO, SPI2_NSS_PIN); -#endif -} -#endif - -#if defined(USE_SPI_DEVICE_3) && defined(STM32F303xC) - -#ifndef SPI3_GPIO -#define SPI3_GPIO GPIOB -#define SPI3_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI3_NSS_GPIO GPIOA -#define SPI3_NSS_PERIPHERAL RCC_AHBPeriph_GPIOA -#define SPI3_NSS_PIN GPIO_Pin_15 -#define SPI3_NSS_PIN_SOURCE GPIO_PinSource15 -#define SPI3_SCK_PIN GPIO_Pin_3 -#define SPI3_SCK_PIN_SOURCE GPIO_PinSource3 -#define SPI3_MISO_PIN GPIO_Pin_4 -#define SPI3_MISO_PIN_SOURCE GPIO_PinSource4 -#define SPI3_MOSI_PIN GPIO_Pin_5 -#define SPI3_MOSI_PIN_SOURCE GPIO_PinSource5 -#endif - -void initSpi3(void) -{ - // Specific to the STM32F303 (AF6) - // SPI3 Driver - // PA15 38 SPI3_NSS - // PB3 39 SPI3_SCK - // PB4 40 SPI3_MISO - // PB5 41 SPI3_MOSI - - SPI_InitTypeDef spi; - - // Enable SPI3 clock - RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE); - RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI3, ENABLE); - - GPIO_InitTypeDef GPIO_InitStructure; - - RCC_AHBPeriphClockCmd(SPI3_GPIO_PERIPHERAL, ENABLE); - - GPIO_PinAFConfig(SPI3_GPIO, SPI3_SCK_PIN_SOURCE, GPIO_AF_6); - GPIO_PinAFConfig(SPI3_GPIO, SPI3_MISO_PIN_SOURCE, GPIO_AF_6); - GPIO_PinAFConfig(SPI3_GPIO, SPI3_MOSI_PIN_SOURCE, GPIO_AF_6); - -#ifdef SPI2_NSS_PIN_SOURCE - RCC_AHBPeriphClockCmd(SPI3_NNS_PERIPHERAL, ENABLE); - GPIO_PinAFConfig(SPI3_NNS_GPIO, SPI3_NSS_PIN_SOURCE, GPIO_AF_6); -#endif - - // Init pins - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - -#ifdef USE_SDCARD_SPI3 - // Configure pins and pullups for SD-card use - - // No pull-up needed since we drive this pin as an output - GPIO_InitStructure.GPIO_Pin = SPI3_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI3_GPIO, &GPIO_InitStructure); - - // Prevent MISO pin from floating when SDCard is deselected (high-Z) or not connected - GPIO_InitStructure.GPIO_Pin = SPI3_MISO_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; - GPIO_Init(SPI3_GPIO, &GPIO_InitStructure); - - // In clock-low mode, STM32 manual says we should enable a pulldown to match - GPIO_InitStructure.GPIO_Pin = SPI3_SCK_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; - GPIO_Init(SPI3_GPIO, &GPIO_InitStructure); -#else - // General-purpose pin config - GPIO_InitStructure.GPIO_Pin = SPI3_SCK_PIN | SPI3_MISO_PIN | SPI3_MOSI_PIN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - GPIO_Init(SPI3_GPIO, &GPIO_InitStructure); -#endif - -#ifdef SPI3_NSS_PIN - GPIO_InitStructure.GPIO_Pin = SPI3_NSS_PIN; - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; - GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; - GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; - - GPIO_Init(SPI3_NSS_GPIO, &GPIO_InitStructure); -#endif - - // Init SPI hardware - SPI_I2S_DeInit(SPI3); - - spi.SPI_Mode = SPI_Mode_Master; - spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex; - spi.SPI_DataSize = SPI_DataSize_8b; - spi.SPI_NSS = SPI_NSS_Soft; - spi.SPI_FirstBit = SPI_FirstBit_MSB; - spi.SPI_CRCPolynomial = 7; - spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; - -#ifdef USE_SDCARD_SPI3 - spi.SPI_CPOL = SPI_CPOL_Low; - spi.SPI_CPHA = SPI_CPHA_1Edge; -#else - spi.SPI_CPOL = SPI_CPOL_High; - spi.SPI_CPHA = SPI_CPHA_2Edge; -#endif - - // Configure for 8-bit reads. - SPI_RxFIFOThresholdConfig(SPI3, SPI_RxFIFOThreshold_QF); - - SPI_Init(SPI3, &spi); - SPI_Cmd(SPI3, ENABLE); - -#ifdef SPI3_NSS_PIN - // Drive NSS high to disable connected SPI device. - GPIO_SetBits(SPI3_NSS_GPIO, SPI3_NSS_PIN); -#endif -} -#endif - -bool spiInit(SPI_TypeDef *instance) -{ -#if (!(defined(USE_SPI_DEVICE_1) && defined(USE_SPI_DEVICE_2) && defined(USE_SPI_DEVICE_3))) - UNUSED(instance); -#endif - -#ifdef USE_SPI_DEVICE_1 - if (instance == SPI1) { - initSpi1(); - return true; - } -#endif -#ifdef USE_SPI_DEVICE_2 - if (instance == SPI2) { - initSpi2(); - return true; - } -#endif -#if defined(USE_SPI_DEVICE_3) && defined(STM32F303xC) - if (instance == SPI3) { - initSpi3(); - return true; - } -#endif - return false; + } + return false; } +uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance) +{ + SPIDevice device = spiDeviceByInstance(instance); + if (device == SPIINVALID) + return -1; + spiHardwareMap[device].errorCount++; + return spiHardwareMap[device].errorCount; +} + +// return uint8_t value or -1 when failure uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data) { - uint16_t spiTimeout = 1000; + uint16_t spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { - if ((spiTimeout--) == 0) - break; - } + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); #ifdef STM32F303xC - SPI_SendData8(instance, data); + SPI_SendData8(instance, data); +#else + SPI_I2S_SendData(instance, data); #endif -#ifdef STM32F10X - SPI_I2S_SendData(instance, data); -#endif - spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET){ - if ((spiTimeout--) == 0) - break; - } + spiTimeout = 1000; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); #ifdef STM32F303xC - return ((uint8_t)SPI_ReceiveData8(instance)); -#endif -#ifdef STM32F10X - return ((uint8_t)SPI_I2S_ReceiveData(instance)); + return ((uint8_t)SPI_ReceiveData8(instance)); +#else + return ((uint8_t)SPI_I2S_ReceiveData(instance)); #endif } @@ -482,48 +244,47 @@ uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data) bool spiIsBusBusy(SPI_TypeDef *instance) { #ifdef STM32F303xC - return SPI_GetTransmissionFIFOStatus(instance) != SPI_TransmissionFIFOStatus_Empty || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; -#endif -#ifdef STM32F10X - return SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; + return SPI_GetTransmissionFIFOStatus(instance) != SPI_TransmissionFIFOStatus_Empty || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; +#else + return SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; #endif } -void spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len) +bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len) { - uint16_t spiTimeout = 1000; + uint16_t spiTimeout = 1000; - uint8_t b; - instance->DR; - while (len--) { - b = in ? *(in++) : 0xFF; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { - if ((spiTimeout--) == 0) - break; - } + uint8_t b; + instance->DR; + while (len--) { + b = in ? *(in++) : 0xFF; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); + } #ifdef STM32F303xC - SPI_SendData8(instance, b); - //SPI_I2S_SendData16(instance, b); + SPI_SendData8(instance, b); + //SPI_I2S_SendData16(instance, b); +#else + SPI_I2S_SendData(instance, b); #endif -#ifdef STM32F10X - SPI_I2S_SendData(instance, b); -#endif - spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) { - if ((spiTimeout--) == 0) - break; - } + spiTimeout = 1000; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) { + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); + } #ifdef STM32F303xC - b = SPI_ReceiveData8(instance); - //b = SPI_I2S_ReceiveData16(instance); + b = SPI_ReceiveData8(instance); + //b = SPI_I2S_ReceiveData16(instance); +#else + b = SPI_I2S_ReceiveData(instance); #endif -#ifdef STM32F10X - b = SPI_I2S_ReceiveData(instance); -#endif - if (out) - *(out++) = b; - } + if (out) + *(out++) = b; + } + + return true; } @@ -531,55 +292,70 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor) { #define BR_CLEAR_MASK 0xFFC7 - uint16_t tempRegister; + uint16_t tempRegister; - SPI_Cmd(instance, DISABLE); + SPI_Cmd(instance, DISABLE); - tempRegister = instance->CR1; + tempRegister = instance->CR1; - switch (divisor) { - case 2: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_2; - break; + switch (divisor) { + case 2: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_2; + break; - case 4: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_4; - break; + case 4: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_4; + break; - case 8: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_8; - break; + case 8: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_8; + break; - case 16: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_16; - break; + case 16: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_16; + break; - case 32: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_32; - break; + case 32: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_32; + break; - case 64: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_64; - break; + case 64: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_64; + break; - case 128: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_128; - break; + case 128: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_128; + break; - case 256: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_256; - break; - } + case 256: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_256; + break; + } - instance->CR1 = tempRegister; + instance->CR1 = tempRegister; - SPI_Cmd(instance, ENABLE); + SPI_Cmd(instance, ENABLE); } + +uint16_t spiGetErrorCounter(SPI_TypeDef *instance) +{ + SPIDevice device = spiDeviceByInstance(instance); + if (device == SPIINVALID) + return 0; + return spiHardwareMap[device].errorCount; +} + +void spiResetErrorCounter(SPI_TypeDef *instance) +{ + SPIDevice device = spiDeviceByInstance(instance); + if (device != SPIINVALID) + spiHardwareMap[device].errorCount = 0; +} \ No newline at end of file diff --git a/src/main/drivers/bus_spi.h b/src/main/drivers/bus_spi.h index 7c37a6876..1d5eca6bc 100644 --- a/src/main/drivers/bus_spi.h +++ b/src/main/drivers/bus_spi.h @@ -22,9 +22,64 @@ #define SPI_18MHZ_CLOCK_DIVIDER 2 #define SPI_9MHZ_CLOCK_DIVIDER 4 -bool spiInit(SPI_TypeDef *instance); +#include +#include "io.h" +#include "rcc.h" + +#if defined(STM32F40_41xxx) || defined (STM32F411xE) || defined(STM32F303xC) +#define SPI_IO_AF_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_NOPULL) +#define SPI_IO_AF_SCK_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_DOWN) +#define SPI_IO_AF_MISO_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_UP) +#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_OUT, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_NOPULL) +#elif defined(STM32F10X) +#define SPI_IO_AF_CFG IO_CONFIG(GPIO_Mode_AF_OD, GPIO_Speed_50MHz) +#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_Out_OD, GPIO_Speed_50MHz) +#else +#error "Unknown processor" +#endif +#if defined(STM32F40_41xxx) || defined (STM32F411xE) + +#define SPI_SLOW_CLOCK 128 //00.65625 MHz +#define SPI_STANDARD_CLOCK 8 //11.50000 MHz +#define SPI_FAST_CLOCK 4 //21.00000 MHz +#define SPI_ULTRAFAST_CLOCK 2 //42.00000 MHz + +#else + +#define SPI_SLOW_CLOCK 128 //00.56250 MHz +#define SPI_STANDARD_CLOCK 4 //09.00000 MHz +#define SPI_FAST_CLOCK 2 //18.00000 MHz +#define SPI_ULTRAFAST_CLOCK 2 //18.00000 MHz + +#endif + +typedef enum SPIDevice { + SPIINVALID = -1, + SPIDEV_1 = 0, + SPIDEV_2, + SPIDEV_3, + SPIDEV_MAX = SPIDEV_3, +} SPIDevice; + +typedef struct SPIDevice_s { + SPI_TypeDef *dev; + ioTag_t nss; + ioTag_t sck; + ioTag_t mosi; + ioTag_t miso; + rccPeriphTag_t rcc; + uint8_t af; + volatile uint16_t errorCount; + bool sdcard; +} spiDevice_t; + +bool spiInit(SPIDevice device); void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor); uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t in); bool spiIsBusBusy(SPI_TypeDef *instance); -void spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len); +bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len); + +uint16_t spiGetErrorCounter(SPI_TypeDef *instance); +void spiResetErrorCounter(SPI_TypeDef *instance); + diff --git a/src/main/drivers/compass_ak8963.c b/src/main/drivers/compass_ak8963.c index c1ee643cb..a07858194 100644 --- a/src/main/drivers/compass_ak8963.c +++ b/src/main/drivers/compass_ak8963.c @@ -187,12 +187,14 @@ bool ak8963SPICompleteRead(uint8_t *buf) #endif #ifdef USE_I2C -bool c_i2cWrite(uint8_t addr_, uint8_t reg_, uint8_t data) { - return i2cWrite(addr_, reg_, data); +bool c_i2cWrite(uint8_t addr_, uint8_t reg_, uint8_t data) +{ + return i2cWrite(MAG_I2C_INSTANCE, addr_, reg_, data); } -bool c_i2cRead(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf) { - return i2cRead(addr_, reg_, len, buf); +bool c_i2cRead(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf) +{ + return i2cRead(MAG_I2C_INSTANCE, addr_, reg_, len, buf); } #endif @@ -203,11 +205,11 @@ bool ak8963Detect(mag_t *mag) #ifdef USE_I2C // check for AK8963 on I2C bus - ack = i2cRead(AK8963_MAG_I2C_ADDRESS, AK8963_MAG_REG_WHO_AM_I, 1, &sig); + ack = i2cRead(MAG_I2C_INSTANCE, AK8963_MAG_I2C_ADDRESS, AK8963_MAG_REG_WHO_AM_I, 1, &sig); if (ack && sig == AK8963_Device_ID) // 0x48 / 01001000 / 'H' { - ak8963config.read = i2cRead; - ak8963config.write = i2cWrite; + ak8963config.read = c_i2cRead; + ak8963config.write = c_i2cWrite; mag->init = ak8963Init; mag->read = ak8963Read; diff --git a/src/main/drivers/compass_ak8975.c b/src/main/drivers/compass_ak8975.c index 57260d86c..386a06e7d 100644 --- a/src/main/drivers/compass_ak8975.c +++ b/src/main/drivers/compass_ak8975.c @@ -64,7 +64,7 @@ bool ak8975detect(mag_t *mag) bool ack = false; uint8_t sig = 0; - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_WHO_AM_I, 1, &sig); + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_WHO_AM_I, 1, &sig); if (!ack || sig != 'H') // 0x48 / 01001000 / 'H' return false; @@ -86,24 +86,24 @@ void ak8975Init() UNUSED(ack); - ack = i2cWrite(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x00); // power down before entering fuse mode + ack = i2cWrite(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x00); // power down before entering fuse mode delay(20); - ack = i2cWrite(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x0F); // Enter Fuse ROM access mode + ack = i2cWrite(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x0F); // Enter Fuse ROM access mode delay(10); - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975A_ASAX, 3, &buffer[0]); // Read the x-, y-, and z-axis calibration values + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975A_ASAX, 3, &buffer[0]); // Read the x-, y-, and z-axis calibration values delay(10); - ack = i2cWrite(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x00); // power down after reading. + ack = i2cWrite(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x00); // power down after reading. delay(10); // Clear status registers - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS1, 1, &status); - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS2, 1, &status); + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS1, 1, &status); + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS2, 1, &status); // Trigger first measurement - ack = i2cWrite(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x01); + ack = i2cWrite(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x01); } #define BIT_STATUS1_REG_DATA_READY (1 << 0) @@ -118,13 +118,13 @@ bool ak8975Read(int16_t *magData) uint8_t status; uint8_t buf[6]; - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS1, 1, &status); + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS1, 1, &status); if (!ack || (status & BIT_STATUS1_REG_DATA_READY) == 0) { return false; } #if 1 // USE_I2C_SINGLE_BYTE_READS - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_HXL, 6, buf); // read from AK8975_MAG_REG_HXL to AK8975_MAG_REG_HZH + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_HXL, 6, buf); // read from AK8975_MAG_REG_HXL to AK8975_MAG_REG_HZH #else for (uint8_t i = 0; i < 6; i++) { ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_HXL + i, 1, &buf[i]); // read from AK8975_MAG_REG_HXL to AK8975_MAG_REG_HZH @@ -134,7 +134,7 @@ bool ak8975Read(int16_t *magData) } #endif - ack = i2cRead(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS2, 1, &status); + ack = i2cRead(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_STATUS2, 1, &status); if (!ack) { return false; } @@ -152,6 +152,6 @@ bool ak8975Read(int16_t *magData) magData[Z] = -(int16_t)(buf[5] << 8 | buf[4]) * 4; - ack = i2cWrite(AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x01); // start reading again + ack = i2cWrite(MAG_I2C_INSTANCE, AK8975_MAG_I2C_ADDRESS, AK8975_MAG_REG_CNTL, 0x01); // start reading again return true; } diff --git a/src/main/drivers/nvic.h b/src/main/drivers/nvic.h index 74cc17304..7d6b100a9 100644 --- a/src/main/drivers/nvic.h +++ b/src/main/drivers/nvic.h @@ -8,6 +8,7 @@ #define NVIC_PRIO_TIMER NVIC_BUILD_PRIORITY(1, 1) #define NVIC_PRIO_BARO_EXTI NVIC_BUILD_PRIORITY(0x0f, 0x0f) #define NVIC_PRIO_SONAR_EXTI NVIC_BUILD_PRIORITY(2, 0) // maybe increate slightly +#define NVIC_PRIO_TRANSPONDER_DMA NVIC_BUILD_PRIORITY(3, 0) #define NVIC_PRIO_MPU_INT_EXTI NVIC_BUILD_PRIORITY(0x0f, 0x0f) #define NVIC_PRIO_MAG_INT_EXTI NVIC_BUILD_PRIORITY(0x0f, 0x0f) #define NVIC_PRIO_WS2811_DMA NVIC_BUILD_PRIORITY(1, 2) // TODO - is there some reason to use high priority? (or to use DMA IRQ at all?) @@ -37,6 +38,7 @@ #define NVIC_PRIO_MPU_DATA_READY NVIC_BUILD_PRIORITY(0x0f, 0x0f) #define NVIC_PRIO_MAG_DATA_READY NVIC_BUILD_PRIORITY(0x0f, 0x0f) #define NVIC_PRIO_CALLBACK NVIC_BUILD_PRIORITY(0x0f, 0x0f) +#define NVIC_PRIO_BST_READ_DATA NVIC_BUILD_PRIORITY(1, 1) // utility macros to join/split priority #define NVIC_BUILD_PRIORITY(base,sub) (((((base)<<(4-(7-(NVIC_PRIORITY_GROUPING>>8))))|((sub)&(0x0f>>(7-(NVIC_PRIORITY_GROUPING>>8)))))<<4)&0xf0) diff --git a/src/main/drivers/rcc.c b/src/main/drivers/rcc.c index 30df1d888..77be51d05 100644 --- a/src/main/drivers/rcc.c +++ b/src/main/drivers/rcc.c @@ -4,17 +4,48 @@ void RCC_ClockCmd(rccPeriphTag_t periphTag, FunctionalState NewState) { - int tag = periphTag >> 5; - uint32_t mask = 1 << (periphTag & 0x1f); - switch(tag) { - case RCC_AHB: - RCC_AHBPeriphClockCmd(mask, NewState); - break; - case RCC_APB2: - RCC_APB2PeriphClockCmd(mask, NewState); - break; - case RCC_APB1: - RCC_APB1PeriphClockCmd(mask, NewState); - break; - } + int tag = periphTag >> 5; + uint32_t mask = 1 << (periphTag & 0x1f); + switch (tag) { +#if defined(STM32F303xC) + case RCC_AHB: + RCC_AHBPeriphClockCmd(mask, NewState); + break; +#endif + case RCC_APB2: + RCC_APB2PeriphClockCmd(mask, NewState); + break; + case RCC_APB1: + RCC_APB1PeriphClockCmd(mask, NewState); + break; +#if defined(STM32F40_41xxx) || defined(STM32F411xE) + case RCC_AHB1: + RCC_AHB1PeriphClockCmd(mask, NewState); + break; +#endif + } +} + +void RCC_ResetCmd(rccPeriphTag_t periphTag, FunctionalState NewState) +{ + int tag = periphTag >> 5; + uint32_t mask = 1 << (periphTag & 0x1f); + switch (tag) { +#if defined(STM32F303xC) + case RCC_AHB: + RCC_AHBPeriphResetCmd(mask, NewState); + break; +#endif + case RCC_APB2: + RCC_APB2PeriphResetCmd(mask, NewState); + break; + case RCC_APB1: + RCC_APB1PeriphResetCmd(mask, NewState); + break; +#if defined(STM32F40_41xxx) || defined(STM32F411xE) + case RCC_AHB1: + RCC_AHB1PeriphResetCmd(mask, NewState); + break; +#endif + } } diff --git a/src/main/drivers/rcc.h b/src/main/drivers/rcc.h index 14ce122c9..a00b5b845 100644 --- a/src/main/drivers/rcc.h +++ b/src/main/drivers/rcc.h @@ -17,5 +17,5 @@ enum rcc_reg { typedef uint8_t rccPeriphTag_t; void RCC_ClockCmd(rccPeriphTag_t periphTag, FunctionalState NewState); - +void RCC_ResetCmd(rccPeriphTag_t periphTag, FunctionalState NewState); diff --git a/src/main/drivers/resource.h b/src/main/drivers/resource.h index ef31fd79d..0c6ff6975 100644 --- a/src/main/drivers/resource.h +++ b/src/main/drivers/resource.h @@ -21,6 +21,7 @@ typedef enum { OWNER_TIMER, OWNER_SONAR, OWNER_SYSTEM, + OWNER_SDCARD } resourceOwner_t; diff --git a/src/main/drivers/sdcard.c b/src/main/drivers/sdcard.c index bd86d5f33..d6f2b9e6a 100644 --- a/src/main/drivers/sdcard.c +++ b/src/main/drivers/sdcard.c @@ -24,7 +24,7 @@ #include "platform.h" #include "nvic.h" -#include "gpio.h" +#include "io.h" #include "drivers/bus_spi.h" #include "drivers/system.h" @@ -37,8 +37,8 @@ #define SDCARD_PROFILING #endif -#define SET_CS_HIGH GPIO_SetBits(SDCARD_SPI_CS_GPIO, SDCARD_SPI_CS_PIN) -#define SET_CS_LOW GPIO_ResetBits(SDCARD_SPI_CS_GPIO, SDCARD_SPI_CS_PIN) +#define SET_CS_HIGH IOHi(sdcardDetectPin) +#define SET_CS_LOW IOLo(sdcardDetectPin) #define SDCARD_INIT_NUM_DUMMY_BYTES 10 #define SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY 8 @@ -117,25 +117,23 @@ static sdcard_t sdcard; STATIC_ASSERT(sizeof(sdcardCSD_t) == 16, sdcard_csd_bitfields_didnt_pack_properly); +static IO_t sdcardDetectPin = IO_NONE; + void sdcardInsertionDetectDeinit(void) { #ifdef SDCARD_DETECT_PIN - GPIO_InitTypeDef GPIO_InitStructure; - - GPIO_InitStructure.GPIO_Pin = SDCARD_DETECT_PIN; - GPIO_Init(SDCARD_DETECT_GPIO_PORT, &GPIO_InitStructure); + sdcardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN)); + IOInit(sdcardDetectPin, OWNER_SYSTEM, RESOURCE_SPI); + IOConfigGPIO(sdcardDetectPin, SPI_IO_CS_CFG); #endif } void sdcardInsertionDetectInit(void) { #ifdef SDCARD_DETECT_PIN - GPIO_InitTypeDef GPIO_InitStructure; - - GPIO_InitStructure.GPIO_Pin = SDCARD_DETECT_PIN; - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; - GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; - GPIO_Init(SDCARD_DETECT_GPIO_PORT, &GPIO_InitStructure); + sdcardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN)); + IOInit(sdcardDetectPin, OWNER_SDCARD, RESOURCE_INPUT); + IOConfigGPIO(sdcardDetectPin, SPI_IO_CS_CFG); #endif } @@ -148,7 +146,7 @@ bool sdcard_isInserted(void) #ifdef SDCARD_DETECT_PIN - result = (GPIO_ReadInputData(SDCARD_DETECT_GPIO_PORT) & SDCARD_DETECT_PIN) != 0; + result = IORead(sdcardDetectPin) != 0; #ifdef SDCARD_DETECT_INVERTED result = !result; diff --git a/src/main/main.c b/src/main/main.c index 52d232744..5c2c6dca2 100644 --- a/src/main/main.c +++ b/src/main/main.c @@ -389,18 +389,16 @@ void init(void) bstInit(BST_DEVICE); #endif - - #ifdef USE_SPI - spiInit(SPI1); - spiInit(SPI2); + spiInit(SPIDEV_1); + spiInit(SPIDEV_2); #ifdef STM32F303xC #ifdef ALIENFLIGHTF3 if (hardwareRevision == AFF3_REV_2) { - spiInit(SPI3); + spiInit(SPIDEV_3); } #else - spiInit(SPI3); + spiInit(SPIDEV_3); #endif #endif #endif diff --git a/src/main/target/ALIENFLIGHTF3/target.h b/src/main/target/ALIENFLIGHTF3/target.h index ffeb3846d..f6de770af 100644 --- a/src/main/target/ALIENFLIGHTF3/target.h +++ b/src/main/target/ALIENFLIGHTF3/target.h @@ -98,16 +98,8 @@ #define USE_I2C #define I2C_DEVICE (I2CDEV_2) // SDA (PA10/AF4), SCL (PA9/AF4) -#define I2C2_SCL_GPIO GPIOA -#define I2C2_SCL_GPIO_AF GPIO_AF_4 -#define I2C2_SCL_PIN GPIO_Pin_9 -#define I2C2_SCL_PIN_SOURCE GPIO_PinSource9 -#define I2C2_SCL_CLK_SOURCE RCC_AHBPeriph_GPIOA -#define I2C2_SDA_GPIO GPIOA -#define I2C2_SDA_GPIO_AF GPIO_AF_4 -#define I2C2_SDA_PIN GPIO_Pin_10 -#define I2C2_SDA_PIN_SOURCE GPIO_PinSource10 -#define I2C2_SDA_CLK_SOURCE RCC_AHBPeriph_GPIOA +#define I2C2_SCL_PIN PA9 +#define I2C2_SDA_PIN PA10 // SPI3 // PA15 38 SPI3_NSS diff --git a/src/main/target/CHEBUZZF3/target.h b/src/main/target/CHEBUZZF3/target.h index 816ad857e..4c48a8df0 100644 --- a/src/main/target/CHEBUZZF3/target.h +++ b/src/main/target/CHEBUZZF3/target.h @@ -33,16 +33,10 @@ #define USE_SPI_DEVICE_1 #define USE_SPI_DEVICE_2 -#define SPI2_GPIO GPIOB -#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI2_NSS_PIN Pin_12 -#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12 -#define SPI2_SCK_PIN Pin_13 -#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13 -#define SPI2_MISO_PIN Pin_14 -#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14 -#define SPI2_MOSI_PIN Pin_15 -#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15 +#define SPI2_NSS_PIN PB12 +#define SPI2_SCK_PIN PB13 +#define SPI2_MISO_PIN PB14 +#define SPI2_MOSI_PIN PB15 #define USE_SDCARD #define USE_SDCARD_SPI2 @@ -163,4 +157,5 @@ #define TARGET_IO_PORTB 0xffff #define TARGET_IO_PORTC 0xffff #define TARGET_IO_PORTD (BIT(2)) +#define TARGET_IO_PORTE 0xffff #define TARGET_IO_PORTF (BIT(0)|BIT(1)|BIT(4)) diff --git a/src/main/target/COLIBRI_RACE/target.h b/src/main/target/COLIBRI_RACE/target.h index 1555b7395..d11d8dd14 100755 --- a/src/main/target/COLIBRI_RACE/target.h +++ b/src/main/target/COLIBRI_RACE/target.h @@ -29,27 +29,18 @@ #define BEEPER_INVERTED #define USE_EXTI -#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA -#define MPU6500_CS_GPIO GPIOA -#define MPU6500_CS_PIN GPIO_Pin_4 +#define MPU6500_CS_PIN PA4 #define MPU6500_SPI_INSTANCE SPI1 -#define MPU6000_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA -#define MPU6000_CS_GPIO GPIOA -#define MPU6000_CS_PIN GPIO_Pin_4 +#define MPU6000_CS_PIN PA4 #define MPU6000_SPI_INSTANCE SPI1 #define USE_SPI #define USE_SPI_DEVICE_1 -#define SPI1_GPIO GPIOB -#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI1_SCK_PIN GPIO_Pin_3 -#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3 -#define SPI1_MISO_PIN GPIO_Pin_4 -#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4 -#define SPI1_MOSI_PIN GPIO_Pin_5 -#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5 +#define SPI1_SCK_PIN PB3 +#define SPI1_MISO_PIN PB4 +#define SPI1_MOSI_PIN PB5 #define USABLE_TIMER_CHANNEL_COUNT 11 diff --git a/src/main/target/LUX_RACE/target.h b/src/main/target/LUX_RACE/target.h index 54bf94fbf..312dfe611 100644 --- a/src/main/target/LUX_RACE/target.h +++ b/src/main/target/LUX_RACE/target.h @@ -35,14 +35,9 @@ #define USE_SPI #define USE_SPI_DEVICE_1 -#define SPI1_GPIO GPIOB -#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI1_SCK_PIN GPIO_Pin_3 -#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3 -#define SPI1_MISO_PIN GPIO_Pin_4 -#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4 -#define SPI1_MOSI_PIN GPIO_Pin_5 -#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5 +#define SPI1_SCK_PIN PB3 +#define SPI1_MISO_PIN PB4 +#define SPI1_MOSI_PIN PB5 #define USABLE_TIMER_CHANNEL_COUNT 11 diff --git a/src/main/target/NAZE/target.h b/src/main/target/NAZE/target.h index bab710db2..acd00b7c8 100644 --- a/src/main/target/NAZE/target.h +++ b/src/main/target/NAZE/target.h @@ -46,7 +46,7 @@ #define NAZE_SPI_INSTANCE SPI2 #define NAZE_SPI_CS_GPIO GPIOB -#define NAZE_SPI_CS_PIN GPIO_Pin_12 +#define NAZE_SPI_CS_PIN PB12 #define NAZE_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB // We either have this 16mbit flash chip on SPI or the MPU6500 acc/gyro depending on board revision: diff --git a/src/main/target/SPRACINGF3/target.h b/src/main/target/SPRACINGF3/target.h index be1aed09e..03eadcf7f 100644 --- a/src/main/target/SPRACINGF3/target.h +++ b/src/main/target/SPRACINGF3/target.h @@ -164,4 +164,4 @@ #define TARGET_IO_PORTA 0xffff #define TARGET_IO_PORTB 0xffff #define TARGET_IO_PORTC (BIT(13)|BIT(14)|BIT(15)) -#define TARGET_IO_PORTF (BIT(0)|BIT(1)) +#define TARGET_IO_PORTF (BIT(0)|BIT(1)|BIT(3)|BIT(4)) diff --git a/src/main/target/SPRACINGF3EVO/target.h b/src/main/target/SPRACINGF3EVO/target.h index 170f1dd25..048baa188 100755 --- a/src/main/target/SPRACINGF3EVO/target.h +++ b/src/main/target/SPRACINGF3EVO/target.h @@ -100,34 +100,22 @@ #define USE_SPI_DEVICE_1 // PB9,3,4,5 on AF5 SPI1 (MPU) #define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 SPI2 (SDCard) -#define SPI1_GPIO GPIOB -#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI1_NSS_PIN Pin_9 -#define SPI1_NSS_PIN_SOURCE GPIO_PinSource9 -#define SPI1_SCK_PIN Pin_3 -#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3 -#define SPI1_MISO_PIN Pin_4 -#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4 -#define SPI1_MOSI_PIN Pin_5 -#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5 +#define SPI1_NSS_PIN PB9 +#define SPI1_SCK_PIN PB3 +#define SPI1_MISO_PIN PB4 +#define SPI1_MOSI_PIN PB5 -#define SPI2_GPIO GPIOB -#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB -#define SPI2_NSS_PIN Pin_12 -#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12 -#define SPI2_SCK_PIN Pin_13 -#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13 -#define SPI2_MISO_PIN Pin_14 -#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14 -#define SPI2_MOSI_PIN Pin_15 -#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15 +#define SPI2_NSS_PIN PB12 +#define SPI2_SCK_PIN PB13 +#define SPI2_MISO_PIN PB14 +#define SPI2_MOSI_PIN PB15 #define USE_SDCARD #define USE_SDCARD_SPI2 #define SDCARD_DETECT_INVERTED -#define SDCARD_DETECT_PIN GPIO_Pin_14 +#define SDCARD_DETECT_PIN PC14 #define SDCARD_DETECT_EXTI_LINE EXTI_Line14 #define SDCARD_DETECT_EXTI_PIN_SOURCE EXTI_PinSource14 #define SDCARD_DETECT_GPIO_PORT GPIOC @@ -148,9 +136,7 @@ #define SDCARD_DMA_CHANNEL_TX DMA1_Channel5 #define SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG DMA1_FLAG_TC5 -#define MPU6500_CS_GPIO_CLK_PERIPHERAL SPI1_GPIO_PERIPHERAL -#define MPU6500_CS_GPIO SPI1_GPIO -#define MPU6500_CS_PIN GPIO_Pin_9 +#define MPU6500_CS_PIN PB9 #define MPU6500_SPI_INSTANCE SPI1 #define USE_ADC @@ -223,4 +209,4 @@ #define TARGET_IO_PORTA 0xffff #define TARGET_IO_PORTB 0xffff #define TARGET_IO_PORTC (BIT(13)|BIT(14)|BIT(15)) -#define TARGET_IO_PORTF (BIT(0)|BIT(1)) +#define TARGET_IO_PORTF (BIT(0)|BIT(1)|BIT(4))