src/main/drivers/bus_spi_ll.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #if defined(USE_SPI)
  28
  29 #include "common/utils.h"
  30 #include "common/maths.h"
  31
  32 #include "drivers/bus.h"
  33 #include "drivers/bus_spi.h"
  34 #include "drivers/bus_spi_impl.h"
  35 #include "drivers/dma.h"
  36 #include "drivers/io.h"
  37 #include "drivers/rcc.h"
  38
  39 #ifndef SPI2_SCK_PIN
  40 #define SPI2_NSS_PIN    PB12
  41 #define SPI2_SCK_PIN    PB13
  42 #define SPI2_MISO_PIN   PB14
  43 #define SPI2_MOSI_PIN   PB15
  44 #endif
  45
  46 #ifndef SPI3_SCK_PIN
  47 #define SPI3_NSS_PIN    PA15
  48 #define SPI3_SCK_PIN    PB3
  49 #define SPI3_MISO_PIN   PB4
  50 #define SPI3_MOSI_PIN   PB5
  51 #endif
  52
  53 #ifndef SPI4_SCK_PIN
  54 #define SPI4_NSS_PIN    PA15
  55 #define SPI4_SCK_PIN    PB3
  56 #define SPI4_MISO_PIN   PB4
  57 #define SPI4_MOSI_PIN   PB5
  58 #endif
  59
  60 #ifndef SPI1_NSS_PIN
  61 #define SPI1_NSS_PIN NONE
  62 #endif
  63 #ifndef SPI2_NSS_PIN
  64 #define SPI2_NSS_PIN NONE
  65 #endif
  66 #ifndef SPI3_NSS_PIN
  67 #define SPI3_NSS_PIN NONE
  68 #endif
  69 #ifndef SPI4_NSS_PIN
  70 #define SPI4_NSS_PIN NONE
  71 #endif
  72
  73 #define SPI_DEFAULT_TIMEOUT 10
  74
  75 #ifdef STM32H7
  76 #define IS_DTCM(p) (((uint32_t)p & 0xfffe0000) == 0x20000000)
  77 #elif defined(STM32F7)
  78 #define IS_DTCM(p) (((uint32_t)p & 0xffff0000) == 0x20000000)
  79 #elif defined(STM32G4)
  80 #define IS_CCM(p) ((((uint32_t)p & 0xffff8000) == 0x10000000) || (((uint32_t)p & 0xffff8000) == 0x20018000))
  81 #endif
  82 static LL_SPI_InitTypeDef defaultInit =
  83 {
  84     .TransferDirection = LL_SPI_FULL_DUPLEX,
  85     .Mode = LL_SPI_MODE_MASTER,
  86     .DataWidth = LL_SPI_DATAWIDTH_8BIT,
  87     .NSS = LL_SPI_NSS_SOFT,
  88     .BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8,
  89     .BitOrder = LL_SPI_MSB_FIRST,
  90     .CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
  91     .ClockPolarity = LL_SPI_POLARITY_HIGH,
  92     .ClockPhase = LL_SPI_PHASE_2EDGE,
  93 };
  94
  95 static uint32_t spiDivisorToBRbits(SPI_TypeDef *instance, uint16_t divisor)
  96 {
  97 #if !defined(STM32H7)
  98     // SPI2 and SPI3 are on APB1/AHB1 which PCLK is half that of APB2/AHB2.
  99
 100     if (instance == SPI2 || instance == SPI3) {
 101         divisor /= 2; // Safe for divisor == 0 or 1
 102     }
 103 #else
 104     UNUSED(instance);
 105 #endif
 106
 107     divisor = constrain(divisor, 2, 256);
 108
 109 #if defined(STM32H7)
 110     const uint32_t baudRatePrescaler[8] = {
 111         LL_SPI_BAUDRATEPRESCALER_DIV2,
 112         LL_SPI_BAUDRATEPRESCALER_DIV4,
 113         LL_SPI_BAUDRATEPRESCALER_DIV8,
 114         LL_SPI_BAUDRATEPRESCALER_DIV16,
 115         LL_SPI_BAUDRATEPRESCALER_DIV32,
 116         LL_SPI_BAUDRATEPRESCALER_DIV64,
 117         LL_SPI_BAUDRATEPRESCALER_DIV128,
 118         LL_SPI_BAUDRATEPRESCALER_DIV256,
 119     };
 120     int prescalerIndex = ffs(divisor) - 2; // prescaler begins at "/2"
 121
 122     return baudRatePrescaler[prescalerIndex];
 123 #else
 124     return (ffs(divisor) - 2) << SPI_CR1_BR_Pos;
 125 #endif
 126 }
 127
 128 void spiInitDevice(SPIDevice device)
 129 {
 130     spiDevice_t *spi = &spiDevice[device];
 131
 132     if (!spi->dev) {
 133         return;
 134     }
 135
 136     // Enable SPI clock
 137     RCC_ClockCmd(spi->rcc, ENABLE);
 138     RCC_ResetCmd(spi->rcc, ENABLE);
 139
 140     IOInit(IOGetByTag(spi->sck),  OWNER_SPI_SCK,  RESOURCE_INDEX(device));
 141     IOInit(IOGetByTag(spi->miso), OWNER_SPI_MISO, RESOURCE_INDEX(device));
 142     IOInit(IOGetByTag(spi->mosi), OWNER_SPI_MOSI, RESOURCE_INDEX(device));
 143
 144     IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->misoAF);
 145     IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->mosiAF);
 146     IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_HIGH, spi->sckAF);
 147
 148     LL_SPI_Disable(spi->dev);
 149     LL_SPI_DeInit(spi->dev);
 150
 151 #if defined(STM32H7)
 152     // Prevent glitching when SPI is disabled
 153     LL_SPI_EnableGPIOControl(spi->dev);
 154
 155     LL_SPI_SetFIFOThreshold(spi->dev, LL_SPI_FIFO_TH_01DATA);
 156     LL_SPI_Init(spi->dev, &defaultInit);
 157 #else
 158     LL_SPI_SetRxFIFOThreshold(spi->dev, SPI_RXFIFO_THRESHOLD_QF);
 159
 160     LL_SPI_Init(spi->dev, &defaultInit);
 161     LL_SPI_Enable(spi->dev);
 162 #endif
 163 }
 164
 165 void spiInternalResetDescriptors(busDevice_t *bus)
 166 {
 167     LL_DMA_InitTypeDef *initTx = bus->initTx;
 168
 169     LL_DMA_StructInit(initTx);
 170 #if defined(STM32G4) || defined(STM32H7)
 171     initTx->PeriphRequest = bus->dmaTx->channel;
 172 #else
 173     initTx->Channel = bus->dmaTx->channel;
 174 #endif
 175     initTx->Mode = LL_DMA_MODE_NORMAL;
 176     initTx->Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
 177 #if defined(STM32H7)
 178     initTx->PeriphOrM2MSrcAddress = (uint32_t)&bus->busType_u.spi.instance->TXDR;
 179 #else
 180     initTx->PeriphOrM2MSrcAddress = (uint32_t)&bus->busType_u.spi.instance->DR;
 181 #endif
 182     initTx->Priority = LL_DMA_PRIORITY_LOW;
 183     initTx->PeriphOrM2MSrcIncMode  = LL_DMA_PERIPH_NOINCREMENT;
 184     initTx->PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
 185     initTx->MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
 186
 187     if (bus->dmaRx) {
 188         LL_DMA_InitTypeDef *initRx = bus->initRx;
 189
 190         LL_DMA_StructInit(initRx);
 191 #if defined(STM32G4) || defined(STM32H7)
 192         initRx->PeriphRequest = bus->dmaRx->channel;
 193 #else
 194         initRx->Channel = bus->dmaRx->channel;
 195 #endif
 196         initRx->Mode = LL_DMA_MODE_NORMAL;
 197         initRx->Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
 198 #if defined(STM32H7)
 199         initRx->PeriphOrM2MSrcAddress = (uint32_t)&bus->busType_u.spi.instance->RXDR;
 200 #else
 201         initRx->PeriphOrM2MSrcAddress = (uint32_t)&bus->busType_u.spi.instance->DR;
 202 #endif
 203         initRx->Priority = LL_DMA_PRIORITY_LOW;
 204         initRx->PeriphOrM2MSrcIncMode  = LL_DMA_PERIPH_NOINCREMENT;
 205         initRx->PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
 206     }
 207 }
 208
 209 void spiInternalResetStream(dmaChannelDescriptor_t *descriptor)
 210 {
 211     // Disable the stream
 212 #if defined(STM32G4)
 213     LL_DMA_DisableChannel(descriptor->dma, descriptor->stream);
 214     while (LL_DMA_IsEnabledChannel(descriptor->dma, descriptor->stream));
 215 #else
 216     LL_DMA_DisableStream(descriptor->dma, descriptor->stream);
 217     while (LL_DMA_IsEnabledStream(descriptor->dma, descriptor->stream));
 218 #endif
 219
 220     // Clear any pending interrupt flags
 221     DMA_CLEAR_FLAG(descriptor, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 222 }
 223
 224
 225 static bool spiInternalReadWriteBufPolled(SPI_TypeDef *instance, const uint8_t *txData, uint8_t *rxData, int len)
 226 {
 227 #if defined(STM32H7)
 228     LL_SPI_SetTransferSize(instance, len);
 229     LL_SPI_Enable(instance);
 230     LL_SPI_StartMasterTransfer(instance);
 231     while (len) {
 232         while (!LL_SPI_IsActiveFlag_TXP(instance));
 233         uint8_t b = txData ? *(txData++) : 0xFF;
 234         LL_SPI_TransmitData8(instance, b);
 235
 236         while (!LL_SPI_IsActiveFlag_RXP(instance));
 237         b = LL_SPI_ReceiveData8(instance);
 238         if (rxData) {
 239             *(rxData++) = b;
 240         }
 241         --len;
 242     }
 243     while (!LL_SPI_IsActiveFlag_EOT(instance));
 244     LL_SPI_ClearFlag_TXTF(instance);
 245     LL_SPI_Disable(instance);
 246 #else
 247     // set 16-bit transfer
 248     CLEAR_BIT(instance->CR2, SPI_RXFIFO_THRESHOLD);
 249     while (len > 1) {
 250         while (!LL_SPI_IsActiveFlag_TXE(instance));
 251         uint16_t w;
 252         if (txData) {
 253             w = *((uint16_t *)txData);
 254             txData += 2;
 255         } else {
 256             w = 0xFFFF;
 257         }
 258         LL_SPI_TransmitData16(instance, w);
 259
 260         while (!LL_SPI_IsActiveFlag_RXNE(instance));
 261         w = LL_SPI_ReceiveData16(instance);
 262         if (rxData) {
 263             *((uint16_t *)rxData) = w;
 264             rxData += 2;
 265         }
 266         len -= 2;
 267     }
 268     // set 8-bit transfer
 269     SET_BIT(instance->CR2, SPI_RXFIFO_THRESHOLD);
 270     if (len) {
 271         while (!LL_SPI_IsActiveFlag_TXE(instance));
 272         uint8_t b = txData ? *(txData++) : 0xFF;
 273         LL_SPI_TransmitData8(instance, b);
 274
 275         while (!LL_SPI_IsActiveFlag_RXNE(instance));
 276         b = LL_SPI_ReceiveData8(instance);
 277         if (rxData) {
 278             *(rxData++) = b;
 279         }
 280         --len;
 281     }
 282 #endif
 283
 284     return true;
 285 }
 286
 287 void spiInternalInitStream(const extDevice_t *dev, bool preInit)
 288 {
 289     STATIC_DMA_DATA_AUTO uint8_t dummyTxByte = 0xff;
 290     STATIC_DMA_DATA_AUTO uint8_t dummyRxByte;
 291     busDevice_t *bus = dev->bus;
 292
 293     busSegment_t *segment = bus->curSegment;
 294
 295     if (preInit) {
 296         // Prepare the init structure for the next segment to reduce inter-segment interval
 297         segment++;
 298         if(segment->len == 0) {
 299             // There's no following segment
 300             return;
 301         }
 302     }
 303
 304     int len = segment->len;
 305
 306     uint8_t *txData = segment->u.buffers.txData;
 307     LL_DMA_InitTypeDef *initTx = bus->initTx;
 308
 309     if (txData) {
 310 #ifdef __DCACHE_PRESENT
 311 #ifdef STM32H7
 312         if ((txData < &_dmaram_start__) || (txData >= &_dmaram_end__)) {
 313 #else
 314         // No need to flush DTCM memory
 315         if (!IS_DTCM(txData)) {
 316 #endif
 317             // Flush the D cache to ensure the data to be written is in main memory
 318             SCB_CleanDCache_by_Addr(
 319                     (uint32_t *)((uint32_t)txData & ~CACHE_LINE_MASK),
 320                     (((uint32_t)txData & CACHE_LINE_MASK) + len - 1 + CACHE_LINE_SIZE) & ~CACHE_LINE_MASK);
 321         }
 322 #endif // __DCACHE_PRESENT
 323         initTx->MemoryOrM2MDstAddress = (uint32_t)txData;
 324         initTx->MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
 325     } else {
 326         initTx->MemoryOrM2MDstAddress = (uint32_t)&dummyTxByte;
 327         initTx->MemoryOrM2MDstIncMode = LL_DMA_MEMORY_NOINCREMENT;
 328     }
 329     initTx->NbData = len;
 330
 331 #if !defined(STM32G4) && !defined(STM32H7)
 332     if (dev->bus->dmaRx) {
 333 #endif
 334         uint8_t *rxData = segment->u.buffers.rxData;
 335         LL_DMA_InitTypeDef *initRx = bus->initRx;
 336
 337         if (rxData) {
 338             /* Flush the D cache for the start and end of the receive buffer as
 339              * the cache will be invalidated after the transfer and any valid data
 340              * just before/after must be in memory at that point
 341              */
 342 #ifdef __DCACHE_PRESENT
 343             // No need to flush/invalidate DTCM memory
 344 #ifdef STM32H7
 345             if ((rxData < &_dmaram_start__) || (rxData >= &_dmaram_end__)) {
 346 #else
 347             // No need to flush DTCM memory
 348             if (!IS_DTCM(rxData)) {
 349 #endif
 350                 SCB_CleanInvalidateDCache_by_Addr(
 351                         (uint32_t *)((uint32_t)rxData & ~CACHE_LINE_MASK),
 352                         (((uint32_t)rxData & CACHE_LINE_MASK) + len - 1 + CACHE_LINE_SIZE) & ~CACHE_LINE_MASK);
 353             }
 354 #endif // __DCACHE_PRESENT
 355         initRx->MemoryOrM2MDstAddress = (uint32_t)rxData;
 356         initRx->MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
 357     } else {
 358         initRx->MemoryOrM2MDstAddress = (uint32_t)&dummyRxByte;
 359         initRx->MemoryOrM2MDstIncMode = LL_DMA_MEMORY_NOINCREMENT;
 360     }
 361     initRx->NbData = len;
 362 #if !defined(STM32G4) && !defined(STM32H7)
 363     }
 364 #endif
 365 }
 366
 367 void spiInternalStartDMA(const extDevice_t *dev)
 368 {
 369     busDevice_t *bus = dev->bus;
 370
 371     // Assert Chip Select
 372     IOLo(dev->busType_u.spi.csnPin);
 373
 374     dmaChannelDescriptor_t *dmaTx = bus->dmaTx;
 375     dmaChannelDescriptor_t *dmaRx = bus->dmaRx;
 376
 377 #if !defined(STM32G4) && !defined(STM32H7)
 378     if (dmaRx) {
 379 #endif
 380         // Use the correct callback argument
 381         dmaRx->userParam = (uint32_t)dev;
 382
 383         // Clear transfer flags
 384         DMA_CLEAR_FLAG(dmaTx, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 385         DMA_CLEAR_FLAG(dmaRx, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 386
 387 #ifdef STM32G4
 388         // Disable channels to enable update
 389         LL_DMA_DisableChannel(dmaTx->dma, dmaTx->stream);
 390         LL_DMA_DisableChannel(dmaRx->dma, dmaRx->stream);
 391
 392         /* Use the Rx interrupt as this occurs once the SPI operation is complete whereas the Tx interrupt
 393          * occurs earlier when the Tx FIFO is empty, but the SPI operation is still in progress
 394          */
 395         LL_DMA_EnableIT_TC(dmaRx->dma, dmaRx->stream);
 396
 397         // Update channels
 398         LL_DMA_Init(dmaTx->dma, dmaTx->stream, bus->initTx);
 399         LL_DMA_Init(dmaRx->dma, dmaRx->stream, bus->initRx);
 400
 401         LL_SPI_EnableDMAReq_RX(dev->bus->busType_u.spi.instance);
 402
 403         // Enable channels
 404         LL_DMA_EnableChannel(dmaTx->dma, dmaTx->stream);
 405         LL_DMA_EnableChannel(dmaRx->dma, dmaRx->stream);
 406
 407         LL_SPI_EnableDMAReq_TX(dev->bus->busType_u.spi.instance);
 408 #else
 409         DMA_Stream_TypeDef *streamRegsTx = (DMA_Stream_TypeDef *)dmaTx->ref;
 410         DMA_Stream_TypeDef *streamRegsRx = (DMA_Stream_TypeDef *)dmaRx->ref;
 411
 412         // Disable streams to enable update
 413         LL_DMA_WriteReg(streamRegsTx, CR, 0U);
 414         LL_DMA_WriteReg(streamRegsRx, CR, 0U);
 415
 416         /* Use the Rx interrupt as this occurs once the SPI operation is complete whereas the Tx interrupt
 417          * occurs earlier when the Tx FIFO is empty, but the SPI operation is still in progress
 418          */
 419         LL_EX_DMA_EnableIT_TC(streamRegsRx);
 420
 421         // Update streams
 422         LL_DMA_Init(dmaTx->dma, dmaTx->stream, bus->initTx);
 423         LL_DMA_Init(dmaRx->dma, dmaRx->stream, bus->initRx);
 424
 425         /* Note from AN4031
 426          *
 427          * If the user enables the used peripheral before the corresponding DMA stream, a “FEIF”
 428          * (FIFO Error Interrupt Flag) may be set due to the fact the DMA is not ready to provide
 429          * the first required data to the peripheral (in case of memory-to-peripheral transfer).
 430          */
 431
 432         // Enable the SPI DMA Tx & Rx requests
 433 #if defined(STM32H7)
 434         LL_SPI_SetTransferSize(dev->bus->busType_u.spi.instance, dev->bus->curSegment->len);
 435         LL_DMA_EnableStream(dmaTx->dma, dmaTx->stream);
 436         LL_DMA_EnableStream(dmaRx->dma, dmaRx->stream);
 437         SET_BIT(dev->bus->busType_u.spi.instance->CFG1, SPI_CFG1_RXDMAEN | SPI_CFG1_TXDMAEN);
 438         LL_SPI_Enable(dev->bus->busType_u.spi.instance);
 439         LL_SPI_StartMasterTransfer(dev->bus->busType_u.spi.instance);
 440 #else
 441         // Enable streams
 442         LL_DMA_EnableStream(dmaTx->dma, dmaTx->stream);
 443         LL_DMA_EnableStream(dmaRx->dma, dmaRx->stream);
 444
 445         SET_BIT(dev->bus->busType_u.spi.instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);
 446 #endif
 447 #if !defined(STM32G4) && !defined(STM32H7)
 448     } else {
 449         DMA_Stream_TypeDef *streamRegsTx = (DMA_Stream_TypeDef *)dmaTx->ref;
 450
 451         // Use the correct callback argument
 452         dmaTx->userParam = (uint32_t)dev;
 453
 454         // Clear transfer flags
 455         DMA_CLEAR_FLAG(dmaTx, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 456
 457         // Disable streams to enable update
 458         LL_DMA_WriteReg(streamRegsTx, CR, 0U);
 459
 460         LL_EX_DMA_EnableIT_TC(streamRegsTx);
 461
 462         // Update streams
 463         LL_DMA_Init(dmaTx->dma, dmaTx->stream, bus->initTx);
 464
 465         /* Note from AN4031
 466          *
 467          * If the user enables the used peripheral before the corresponding DMA stream, a “FEIF”
 468          * (FIFO Error Interrupt Flag) may be set due to the fact the DMA is not ready to provide
 469          * the first required data to the peripheral (in case of memory-to-peripheral transfer).
 470          */
 471
 472         // Enable the SPI DMA Tx request
 473         // Enable streams
 474         LL_DMA_EnableStream(dmaTx->dma, dmaTx->stream);
 475
 476         SET_BIT(dev->bus->busType_u.spi.instance->CR2, SPI_CR2_TXDMAEN);
 477     }
 478 #endif
 479 #endif
 480 }
 481
 482 void spiInternalStopDMA (const extDevice_t *dev)
 483 {
 484     busDevice_t *bus = dev->bus;
 485
 486     dmaChannelDescriptor_t *dmaTx = bus->dmaTx;
 487     dmaChannelDescriptor_t *dmaRx = bus->dmaRx;
 488     SPI_TypeDef *instance = bus->busType_u.spi.instance;
 489
 490 #if !defined(STM32G4) && !defined(STM32H7)
 491     if (dmaRx) {
 492 #endif
 493         // Disable the DMA engine and SPI interface
 494 #ifdef STM32G4
 495         LL_DMA_DisableChannel(dmaTx->dma, dmaTx->stream);
 496         LL_DMA_DisableChannel(dmaRx->dma, dmaRx->stream);
 497 #else
 498         LL_DMA_DisableStream(dmaRx->dma, dmaRx->stream);
 499         LL_DMA_DisableStream(dmaTx->dma, dmaTx->stream);
 500 #endif
 501
 502         // Clear transfer flags
 503         DMA_CLEAR_FLAG(dmaRx, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 504
 505         LL_SPI_DisableDMAReq_TX(instance);
 506         LL_SPI_DisableDMAReq_RX(instance);
 507 #if defined(STM32H7)
 508         LL_SPI_ClearFlag_TXTF(dev->bus->busType_u.spi.instance);
 509         LL_SPI_Disable(dev->bus->busType_u.spi.instance);
 510 #endif
 511 #if !defined(STM32G4) && !defined(STM32H7)
 512     } else {
 513         SPI_TypeDef *instance = bus->busType_u.spi.instance;
 514
 515         // Ensure the current transmission is complete
 516         while (LL_SPI_IsActiveFlag_BSY(instance));
 517
 518         // Drain the RX buffer
 519         while (LL_SPI_IsActiveFlag_RXNE(instance)) {
 520             instance->DR;
 521         }
 522
 523         // Disable the DMA engine and SPI interface
 524         LL_DMA_DisableStream(dmaTx->dma, dmaTx->stream);
 525
 526         DMA_CLEAR_FLAG(dmaTx, DMA_IT_HTIF | DMA_IT_TEIF | DMA_IT_TCIF);
 527
 528         LL_SPI_DisableDMAReq_TX(instance);
 529 #endif
 530 #if !defined(STM32G4) && !defined(STM32H7)
 531     }
 532 #endif
 533 }
 534
 535 // DMA transfer setup and start
 536 void spiSequenceStart(const extDevice_t *dev)
 537 {
 538     busDevice_t *bus = dev->bus;
 539     SPI_TypeDef *instance = bus->busType_u.spi.instance;
 540     spiDevice_t *spi = &spiDevice[spiDeviceByInstance(instance)];
 541     bool dmaSafe = dev->useDMA;
 542     uint32_t xferLen = 0;
 543     uint32_t segmentCount = 0;
 544
 545     bus->initSegment = true;
 546
 547     // Switch bus speed
 548 #if !defined(STM32H7)
 549     LL_SPI_Disable(instance);
 550 #endif
 551
 552     if (dev->busType_u.spi.speed != bus->busType_u.spi.speed) {
 553         LL_SPI_SetBaudRatePrescaler(instance, spiDivisorToBRbits(instance, dev->busType_u.spi.speed));
 554         bus->busType_u.spi.speed = dev->busType_u.spi.speed;
 555     }
 556
 557     // Switch SPI clock polarity/phase if necessary
 558     if (dev->busType_u.spi.leadingEdge != bus->busType_u.spi.leadingEdge) {
 559         if (dev->busType_u.spi.leadingEdge) {
 560             IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_LOW, spi->sckAF);
 561             LL_SPI_SetClockPhase(instance, LL_SPI_PHASE_1EDGE);
 562             LL_SPI_SetClockPolarity(instance, LL_SPI_POLARITY_LOW);
 563         }
 564         else {
 565             IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG_HIGH, spi->sckAF);
 566             LL_SPI_SetClockPhase(instance, LL_SPI_PHASE_2EDGE);
 567             LL_SPI_SetClockPolarity(instance, LL_SPI_POLARITY_HIGH);
 568         }
 569
 570         bus->busType_u.spi.leadingEdge = dev->busType_u.spi.leadingEdge;
 571     }
 572
 573 #if !defined(STM32H7)
 574     LL_SPI_Enable(instance);
 575 #endif
 576
 577     /* Where data is being read into a buffer which is cached, where the start or end of that
 578      * buffer is not cache aligned, there is a risk of corruption of other data in that cache line.
 579      * After the read is complete, the cache lines covering the structure will be invalidated to ensure
 580      * that the processor sees the read data, not what was in cache previously. Unfortunately if
 581      * there is any other data in the area covered by those cache lines, at the start or end of the
 582      * buffer, it too will be invalidated, so had the processor written to those locations during the DMA
 583      * operation those written values will be lost.
 584      */
 585
 586     // Check that any reads are cache aligned and of multiple cache lines in length
 587     for (busSegment_t *checkSegment = bus->curSegment; checkSegment->len; checkSegment++) {
 588         // Check there is no receive data as only transmit DMA is available
 589         if ((checkSegment->u.buffers.rxData) && (bus->dmaRx == (dmaChannelDescriptor_t *)NULL)) {
 590             dmaSafe = false;
 591             break;
 592         }
 593 #ifdef STM32H7
 594         // Check if RX data can be DMAed
 595         if ((checkSegment->u.buffers.rxData) &&
 596             // DTCM can't be accessed by DMA1/2 on the H7
 597             (IS_DTCM(checkSegment->u.buffers.rxData) ||
 598              // Memory declared as DMA_RAM will have an address between &_dmaram_start__ and &_dmaram_end__
 599              (((checkSegment->u.buffers.rxData < &_dmaram_start__) || (checkSegment->u.buffers.rxData >= &_dmaram_end__)) &&
 600              (((uint32_t)checkSegment->u.buffers.rxData & (CACHE_LINE_SIZE - 1)) || (checkSegment->len & (CACHE_LINE_SIZE - 1)))))) {
 601             dmaSafe = false;
 602             break;
 603         }
 604         // Check if TX data can be DMAed
 605         else if ((checkSegment->u.buffers.txData) && IS_DTCM(checkSegment->u.buffers.txData)) {
 606             dmaSafe = false;
 607             break;
 608         }
 609 #elif defined(STM32F7)
 610         if ((checkSegment->u.buffers.rxData) &&
 611             // DTCM is accessible and uncached on the F7
 612             (!IS_DTCM(checkSegment->u.buffers.rxData) &&
 613             (((uint32_t)checkSegment->u.buffers.rxData & (CACHE_LINE_SIZE - 1)) || (checkSegment->len & (CACHE_LINE_SIZE - 1))))) {
 614             dmaSafe = false;
 615             break;
 616         }
 617 #elif defined(STM32G4)
 618         // Check if RX data can be DMAed
 619         if ((checkSegment->u.buffers.rxData) &&
 620             // CCM can't be accessed by DMA1/2 on the G4
 621             IS_CCM(checkSegment->u.buffers.rxData)) {
 622             dmaSafe = false;
 623             break;
 624         }
 625         if ((checkSegment->u.buffers.txData) &&
 626             // CCM can't be accessed by DMA1/2 on the G4
 627             IS_CCM(checkSegment->u.buffers.txData)) {
 628             dmaSafe = false;
 629             break;
 630         }
 631 #endif
 632         // Note that these counts are only valid if dmaSafe is true
 633         segmentCount++;
 634         xferLen += checkSegment->len;
 635     }
 636
 637     // Use DMA if possible
 638     if (bus->useDMA && dmaSafe && ((segmentCount > 1) || (xferLen > 8))) {
 639         // Intialise the init structures for the first transfer
 640         spiInternalInitStream(dev, false);
 641
 642         // Start the transfers
 643         spiInternalStartDMA(dev);
 644     } else {
 645         // Manually work through the segment list performing a transfer for each
 646         while (bus->curSegment->len) {
 647             // Assert Chip Select
 648             IOLo(dev->busType_u.spi.csnPin);
 649
 650             spiInternalReadWriteBufPolled(
 651                     bus->busType_u.spi.instance,
 652                     bus->curSegment->u.buffers.txData,
 653                     bus->curSegment->u.buffers.rxData,
 654                     bus->curSegment->len);
 655
 656             if (bus->curSegment->negateCS) {
 657                 // Negate Chip Select
 658                 IOHi(dev->busType_u.spi.csnPin);
 659             }
 660
 661             if (bus->curSegment->callback) {
 662                 switch(bus->curSegment->callback(dev->callbackArg)) {
 663                 case BUS_BUSY:
 664                     // Repeat the last DMA segment
 665                     bus->curSegment--;
 666                     break;
 667
 668                 case BUS_ABORT:
 669                     bus->curSegment = (busSegment_t *)BUS_SPI_FREE;
 670                     return;
 671
 672                 case BUS_READY:
 673                 default:
 674                     // Advance to the next DMA segment
 675                     break;
 676                 }
 677             }
 678             bus->curSegment++;
 679         }
 680
 681         // If a following transaction has been linked, start it
 682         if (bus->curSegment->u.link.dev) {
 683             const extDevice_t *nextDev = bus->curSegment->u.link.dev;
 684             busSegment_t *nextSegments = bus->curSegment->u.link.segments;
 685             busSegment_t *endSegment = bus->curSegment;
 686             bus->curSegment = nextSegments;
 687             endSegment->u.link.dev = NULL;
 688             spiSequenceStart(nextDev);
 689         } else {
 690             // The end of the segment list has been reached, so mark transactions as complete
 691             bus->curSegment = (busSegment_t *)BUS_SPI_FREE;
 692         }
 693     }
 694 }
 695 #endif