src/main/drivers/bus_spi_hal.c

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdbool.h>
  19 #include <stdint.h>
  20 #include <string.h>
  21
  22 #include <platform.h>
  23
  24 #if defined(USE_SPI) && !defined(USE_LOWLEVEL_DRIVER)
  25
  26 #include "common/utils.h"
  27
  28 #include "drivers/bus.h"
  29 #include "drivers/bus_spi.h"
  30 #include "drivers/bus_spi_impl.h"
  31 #include "drivers/dma.h"
  32 #include "drivers/io.h"
  33 #include "drivers/nvic.h"
  34 #include "drivers/rcc.h"
  35
  36 spiDevice_t spiDevice[SPIDEV_COUNT];
  37
  38 #ifndef SPI2_SCK_PIN
  39 #define SPI2_NSS_PIN    PB12
  40 #define SPI2_SCK_PIN    PB13
  41 #define SPI2_MISO_PIN   PB14
  42 #define SPI2_MOSI_PIN   PB15
  43 #endif
  44
  45 #ifndef SPI3_SCK_PIN
  46 #define SPI3_NSS_PIN    PA15
  47 #define SPI3_SCK_PIN    PB3
  48 #define SPI3_MISO_PIN   PB4
  49 #define SPI3_MOSI_PIN   PB5
  50 #endif
  51
  52 #ifndef SPI4_SCK_PIN
  53 #define SPI4_NSS_PIN    PA15
  54 #define SPI4_SCK_PIN    PB3
  55 #define SPI4_MISO_PIN   PB4
  56 #define SPI4_MOSI_PIN   PB5
  57 #endif
  58
  59 #ifndef SPI1_NSS_PIN
  60 #define SPI1_NSS_PIN NONE
  61 #endif
  62 #ifndef SPI2_NSS_PIN
  63 #define SPI2_NSS_PIN NONE
  64 #endif
  65 #ifndef SPI3_NSS_PIN
  66 #define SPI3_NSS_PIN NONE
  67 #endif
  68 #ifndef SPI4_NSS_PIN
  69 #define SPI4_NSS_PIN NONE
  70 #endif
  71
  72 #define SPI_DEFAULT_TIMEOUT 10
  73
  74 SPIDevice spiDeviceByInstance(SPI_TypeDef *instance)
  75 {
  76 #ifdef USE_SPI_DEVICE_1
  77     if (instance == SPI1)
  78         return SPIDEV_1;
  79 #endif
  80
  81 #ifdef USE_SPI_DEVICE_2
  82     if (instance == SPI2)
  83         return SPIDEV_2;
  84 #endif
  85
  86 #ifdef USE_SPI_DEVICE_3
  87     if (instance == SPI3)
  88         return SPIDEV_3;
  89 #endif
  90
  91 #ifdef USE_SPI_DEVICE_4
  92     if (instance == SPI4)
  93         return SPIDEV_4;
  94 #endif
  95
  96     return SPIINVALID;
  97 }
  98
  99 SPI_HandleTypeDef* spiHandleByInstance(SPI_TypeDef *instance)
 100 {
 101     return &spiDevice[spiDeviceByInstance(instance)].hspi;
 102 }
 103
 104 SPI_TypeDef *spiInstanceByDevice(SPIDevice device)
 105 {
 106     if (device >= SPIDEV_COUNT) {
 107         return NULL;
 108     }
 109
 110     return spiDevice[device].dev;
 111 }
 112
 113 DMA_HandleTypeDef* dmaHandleByInstance(SPI_TypeDef *instance)
 114 {
 115     return &spiDevice[spiDeviceByInstance(instance)].hdma;
 116 }
 117
 118 void SPI1_IRQHandler(void)
 119 {
 120     HAL_SPI_IRQHandler(&spiDevice[SPIDEV_1].hspi);
 121 }
 122
 123 void SPI2_IRQHandler(void)
 124 {
 125     HAL_SPI_IRQHandler(&spiDevice[SPIDEV_2].hspi);
 126 }
 127
 128 void SPI3_IRQHandler(void)
 129 {
 130     HAL_SPI_IRQHandler(&spiDevice[SPIDEV_3].hspi);
 131 }
 132
 133 void SPI4_IRQHandler(void)
 134 {
 135     HAL_SPI_IRQHandler(&spiDevice[SPIDEV_4].hspi);
 136 }
 137
 138
 139 void spiInitDevice(SPIDevice device)
 140 {
 141     spiDevice_t *spi = &(spiDevice[device]);
 142
 143 #ifdef SDCARD_SPI_INSTANCE
 144     if (spi->dev == SDCARD_SPI_INSTANCE) {
 145         spi->leadingEdge = true;
 146     }
 147 #endif
 148 #ifdef RX_SPI_INSTANCE
 149     if (spi->dev == RX_SPI_INSTANCE) {
 150         spi->leadingEdge = true;
 151     }
 152 #endif
 153 #ifdef MPU6500_SPI_INSTANCE
 154     if (spi->dev == MPU6500_SPI_INSTANCE) {
 155         spi->leadingEdge = true;
 156     }
 157 #endif
 158
 159     // Enable SPI clock
 160     RCC_ClockCmd(spi->rcc, ENABLE);
 161     RCC_ResetCmd(spi->rcc, ENABLE);
 162
 163     IOInit(IOGetByTag(spi->sck),  OWNER_SPI_SCK,  RESOURCE_INDEX(device));
 164     IOInit(IOGetByTag(spi->miso), OWNER_SPI_MISO, RESOURCE_INDEX(device));
 165     IOInit(IOGetByTag(spi->mosi), OWNER_SPI_MOSI, RESOURCE_INDEX(device));
 166
 167 #if defined(STM32F7)
 168     if (spi->leadingEdge == true)
 169         IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_LOW, spi->sckAF);
 170     else
 171         IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_HIGH, spi->sckAF);
 172     IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->misoAF);
 173     IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->mosiAF);
 174 #endif
 175 #if defined(STM32F3) || defined(STM32F4)
 176     if (spi->leadingEdge == true)
 177         IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_LOW, spi->af);
 178     else
 179         IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_HIGH, spi->af);
 180     IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->af);
 181     IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af);
 182 #endif
 183 #if defined(STM32F10X)
 184     IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG);
 185     IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG);
 186     IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_MOSI_CFG);
 187 #endif
 188     spiDevice[device].hspi.Instance = spi->dev;
 189     // Init SPI hardware
 190     HAL_SPI_DeInit(&spiDevice[device].hspi);
 191
 192     spiDevice[device].hspi.Init.Mode = SPI_MODE_MASTER;
 193     spiDevice[device].hspi.Init.Direction = SPI_DIRECTION_2LINES;
 194     spiDevice[device].hspi.Init.DataSize = SPI_DATASIZE_8BIT;
 195     spiDevice[device].hspi.Init.NSS = SPI_NSS_SOFT;
 196     spiDevice[device].hspi.Init.FirstBit = SPI_FIRSTBIT_MSB;
 197     spiDevice[device].hspi.Init.CRCPolynomial = 7;
 198     spiDevice[device].hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
 199     spiDevice[device].hspi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
 200     spiDevice[device].hspi.Init.TIMode = SPI_TIMODE_DISABLED;
 201
 202     if (spi->leadingEdge) {
 203         spiDevice[device].hspi.Init.CLKPolarity = SPI_POLARITY_LOW;
 204         spiDevice[device].hspi.Init.CLKPhase = SPI_PHASE_1EDGE;
 205     }
 206     else {
 207         spiDevice[device].hspi.Init.CLKPolarity = SPI_POLARITY_HIGH;
 208         spiDevice[device].hspi.Init.CLKPhase = SPI_PHASE_2EDGE;
 209     }
 210
 211     if (HAL_SPI_Init(&spiDevice[device].hspi) == HAL_OK)
 212     {
 213     }
 214 }
 215
 216 bool spiInit(SPIDevice device)
 217 {
 218     switch (device) {
 219     case SPIINVALID:
 220         return false;
 221     case SPIDEV_1:
 222 #if defined(USE_SPI_DEVICE_1)
 223         spiInitDevice(device);
 224         return true;
 225 #else
 226         break;
 227 #endif
 228     case SPIDEV_2:
 229 #if defined(USE_SPI_DEVICE_2)
 230         spiInitDevice(device);
 231         return true;
 232 #else
 233         break;
 234 #endif
 235     case SPIDEV_3:
 236 #if defined(USE_SPI_DEVICE_3)
 237         spiInitDevice(device);
 238         return true;
 239 #else
 240         break;
 241 #endif
 242     case SPIDEV_4:
 243 #if defined(USE_SPI_DEVICE_4)
 244         spiInitDevice(device);
 245         return true;
 246 #else
 247         break;
 248 #endif
 249     }
 250     return false;
 251 }
 252
 253 uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
 254 {
 255     SPIDevice device = spiDeviceByInstance(instance);
 256     if (device == SPIINVALID) {
 257         return -1;
 258     }
 259     spiDevice[device].errorCount++;
 260     return spiDevice[device].errorCount;
 261 }
 262
 263 /**
 264  * Return true if the bus is currently in the middle of a transmission.
 265  */
 266 bool spiIsBusBusy(SPI_TypeDef *instance)
 267 {
 268     SPIDevice device = spiDeviceByInstance(instance);
 269     if (spiDevice[device].hspi.State == HAL_SPI_STATE_BUSY)
 270         return true;
 271     else
 272         return false;
 273 }
 274
 275 bool spiTransfer(SPI_TypeDef *instance, const uint8_t *txData, uint8_t *rxData, int len)
 276 {
 277     SPIDevice device = spiDeviceByInstance(instance);
 278     HAL_StatusTypeDef status;
 279
 280     if (!rxData) { // Tx only
 281         status = HAL_SPI_Transmit(&spiDevice[device].hspi, txData, len, SPI_DEFAULT_TIMEOUT);
 282     } else if (!txData) { // Rx only
 283         status = HAL_SPI_Receive(&spiDevice[device].hspi, rxData, len, SPI_DEFAULT_TIMEOUT);
 284     } else { // Tx and Rx
 285         status = HAL_SPI_TransmitReceive(&spiDevice[device].hspi, txData, rxData, len, SPI_DEFAULT_TIMEOUT);
 286     }
 287     if (status != HAL_OK) {
 288         spiTimeoutUserCallback(instance);
 289     }
 290     return true;
 291 }
 292
 293 static bool spiBusReadBuffer(const busDevice_t *bus, uint8_t *out, int len)
 294 {
 295     const HAL_StatusTypeDef status = HAL_SPI_Receive(bus->busdev_u.spi.handle, out, len, SPI_DEFAULT_TIMEOUT);
 296     if (status != HAL_OK) {
 297         spiTimeoutUserCallback(bus->busdev_u.spi.instance);
 298     }
 299     return true;
 300 }
 301
 302 uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t txByte)
 303 {
 304     uint8_t rxByte;
 305
 306     spiTransfer(instance, &txByte, &rxByte, 1);
 307     return rxByte;
 308 }
 309
 310 static uint8_t spiBusTransferByte(const busDevice_t *bus, uint8_t in)
 311 {
 312     const HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(bus->busdev_u.spi.handle, &in, &in, 1, SPI_DEFAULT_TIMEOUT);
 313     if (status != HAL_OK) {
 314         spiTimeoutUserCallback(bus->busdev_u.spi.instance);
 315     }
 316     return in;
 317 }
 318
 319 bool spiBusTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int len)
 320 {
 321     IOLo(bus->busdev_u.spi.csnPin);
 322     const HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(bus->busdev_u.spi.handle, txData, rxData, len, SPI_DEFAULT_TIMEOUT);
 323     IOHi(bus->busdev_u.spi.csnPin);
 324     if (status != HAL_OK) {
 325         spiTimeoutUserCallback(bus->busdev_u.spi.instance);
 326     }
 327     return true;
 328 }
 329
 330 void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
 331 {
 332     SPIDevice device = spiDeviceByInstance(instance);
 333     if (HAL_SPI_DeInit(&spiDevice[device].hspi) == HAL_OK)
 334     {
 335     }
 336
 337     spiDevice[device].hspi.Init.BaudRatePrescaler = (uint8_t []) {
 338         0, 0,
 339         SPI_BAUDRATEPRESCALER_2, SPI_BAUDRATEPRESCALER_4,
 340         SPI_BAUDRATEPRESCALER_8, SPI_BAUDRATEPRESCALER_16,
 341         SPI_BAUDRATEPRESCALER_32, SPI_BAUDRATEPRESCALER_64,
 342         SPI_BAUDRATEPRESCALER_128, SPI_BAUDRATEPRESCALER_256
 343     }[ffs(divisor | 0x100)];
 344
 345     if (HAL_SPI_Init(&spiDevice[device].hspi) == HAL_OK)
 346     {
 347     }
 348 }
 349
 350 uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
 351 {
 352     SPIDevice device = spiDeviceByInstance(instance);
 353     if (device == SPIINVALID) {
 354         return 0;
 355     }
 356     return spiDevice[device].errorCount;
 357 }
 358
 359 void spiResetErrorCounter(SPI_TypeDef *instance)
 360 {
 361     SPIDevice device = spiDeviceByInstance(instance);
 362     if (device != SPIINVALID) {
 363         spiDevice[device].errorCount = 0;
 364     }
 365 }
 366
 367 bool spiBusWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
 368 {
 369     IOLo(bus->busdev_u.spi.csnPin);
 370     spiBusTransferByte(bus, reg);
 371     spiBusTransferByte(bus, data);
 372     IOHi(bus->busdev_u.spi.csnPin);
 373
 374     return true;
 375 }
 376
 377 bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
 378 {
 379     IOLo(bus->busdev_u.spi.csnPin);
 380     spiBusTransferByte(bus, reg | 0x80); // read transaction
 381     spiBusReadBuffer(bus, data, length);
 382     IOHi(bus->busdev_u.spi.csnPin);
 383
 384     return true;
 385 }
 386
 387 uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg)
 388 {
 389     uint8_t data;
 390     IOLo(bus->busdev_u.spi.csnPin);
 391     spiBusTransferByte(bus, reg | 0x80); // read transaction
 392     spiBusReadBuffer(bus, &data, 1);
 393     IOHi(bus->busdev_u.spi.csnPin);
 394
 395     return data;
 396 }
 397
 398 void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance)
 399 {
 400     bus->busdev_u.spi.instance = instance;
 401     bus->busdev_u.spi.handle = spiHandleByInstance(instance);
 402 }
 403
 404 void dmaSPIIRQHandler(dmaChannelDescriptor_t* descriptor)
 405 {
 406     SPIDevice device = descriptor->userParam;
 407     if (device != SPIINVALID) {
 408         HAL_DMA_IRQHandler(&spiDevice[device].hdma);
 409     }
 410 }
 411
 412
 413 DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, const uint8_t *pData, uint16_t Size)
 414 {
 415     SPIDevice device = spiDeviceByInstance(Instance);
 416
 417     spiDevice[device].hdma.Instance = Stream;
 418     spiDevice[device].hdma.Init.Channel = Channel;
 419     spiDevice[device].hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
 420     spiDevice[device].hdma.Init.PeriphInc = DMA_PINC_DISABLE;
 421     spiDevice[device].hdma.Init.MemInc = DMA_MINC_ENABLE;
 422     spiDevice[device].hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
 423     spiDevice[device].hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
 424     spiDevice[device].hdma.Init.Mode = DMA_NORMAL;
 425     spiDevice[device].hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
 426     spiDevice[device].hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;
 427     spiDevice[device].hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;
 428     spiDevice[device].hdma.Init.MemBurst = DMA_MBURST_SINGLE;
 429     spiDevice[device].hdma.Init.Priority = DMA_PRIORITY_LOW;
 430
 431     HAL_DMA_DeInit(&spiDevice[device].hdma);
 432     HAL_DMA_Init(&spiDevice[device].hdma);
 433
 434     __HAL_DMA_ENABLE(&spiDevice[device].hdma);
 435     __HAL_SPI_ENABLE(&spiDevice[device].hspi);
 436
 437     /* Associate the initialized DMA handle to the spi handle */
 438     __HAL_LINKDMA(&spiDevice[device].hspi, hdmatx, spiDevice[device].hdma);
 439
 440     // DMA TX Interrupt
 441     dmaSetHandler(spiDevice[device].dmaIrqHandler, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)device);
 442
 443     //HAL_CLEANCACHE(pData,Size);
 444     // And Transmit
 445     HAL_SPI_Transmit_DMA(&spiDevice[device].hspi, CONST_CAST(uint8_t*, pData), Size);
 446
 447     return &spiDevice[device].hdma;
 448 }
 449 #endif