zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Bob Kuhn 2020-04-22 15:00:10 -05:00 committed by GitHub
parent 8a9c14ea1d
commit 33bb7859d4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 214 additions and 197 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
Marlin/src/HAL/STM32/Sd2Card_sdio_stm32duino.cpp
View file

@ -27,42 +27,64 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
//#include "SdMscDriver.h" #if NONE(STM32F103xE, STM32F103xG, STM32F4xx, STM32F7xx)
#error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported"
#endif
//#include "usbd_msc_bot.h" #ifdef 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 USB drivers
#if defined(STM32F103xE) || defined(STM32F103xG) 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;
}
#else // !USBD_USE_CDC_COMPOSITE
// use local drivers
#if defined(STM32F103xE) || defined(STM32F103xG)
#include <stm32f1xx_hal_rcc_ex.h> #include <stm32f1xx_hal_rcc_ex.h>
#include <stm32f1xx_hal_sd.h> #include <stm32f1xx_hal_sd.h>
#elif defined(STM32F4xx) #elif defined(STM32F4xx)
#include <stm32f4xx_hal_rcc.h> #include <stm32f4xx_hal_rcc.h>
#include <stm32f4xx_hal_dma.h> #include <stm32f4xx_hal_dma.h>
#include <stm32f4xx_hal_gpio.h> #include <stm32f4xx_hal_gpio.h>
#include <stm32f4xx_hal_sd.h> #include <stm32f4xx_hal_sd.h>
#elif defined(STM32F7xx) #elif defined(STM32F7xx)
#include <stm32f7xx_hal_rcc.h> #include <stm32f7xx_hal_rcc.h>
#include <stm32f7xx_hal_dma.h> #include <stm32f7xx_hal_dma.h>
#include <stm32f7xx_hal_gpio.h> #include <stm32f7xx_hal_gpio.h>
#include <stm32f7xx_hal_sd.h> #include <stm32f7xx_hal_sd.h>
#else #else
#error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported" #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 #define USBD_OK 0
#endif #endif
void go_to_transfer_speed() {
void go_to_transfer_speed() {
SD_InitTypeDef Init; SD_InitTypeDef Init;
/* Default SDIO peripheral configuration for SD card initialization */ /* Default SDIO peripheral configuration for SD card initialization */
@ -75,10 +97,9 @@ void go_to_transfer_speed() {
/* Initialize SDIO peripheral interface with default configuration */ /* Initialize SDIO peripheral interface with default configuration */
SDIO_Init(hsd.Instance, Init); SDIO_Init(hsd.Instance, Init);
} }
void SD_LowLevel_Init(void) {
void SD_LowLevel_Init(void) {
uint32_t tempreg; uint32_t tempreg;
GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitTypeDef GPIO_InitStruct;
@ -93,10 +114,10 @@ void SD_LowLevel_Init(void) {
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); 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.Pin = GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11; // D1-D3
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; 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.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
@ -113,28 +134,23 @@ void SD_LowLevel_Init(void) {
//Initialize the SDIO (with initial <400Khz Clock) //Initialize the SDIO (with initial <400Khz Clock)
tempreg = 0; //Reset value 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; SDIO->CLKCR = tempreg;
//Power up the SDIO // Power up the SDIO
SDIO->POWER = 0x03; 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 */ UNUSED(hsd); /* Prevent unused argument(s) compilation warning */
__HAL_RCC_SDIO_CLK_ENABLE(); // turn on SDIO clock __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 //init SDIO and get SD card info
uint8_t retryCnt = SD_RETRY_COUNT; uint8_t retryCnt = SD_RETRY_COUNT;
@ -153,7 +169,7 @@ bool SDIO_Init() {
go_to_transfer_speed(); 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; retry_Cnt = retryCnt;
for (;;) { 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 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 #endif
return true; return true;
} }
void init_SDIO_pins(void) { void init_SDIO_pins(void) {
GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitTypeDef GPIO_InitStruct = {0};
/**SDIO GPIO Configuration /**SDIO GPIO Configuration
@ -202,24 +218,23 @@ void init_SDIO_pins(void) {
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
} }
//bool SDIO_init() { return (bool) (SD_SDIO_Init() ? 1 : 0);} //bool SDIO_init() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
//bool SDIO_Init_C() { 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 status;
bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
hsd.Instance = SDIO; hsd.Instance = SDIO;
uint8_t retryCnt = SD_RETRY_COUNT; uint8_t retryCnt = SD_RETRY_COUNT;
bool status;
for (;;) { 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 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); return (bool) ((status_read | status_card) ? 1 : 0);
@ -254,21 +269,21 @@ bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
*/ */
return true; 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; hsd.Instance = SDIO;
uint8_t retryCnt = SD_RETRY_COUNT; uint8_t retryCnt = SD_RETRY_COUNT;
bool status;
for (;;) { 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_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 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 #endif // SDIO_SUPPORT

1
Marlin/src/pins/stm32f4/pins_STEVAL_3DP001V1.h
View file

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

3
platformio.ini
View file

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