Composite USB for STM32 SDIO (experimental) (#17222)

Marlin/src/HAL/STM32/Sd2Card_sdio_stm32duino.cpp

@@ -27,42 +27,64 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-//#include "SdMscDriver.h"
+#if NONE(STM32F103xE, STM32F103xG, STM32F4xx, STM32F7xx)
+  #error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported"
+#endif
+
+#ifdef USBD_USE_CDC_COMPOSITE
+
+  // use USB drivers
+
+  extern "C" { int8_t SD_MSC_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
+               int8_t SD_MSC_Write(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
+               extern SD_HandleTypeDef hsd;
+  }
+
+  bool SDIO_Init() {
+    if (hsd.State == HAL_SD_STATE_READY) return 1;  // return passing status
+    return 0;                                       // return failing status
+  }
+
+  bool SDIO_ReadBlock(uint32_t block, uint8_t *src) {
+    int8_t status = SD_MSC_Read(0, (uint8_t*)src, block, 1); // read one 512 byte block
+    return (bool) status;
+  }
+
+  bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
+    int8_t status = SD_MSC_Write(0, (uint8_t*)src, block, 1); // write one 512 byte block
+    return (bool) status;
+  }
 
-//#include "usbd_msc_bot.h"
+#else // !USBD_USE_CDC_COMPOSITE
-//#include "usbd_msc_scsi.h"
-//#include "usbd_msc_composite.h"
-//#include "usbd_msc_cdc_composite.h"
 
-//#include "usbd_msc_data.h"
+  // use local drivers
 
-#if defined(STM32F103xE) || defined(STM32F103xG)
+  #if defined(STM32F103xE) || defined(STM32F103xG)
     #include <stm32f1xx_hal_rcc_ex.h>
     #include <stm32f1xx_hal_sd.h>
-#elif defined(STM32F4xx)
+  #elif defined(STM32F4xx)
     #include <stm32f4xx_hal_rcc.h>
     #include <stm32f4xx_hal_dma.h>
     #include <stm32f4xx_hal_gpio.h>
     #include <stm32f4xx_hal_sd.h>
-#elif defined(STM32F7xx)
+  #elif defined(STM32F7xx)
     #include <stm32f7xx_hal_rcc.h>
     #include <stm32f7xx_hal_dma.h>
     #include <stm32f7xx_hal_gpio.h>
     #include <stm32f7xx_hal_sd.h>
-#else
+  #else
     #error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported"
-#endif
+  #endif
 
-SD_HandleTypeDef hsd;  // create SDIO structure
+  SD_HandleTypeDef hsd;  // create SDIO structure
 
-#define TRANSFER_CLOCK_DIV ((uint8_t)SDIO_INIT_CLK_DIV/40)
+  #define TRANSFER_CLOCK_DIV (uint8_t(SDIO_INIT_CLK_DIV) / 40)
 
-#ifndef USBD_OK
+  #ifndef USBD_OK
     #define USBD_OK 0
-#endif
+  #endif
-
-void go_to_transfer_speed() {
 
+  void go_to_transfer_speed() {
     SD_InitTypeDef Init;
 
     /* Default SDIO peripheral configuration for SD card initialization */
@@ -75,10 +97,9 @@ void go_to_transfer_speed() {
 
     /* Initialize SDIO peripheral interface with default configuration */
     SDIO_Init(hsd.Instance, Init);
-}
+  }
-
-void SD_LowLevel_Init(void) {
 
+  void SD_LowLevel_Init(void) {
     uint32_t tempreg;
 
     GPIO_InitTypeDef  GPIO_InitStruct;
@@ -93,10 +114,10 @@ void SD_LowLevel_Init(void) {
     GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
-  #if defined(SDIO_D1_PIN) && defined(SDIO_D2_PIN) && defined(SDIO_D3_PIN)  // define D1-D3 only if have a four bit wide SDIO bus
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)  // define D1-D3 only if have a four bit wide SDIO bus
       GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11;  // D1-D3
       GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Pull = 1;  //GPIO_NOPULL;
+      GPIO_InitStruct.Pull = 1;  // GPIO_NOPULL;
       GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
       GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
       HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
@@ -113,28 +134,23 @@ void SD_LowLevel_Init(void) {
 
     //Initialize the SDIO (with initial <400Khz Clock)
     tempreg = 0;  //Reset value
-  tempreg |= SDIO_CLKCR_CLKEN;  //Clock is enabled
+    tempreg |= SDIO_CLKCR_CLKEN;  // Clock enabled
-  tempreg |= (uint32_t)0x76;  //Clock Divider. Clock = 48000/(118+2) = 400Khz
+    tempreg |= (uint32_t)0x76;    // Clock Divider. Clock = 48000 / (118 + 2) = 400Khz
-  //Keep the rest at 0 => HW_Flow Disabled, Rising Clock Edge, Disable CLK ByPass, Bus Width = 0, Power save Disable
+    // Keep the rest at 0 => HW_Flow Disabled, Rising Clock Edge, Disable CLK ByPass, Bus Width = 0, Power save Disable
     SDIO->CLKCR = tempreg;
 
-  //Power up the SDIO
+    // Power up the SDIO
     SDIO->POWER = 0x03;
-}
+  }
-
 
-void HAL_SD_MspInit(SD_HandleTypeDef *hsd) { // application specific init
+  void HAL_SD_MspInit(SD_HandleTypeDef *hsd) { // application specific init
     UNUSED(hsd);   /* Prevent unused argument(s) compilation warning */
     __HAL_RCC_SDIO_CLK_ENABLE();  // turn on SDIO clock
-}
+  }
 
-constexpr uint8_t SD_RETRY_COUNT = (1
+  constexpr uint8_t SD_RETRY_COUNT = 1 + 2 * ENABLED(SD_CHECK_AND_RETRY);
-  #if ENABLED(SD_CHECK_AND_RETRY)
-    + 2
-  #endif
-);
 
-bool SDIO_Init() {
+  bool SDIO_Init() {
     //init SDIO and get SD card info
 
     uint8_t retryCnt = SD_RETRY_COUNT;
@@ -153,7 +169,7 @@ bool SDIO_Init() {
 
     go_to_transfer_speed();
 
-  #if defined(SDIO_D1_PIN) && defined(SDIO_D2_PIN) && defined(SDIO_D3_PIN) // go to 4 bit wide mode if pins are defined
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3) // go to 4 bit wide mode if pins are defined
       retry_Cnt = retryCnt;
       for (;;) {
         if (!HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B)) break;  // some cards are only 1 bit wide so a pass here is not required
@@ -172,9 +188,9 @@ bool SDIO_Init() {
     #endif
 
     return true;
-}
+  }
 
-void init_SDIO_pins(void) {
+  void init_SDIO_pins(void) {
     GPIO_InitTypeDef GPIO_InitStruct = {0};
 
     /**SDIO GPIO Configuration
@@ -202,24 +218,23 @@ void init_SDIO_pins(void) {
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
-}
+  }
-
-//bool SDIO_init() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
-//bool SDIO_Init_C() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
 
-bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
+  //bool SDIO_init() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
-  bool status;
+  //bool SDIO_Init_C() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
 
+  bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
     hsd.Instance = SDIO;
-
     uint8_t retryCnt = SD_RETRY_COUNT;
 
+    bool status;
     for (;;) {
-    bool status = (bool) HAL_SD_ReadBlocks(&hsd, (uint8_t*)dst, block, 1, 1000);  // read one 512 byte block with 500mS timeout
+      status = (bool) HAL_SD_ReadBlocks(&hsd, (uint8_t*)dst, block, 1, 1000);  // read one 512 byte block with 500mS timeout
       status |= (bool) HAL_SD_GetCardState(&hsd);     // make sure all is OK
-    if (!status)     return false;                  // return passing status
+      if (!status) break;       // return passing status
-    if (!--retryCnt) return true;                   // return failing status if retries are exhausted
+      if (!--retryCnt) break;   // return failing status if retries are exhausted
     }
+    return status;
 
     /*
     return (bool) ((status_read | status_card) ? 1 : 0);
@@ -254,21 +269,21 @@ bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
     */
 
     return true;
-}
+  }
-
-bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-  bool status;
 
+  bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
     hsd.Instance = SDIO;
-
     uint8_t retryCnt = SD_RETRY_COUNT;
 
+    bool status;
     for (;;) {
       status = (bool) HAL_SD_WriteBlocks(&hsd, (uint8_t*)src, block, 1, 500);  // write one 512 byte block with 500mS timeout
       status |= (bool) HAL_SD_GetCardState(&hsd);     // make sure all is OK
-    if (!status) return (bool) status;              // return passing status
+      if (!status) break;       // return passing status
-    if (!--retryCnt) return (bool) status;          // return failing status if retries are exhausted
+      if (!--retryCnt) break;   // return failing status if retries are exhausted
+    }
+    return status;
   }
-}
 
+#endif // !USBD_USE_CDC_COMPOSITE
 #endif // SDIO_SUPPORT

Marlin/src/pins/stm32f4/pins_STEVAL_3DP001V1.h

@@ -247,6 +247,7 @@
 
   #ifndef SDIO_SUPPORT
     #define SOFTWARE_SPI                          // Use soft SPI for onboard SD
+    #undef SDSS
     #define SDSS                     SDIO_D3_PIN
     #define SCK_PIN                  SDIO_CK_PIN
     #define MISO_PIN                 SDIO_D0_PIN

platformio.ini

@@ -646,7 +646,7 @@ platform_packages = framework-arduinoststm32@>=3.10700,<4
 build_flags       = ${common.build_flags}
  -DTARGET_STM32F4 -DARDUINO_STEVAL -DSTM32F401xE
  -DUSBCON -DUSBD_USE_CDC -DUSBD_VID=0x0483 -DUSB_PRODUCT=\"STEVAL_F401VE\"
- -DDISABLE_GENERIC_SERIALUSB
+ -DDISABLE_GENERIC_SERIALUSB -DUSBD_USE_CDC_COMPOSITE -DUSE_USB_FS
  -IMarlin/src/HAL/STM32
 build_unflags     = -std=gnu++11
 extra_scripts     = pre:buildroot/share/PlatformIO/scripts/generic_create_variant.py
@@ -704,6 +704,7 @@ platform_packages = framework-arduinoststm32@>=3.10700,<4
 build_flags       = ${common.build_flags}
  -DTARGET_STM32F4 -DARDUINO_BLACK_F407VE
  -DUSBCON -DUSBD_USE_CDC -DUSBD_VID=0x0483 -DUSB_PRODUCT=\"BLACK_F407VE\"
+ -DUSBD_USE_CDC_COMPOSITE -DUSE_USB_FS
  -IMarlin/src/HAL/STM32
 build_unflags     = -std=gnu++11
 extra_scripts     = pre:buildroot/share/PlatformIO/scripts/generic_create_variant.py