Bob Kuhn
5 years ago
committed by
GitHub
GitHub
21 changed files with 486 additions and 461 deletions
@ -0,0 +1,274 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(SDIO_SUPPORT) && !defined(STM32GENERIC) |
|||
|
|||
#include <stdint.h> |
|||
#include <stdbool.h> |
|||
|
|||
//#include "SdMscDriver.h"
|
|||
|
|||
//#include "usbd_msc_bot.h"
|
|||
//#include "usbd_msc_scsi.h"
|
|||
//#include "usbd_msc_composite.h"
|
|||
//#include "usbd_msc_cdc_composite.h"
|
|||
|
|||
//#include "usbd_msc_data.h"
|
|||
|
|||
#if defined(STM32F103xE) || defined(STM32F103xG) |
|||
#include <stm32f1xx_hal_rcc_ex.h> |
|||
#include <stm32f1xx_hal_sd.h> |
|||
#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) |
|||
#include <stm32f7xx_hal_rcc.h> |
|||
#include <stm32f7xx_hal_dma.h> |
|||
#include <stm32f7xx_hal_gpio.h> |
|||
#include <stm32f7xx_hal_sd.h> |
|||
#else |
|||
#error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported" |
|||
#endif |
|||
|
|||
SD_HandleTypeDef hsd; // create SDIO structure
|
|||
|
|||
#define TRANSFER_CLOCK_DIV ((uint8_t)SDIO_INIT_CLK_DIV/40) |
|||
|
|||
#ifndef USBD_OK |
|||
#define USBD_OK 0 |
|||
#endif |
|||
|
|||
void go_to_transfer_speed() { |
|||
|
|||
SD_InitTypeDef Init; |
|||
|
|||
/* Default SDIO peripheral configuration for SD card initialization */ |
|||
Init.ClockEdge = hsd.Init.ClockEdge; |
|||
Init.ClockBypass = hsd.Init.ClockBypass; |
|||
Init.ClockPowerSave = hsd.Init.ClockPowerSave; |
|||
Init.BusWide = hsd.Init.BusWide; |
|||
Init.HardwareFlowControl = hsd.Init.HardwareFlowControl; |
|||
Init.ClockDiv = TRANSFER_CLOCK_DIV; |
|||
|
|||
/* Initialize SDIO peripheral interface with default configuration */ |
|||
SDIO_Init(hsd.Instance, Init); |
|||
} |
|||
|
|||
void SD_LowLevel_Init(void) { |
|||
|
|||
uint32_t tempreg; |
|||
|
|||
GPIO_InitTypeDef GPIO_InitStruct; |
|||
|
|||
__HAL_RCC_GPIOC_CLK_ENABLE(); //enable GPIO clocks
|
|||
__HAL_RCC_GPIOD_CLK_ENABLE(); //enable GPIO clocks
|
|||
|
|||
GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_12; // D0 & SCK
|
|||
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; |
|||
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); |
|||
|
|||
#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
|
|||
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.Speed = GPIO_SPEED_FREQ_HIGH; |
|||
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; |
|||
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); |
|||
#endif |
|||
|
|||
// Configure PD.02 CMD line
|
|||
GPIO_InitStruct.Pin = GPIO_PIN_2; |
|||
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); |
|||
|
|||
RCC->APB2RSTR &= ~RCC_APB2RSTR_SDIORST_Msk; // take SDIO out of reset
|
|||
RCC->APB2ENR |= RCC_APB2RSTR_SDIORST_Msk; // enable SDIO clock
|
|||
|
|||
// Enable the DMA2 Clock
|
|||
|
|||
//Initialize the SDIO (with initial <400Khz Clock)
|
|||
tempreg = 0; //Reset value
|
|||
tempreg |= SDIO_CLKCR_CLKEN; //Clock is enabled
|
|||
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
|
|||
SDIO->CLKCR = tempreg; |
|||
|
|||
//Power up the SDIO
|
|||
SDIO->POWER = 0x03; |
|||
} |
|||
|
|||
|
|||
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 |
|||
#if ENABLED(SD_CHECK_AND_RETRY) |
|||
+ 2 |
|||
#endif |
|||
); |
|||
|
|||
bool SDIO_Init() { |
|||
//init SDIO and get SD card info
|
|||
|
|||
uint8_t retryCnt = SD_RETRY_COUNT; |
|||
|
|||
bool status; |
|||
hsd.Instance = SDIO; |
|||
hsd.State = (HAL_SD_StateTypeDef) 0; // HAL_SD_STATE_RESET
|
|||
SD_LowLevel_Init(); |
|||
|
|||
uint8_t retry_Cnt = retryCnt; |
|||
for (;;) { |
|||
status = (bool) HAL_SD_Init(&hsd); |
|||
if (!status) break; |
|||
if (!--retry_Cnt) return false; // return failing status if retries are exhausted
|
|||
} |
|||
|
|||
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
|
|||
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
|
|||
if (!--retry_Cnt) break; |
|||
} |
|||
if (!retry_Cnt) { // wide bus failed, go back to one bit wide mode
|
|||
hsd.State = (HAL_SD_StateTypeDef) 0; // HAL_SD_STATE_RESET
|
|||
SD_LowLevel_Init(); |
|||
retry_Cnt = retryCnt; |
|||
for (;;) { |
|||
status = (bool) HAL_SD_Init(&hsd); |
|||
if (!status) break; |
|||
if (!--retry_Cnt) return false; // return failing status if retries are exhausted
|
|||
} |
|||
} |
|||
#endif |
|||
|
|||
return true; |
|||
} |
|||
|
|||
void init_SDIO_pins(void) { |
|||
GPIO_InitTypeDef GPIO_InitStruct = {0}; |
|||
|
|||
/**SDIO GPIO Configuration
|
|||
PC8 ------> SDIO_D0 |
|||
PC12 ------> SDIO_CK |
|||
PD2 ------> SDIO_CMD |
|||
*/ |
|||
GPIO_InitStruct.Pin = GPIO_PIN_8; |
|||
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; |
|||
GPIO_InitStruct.Pull = GPIO_NOPULL; |
|||
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; |
|||
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; |
|||
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); |
|||
|
|||
GPIO_InitStruct.Pin = GPIO_PIN_12; |
|||
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; |
|||
GPIO_InitStruct.Pull = GPIO_NOPULL; |
|||
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; |
|||
GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; |
|||
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); |
|||
|
|||
GPIO_InitStruct.Pin = GPIO_PIN_2; |
|||
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; |
|||
GPIO_InitStruct.Pull = GPIO_NOPULL; |
|||
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 status; |
|||
|
|||
hsd.Instance = SDIO; |
|||
|
|||
uint8_t retryCnt = SD_RETRY_COUNT; |
|||
|
|||
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_GetCardState(&hsd); // make sure all is OK
|
|||
if (!status) return false; // return passing status
|
|||
if (!--retryCnt) return true; // return failing status if retries are exhausted
|
|||
} |
|||
|
|||
/*
|
|||
return (bool) ((status_read | status_card) ? 1 : 0); |
|||
|
|||
if (SDIO_GetCardState() != SDIO_CARD_TRANSFER) return false; |
|||
if (blockAddress >= SdCard.LogBlockNbr) return false; |
|||
if ((0x03 & (uint32_t)data)) return false; // misaligned data
|
|||
|
|||
if (SdCard.CardType != CARD_SDHC_SDXC) { blockAddress *= 512U; } |
|||
|
|||
if (!SDIO_CmdReadSingleBlock(blockAddress)) { |
|||
SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS); |
|||
dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL); |
|||
return false; |
|||
} |
|||
|
|||
while (!SDIO_GET_FLAG(SDIO_STA_DATAEND | SDIO_STA_TRX_ERROR_FLAGS)) {} |
|||
|
|||
dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL); |
|||
|
|||
if (SDIO->STA & SDIO_STA_RXDAVL) { |
|||
while (SDIO->STA & SDIO_STA_RXDAVL) (void)SDIO->FIFO; |
|||
SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS); |
|||
return false; |
|||
} |
|||
|
|||
if (SDIO_GET_FLAG(SDIO_STA_TRX_ERROR_FLAGS)) { |
|||
SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS); |
|||
return false; |
|||
} |
|||
SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS); |
|||
*/ |
|||
|
|||
return true; |
|||
} |
|||
|
|||
bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) { |
|||
bool status; |
|||
|
|||
hsd.Instance = SDIO; |
|||
|
|||
uint8_t retryCnt = SD_RETRY_COUNT; |
|||
|
|||
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 (!--retryCnt) return (bool) status; // return failing status if retries are exhausted
|
|||
} |
|||
} |
|||
|
|||
#endif // SDIO_SUPPORT
|
|||
Loading…
Reference in new issue