mimxrt/sdcard: Implement proper timeout in sdcard_transfer_blocking.

The previous implementation used USDHC_TransferBlocking which has
infinite loops in USDHC_WaitCommandDone and USDHC_TransferDataBlocking
with no timeout mechanism. Even though the wrapper had a timeout loop,
once inside the SDK function there was no way to abort.

This change replaces USDHC_TransferBlocking with USDHC_TransferNonBlocking
combined with polling of interrupt status flags and proper timeout
handling. The function now:
- Checks for card busy state with timeout before starting transfer
- Uses non-blocking SDK transfer to avoid infinite loops
- Polls interrupt flags with timeout for completion
- Properly handles both command-only and data transfers
- Calls error recovery on timeout or error conditions

This ensures that SD card operations will not hang indefinitely when
hardware doesn't respond as expected.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

ports/mimxrt/sdcard.c

@@ -309,20 +309,54 @@ static status_t sdcard_transfer_blocking(USDHC_Type *base, usdhc_handle_t *handl
     // Wait while the card is busy before a transfer
     status = kStatus_Timeout;
     for (int i = 0; i < timeout_ms * 100; i++) {
-        // Wait until Data0 is low any more. Low indicates "Busy".
-        if (((transfer->data->txData == NULL) && (transfer->data->rxData == NULL)) ||
+        // Wait until Data0 is not low any more. Low indicates "Busy".
+        if (((transfer->data == NULL) || ((transfer->data->txData == NULL) && (transfer->data->rxData == NULL))) ||
             (USDHC_GetPresentStatusFlags(base) & (uint32_t)kUSDHC_Data0LineLevelFlag) != 0) {
-            // Not busy anymore or no TX-Data
-            status = USDHC_TransferBlocking(base, &dma_config, transfer);
-            if (status != kStatus_Success) {
+            // Not busy anymore or no data transfer
+            status = kStatus_Success;
+            break;
+        }
+        ticks_delay_us64(10);
+    }
+
+    if (status != kStatus_Success) {
+        return kStatus_Timeout;
+    }
+
+    // Use non-blocking transfer with polling to implement timeout
+    status = USDHC_TransferNonBlocking(base, handle, &dma_config, transfer);
+    if (status != kStatus_Success) {
+        return status;
+    }
+
+    // Poll for transfer completion with timeout
+    uint32_t interruptStatus = 0;
+    uint32_t waitFlags = (transfer->data != NULL) ?
+        (kUSDHC_CommandFlag | kUSDHC_DataDMAFlag) : kUSDHC_CommandFlag;
+
+    for (uint32_t i = 0; i < timeout_ms * 100; i++) {
+        interruptStatus = USDHC_GetInterruptStatusFlags(base);
+
+        // Check for completion or error
+        if ((interruptStatus & waitFlags) != 0) {
+            // Transfer completed (either success or error)
+            // Call the IRQ handler to complete the transfer and invoke callbacks
+            USDHC_TransferHandleIRQ(base, handle);
+
+            // Check if transfer was successful
+            if ((interruptStatus & kUSDHC_ErrorFlag) != 0) {
                 sdcard_error_recovery(base);
+                return kStatus_Fail;
             }
-            break;
+            return kStatus_Success;
         }
+
         ticks_delay_us64(10);
     }
-    return status;
 
+    // Timeout occurred
+    sdcard_error_recovery(base);
+    return kStatus_Timeout;
 }
 
 static void sdcard_decode_csd(mimxrt_sdcard_obj_t *card, csd_t *csd) {