fix(sdcard): migrate dmaInit() to ownership-checked dmaAllocate()

sdcard.c (SPI-mode) and sdio_f4xx.c/sdio_f7xx.c (SDIO-mode) called
dmaInit(), which silently overwrites any existing DMA owner. Replace
with dmaAllocate() + dmaEnable(), matching the pattern already used
by ADC, transponder, LED strip, and motors.

sdcard.c falls back to polled SPI (clearing useDMAForTx) on claim
failure instead of aborting card init entirely -- useDMAForTx is
already checked as a runtime gate at every transfer/completion site,
so this is a supported fallback, not a new code path. Losing DMA
acceleration is preferable to losing the SD card (and blackbox
logging) over an unrelated DMA conflict.

sdio_f4xx.c/sdio_f7xx.c change SD_Initialize_LL() from void to bool,
matching BF's return type, with the claim check moved to the very
top before any RCC/GPIO/DMA register access. sdio_h7xx.c's no-op
stub (H7 uses internal IDMA) is now bool too, matching BF exactly.

The claim intentionally resolves the DMA identifier from the `dma`
parameter, not a file-scope static -- BF 4.5-maintenance's own
equivalent computes it from a stale static assigned only after the
check, making dmaAllocate() operate on an invalid identifier and the
function always return false. That bug was fixed in BF master
(PR#14990, function since renamed SD_InitialiseHardware) as a side
effect of an unrelated DMA-API refactor, not a targeted fix. Not
filed upstream per explicit instruction; tracked in
BF45-SDIO-DMASTREAM-BUG.md instead.

Two callers (usbd_storage_sdio.c, sdcard_sdio_baremetal.c) previously
ignored SD_Initialize_LL()'s return value entirely. Since neither
caller configures the DMA stream itself, a claim failure would leave
the file-scope dma_stream pointer NULL, and the first real card
transfer would dereference it in SD_StartBlockTransfert() -- both
callers now check the return and bail to SDCARD_STATE_NOT_PRESENT
(or an equivalent failure return) instead.

sdcard_init() and SD_Initialize_LL() can each be called twice per
boot (once from fc_init.c, once from the USB MSC passthrough path)
for the same logical OWNER_SDCARD. Added sdcardDmaClaim()/
sdioDmaClaim(), matching the existing uartDmaClaim()/dshotDmaClaim()
pattern: a stream already held by the same owner+resourceIndex is
treated as an already-successful claim, so the second call is not
mistaken for a real conflict.

Author: nerdCopter

src/main/drivers/sdcard.c

@@ -473,6 +473,15 @@ static bool sdcard_checkInitDone(void) {
     return status == 0x00;
 }
 
+// sdcard_init() can be called from both boot init and the USB MSC passthrough path -- a
+// stream already held by this same owner must be re-claimable.
+static bool sdcardDmaClaim(dmaIdentifier_e identifier, resourceOwner_e owner, uint8_t resourceIndex) {
+    if (dmaGetOwner(identifier) == owner && dmaGetResourceIndex(identifier) == resourceIndex) {
+        return true;
+    }
+    return dmaAllocate(identifier, owner, resourceIndex);
+}
+
 /**
  * Begin the initialization process for the SD card. This must be called first before any other sdcard_ routine.
  */
@@ -489,11 +498,17 @@ void sdcard_init(const sdcardConfig_t *config) {
     sdcard.useDMAForTx = config->useDma;
 #endif
     if (sdcard.useDMAForTx) {
+        if (sdcardDmaClaim(config->dmaIdentifier, OWNER_SDCARD, 0)) {
 #if defined(STM32F4) || defined(STM32F7)
-        sdcard.dmaChannel = config->dmaChannel;
+            sdcard.dmaChannel = config->dmaChannel;
 #endif
-        sdcard.dma = dmaGetDescriptorByIdentifier(config->dmaIdentifier);
-        dmaInit(config->dmaIdentifier, OWNER_SDCARD, 0);
+            sdcard.dma = dmaGetDescriptorByIdentifier(config->dmaIdentifier);
+            dmaEnable(config->dmaIdentifier);
+        } else {
+            // Stream already owned by another peripheral -- fall back to polled SPI
+            // rather than losing the card (and blackbox logging) entirely.
+            sdcard.useDMAForTx = false;
+        }
     }
     if (config->chipSelectTag) {
         sdcard.chipSelectPin = IOGetByTag(config->chipSelectTag);

src/main/drivers/sdcard_sdio_baremetal.c

@@ -286,10 +286,14 @@ void sdcard_init(const sdcardConfig_t *config) {
         sdcard.useCache = 0;
     }
 #if defined(STM32H7)
-    SD_Initialize_LL(NULL);
+    if (!SD_Initialize_LL(NULL)) {
 #else
-    SD_Initialize_LL(dmaGetRefByIdentifier(sdcard.dma));
+    if (!SD_Initialize_LL(dmaGetRefByIdentifier(sdcard.dma))) {
 #endif
+        sdcard.state = SDCARD_STATE_NOT_PRESENT;
+        sdcard.failureCount++;
+        return;
+    }
     if (SD_IsDetected()) {
         if (SD_Init() != 0) {
             sdcard.state = SDCARD_STATE_NOT_PRESENT;

src/main/drivers/sdio_f4xx.c

@@ -1305,11 +1305,24 @@ static SD_Error_t SD_IsCardProgramming(uint8_t *pStatus)
 }
 */
 
+// SD_Initialize_LL() can be called from both the sdcard driver's own init and the USB MSC
+// passthrough path -- a stream already held by this same owner must be re-claimable.
+static bool sdioDmaClaim(dmaIdentifier_e identifier, resourceOwner_e owner, uint8_t resourceIndex) {
+    if (dmaGetOwner(identifier) == owner && dmaGetResourceIndex(identifier) == resourceIndex) {
+        return true;
+    }
+    return dmaAllocate(identifier, owner, resourceIndex);
+}
+
 /** -----------------------------------------------------------------------------------------------------------------*/
 /**
   * @brief  Initialize the SDIO module, DMA, and IO
   */
-void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
+bool SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
+    if (!(dma == DMA2_Stream3 || dma == DMA2_Stream6) || !sdioDmaClaim(dmaGetIdentifier(dma), OWNER_SDCARD, 0)) {
+        return false;
+    }
+    dmaEnable(dmaGetIdentifier(dma));
     // Reset SDIO Module
     RCC->APB2RSTR |=  RCC_APB2RSTR_SDIORST;
     delay(1);
@@ -1362,7 +1375,6 @@ void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
                               DMA_MBURST_INC4      | DMA_PBURST_INC4        |
                               DMA_MEMORY_TO_PERIPH);
         DMA2_Stream3->FCR  = (DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);                 // Configuration FIFO control register
-        dmaInit(dmaGetIdentifier(DMA2_Stream3), OWNER_SDCARD, 0);
         dmaSetHandler(dmaGetIdentifier(DMA2_Stream3), SDIO_DMA_ST3_IRQHandler, 1, 0);
     } else {
         // Initialize DMA2 channel 6
@@ -1375,9 +1387,9 @@ void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
                               DMA_MBURST_INC4      | DMA_PBURST_INC4        |
                               DMA_MEMORY_TO_PERIPH);
         DMA2_Stream6->FCR  = (DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);                 // Configuration FIFO control register
-        dmaInit(dmaGetIdentifier(DMA2_Stream6), OWNER_SDCARD, 0);
         dmaSetHandler(dmaGetIdentifier(DMA2_Stream6), SDIO_DMA_ST6_IRQHandler, 1, 0);
     }
+    return true;
 }
 
 

src/main/drivers/sdio_f7xx.c

@@ -1326,11 +1326,24 @@ static SD_Error_t SD_IsCardProgramming(uint8_t *pStatus)
 }
 */
 
+// SD_Initialize_LL() can be called from both the sdcard driver's own init and the USB MSC
+// passthrough path -- a stream already held by this same owner must be re-claimable.
+static bool sdioDmaClaim(dmaIdentifier_e identifier, resourceOwner_e owner, uint8_t resourceIndex) {
+    if (dmaGetOwner(identifier) == owner && dmaGetResourceIndex(identifier) == resourceIndex) {
+        return true;
+    }
+    return dmaAllocate(identifier, owner, resourceIndex);
+}
+
 /** -----------------------------------------------------------------------------------------------------------------*/
 /**
   * @brief  Initialize the SDMMC1 module, DMA, and IO
   */
-void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
+bool SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
+    if (!(dma == DMA2_Stream3 || dma == DMA2_Stream6) || !sdioDmaClaim(dmaGetIdentifier(dma), OWNER_SDCARD, 0)) {
+        return false;
+    }
+    dmaEnable(dmaGetIdentifier(dma));
     // Reset SDMMC1 Module
     RCC->APB2RSTR |=  RCC_APB2RSTR_SDMMC1RST;
     delay(1);
@@ -1386,7 +1399,6 @@ void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
                               DMA_MBURST_INC4      | DMA_PBURST_INC4        |
                               DMA_MEMORY_TO_PERIPH);
         DMA2_Stream3->FCR  = (DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);                 // Configuration FIFO control register
-        dmaInit(dmaGetIdentifier(DMA2_Stream3), OWNER_SDCARD, 0);
         dmaSetHandler(dmaGetIdentifier(DMA2_Stream3), SDMMC_DMA_ST3_IRQHandler, 1, 0);
     } else {
         // Initialize DMA2 channel 6
@@ -1399,9 +1411,9 @@ void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
                               DMA_MBURST_INC4      | DMA_PBURST_INC4        |
                               DMA_MEMORY_TO_PERIPH);
         DMA2_Stream6->FCR  = (DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);                 // Configuration FIFO control register
-        dmaInit(dmaGetIdentifier(DMA2_Stream6), OWNER_SDCARD, 0);
         dmaSetHandler(dmaGetIdentifier(DMA2_Stream6), SDMMC_DMA_ST6_IRQHandler, 1, 0);
     }
+    return true;
 }
 
 

src/main/drivers/sdio_h7xx.c

@@ -734,9 +734,10 @@ bool SD_IsDetected(void) {
     return status;
 }
 
-void SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
+bool SD_Initialize_LL(DMA_Stream_TypeDef *dma) {
     UNUSED(dma);
     // H7 uses SDMMC internal DMA (IDMA) — no external DMA stream configuration needed.
+    return true;
 }
 
 void SDMMC1_IRQHandler(void)

src/main/drivers/sdmmc_sdio.h

@@ -216,7 +216,7 @@ typedef struct {
 extern           SD_CardInfo_t               SD_CardInfo;
 extern           SD_CardType_t               SD_CardType;
 
-void             SD_Initialize_LL            (DMA_Stream_TypeDef *dma);
+bool             SD_Initialize_LL            (DMA_Stream_TypeDef *dma);
 SD_Error_t       SD_Init                     (void);
 bool             SD_IsDetected              (void);
 bool             SD_GetState                 (void);

src/main/msc/usbd_storage_sdio.c

@@ -152,7 +152,7 @@ static int8_t STORAGE_Init (uint8_t lun) {
 #endif
     UNUSED(lun);
     LED0_OFF;
-    SD_Initialize_LL(SDIO_DMA);
+    if (!SD_Initialize_LL(SDIO_DMA)) return 1;
     if (SD_Init() != 0) return 1;
     LED0_ON;
     return 0;