andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

🎨 Format onboard_sd.cpp

vanilla_fb_2.0.x
Scott Lahteine 3 years ago
parent
3e5d867276
commit
003ce25acf
1 changed files with 183 additions and 176 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 359
      Marlin/src/HAL/STM32F1/onboard_sd.cpp

359
Marlin/src/HAL/STM32F1/onboard_sd.cpp
View File

@ -38,8 +38,8 @@
#define SPI_CLOCK_MAX SPI_BAUD_PCLK_DIV_2 #define SPI_CLOCK_MAX SPI_BAUD_PCLK_DIV_2
#endif #endif
#define CS_LOW() WRITE(ONBOARD_SD_CS_PIN, LOW) /* Set OnboardSPI cs low */ #define CS_LOW() WRITE(ONBOARD_SD_CS_PIN, LOW) // Set OnboardSPI cs low
#define CS_HIGH() WRITE(ONBOARD_SD_CS_PIN, HIGH) /* Set OnboardSPI cs high */ #define CS_HIGH() WRITE(ONBOARD_SD_CS_PIN, HIGH) // Set OnboardSPI cs high
#define FCLK_FAST() ONBOARD_SD_SPI.setClockDivider(SPI_CLOCK_MAX) #define FCLK_FAST() ONBOARD_SD_SPI.setClockDivider(SPI_CLOCK_MAX)
#define FCLK_SLOW() ONBOARD_SD_SPI.setClockDivider(SPI_BAUD_PCLK_DIV_256) #define FCLK_SLOW() ONBOARD_SD_SPI.setClockDivider(SPI_BAUD_PCLK_DIV_256)
@ -49,32 +49,32 @@
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
/* MMC/SD command */ /* MMC/SD command */
#define CMD0 (0) /* GO_IDLE_STATE */ #define CMD0 (0) // GO_IDLE_STATE
#define CMD1 (1) /* SEND_OP_COND (MMC) */ #define CMD1 (1) // SEND_OP_COND (MMC)
#define ACMD41 (0x80+41) /* SEND_OP_COND (SDC) */ #define ACMD41 (0x80+41) // SEND_OP_COND (SDC)
#define CMD8 (8) /* SEND_IF_COND */ #define CMD8 (8) // SEND_IF_COND
#define CMD9 (9) /* SEND_CSD */ #define CMD9 (9) // SEND_CSD
#define CMD10 (10) /* SEND_CID */ #define CMD10 (10) // SEND_CID
#define CMD12 (12) /* STOP_TRANSMISSION */ #define CMD12 (12) // STOP_TRANSMISSION
#define ACMD13 (0x80+13) /* SD_STATUS (SDC) */ #define ACMD13 (0x80+13) // SD_STATUS (SDC)
#define CMD16 (16) /* SET_BLOCKLEN */ #define CMD16 (16) // SET_BLOCKLEN
#define CMD17 (17) /* READ_SINGLE_BLOCK */ #define CMD17 (17) // READ_SINGLE_BLOCK
#define CMD18 (18) /* READ_MULTIPLE_BLOCK */ #define CMD18 (18) // READ_MULTIPLE_BLOCK
#define CMD23 (23) /* SET_BLOCK_COUNT (MMC) */ #define CMD23 (23) // SET_BLOCK_COUNT (MMC)
#define ACMD23 (0x80+23) /* SET_WR_BLK_ERASE_COUNT (SDC) */ #define ACMD23 (0x80+23) // SET_WR_BLK_ERASE_COUNT (SDC)
#define CMD24 (24) /* WRITE_BLOCK */ #define CMD24 (24) // WRITE_BLOCK
#define CMD25 (25) /* WRITE_MULTIPLE_BLOCK */ #define CMD25 (25) // WRITE_MULTIPLE_BLOCK
#define CMD32 (32) /* ERASE_ER_BLK_START */ #define CMD32 (32) // ERASE_ER_BLK_START
#define CMD33 (33) /* ERASE_ER_BLK_END */ #define CMD33 (33) // ERASE_ER_BLK_END
#define CMD38 (38) /* ERASE */ #define CMD38 (38) // ERASE
#define CMD48 (48) /* READ_EXTR_SINGLE */ #define CMD48 (48) // READ_EXTR_SINGLE
#define CMD49 (49) /* WRITE_EXTR_SINGLE */ #define CMD49 (49) // WRITE_EXTR_SINGLE
#define CMD55 (55) /* APP_CMD */ #define CMD55 (55) // APP_CMD
#define CMD58 (58) /* READ_OCR */ #define CMD58 (58) // READ_OCR
static volatile DSTATUS Stat = STA_NOINIT; /* Physical drive status */ static volatile DSTATUS Stat = STA_NOINIT; // Physical drive status
static volatile UINT timeout; static volatile UINT timeout;
static BYTE CardType; /* Card type flags */ static BYTE CardType; // Card type flags
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
/* Send/Receive data to the MMC (Platform dependent) */ /* Send/Receive data to the MMC (Platform dependent) */
@ -82,7 +82,7 @@ static BYTE CardType; /* Card type flags */
/* Exchange a byte */ /* Exchange a byte */
static BYTE xchg_spi ( static BYTE xchg_spi (
BYTE dat /* Data to send */ BYTE dat // Data to send
) { ) {
BYTE returnByte = ONBOARD_SD_SPI.transfer(dat); BYTE returnByte = ONBOARD_SD_SPI.transfer(dat);
return returnByte; return returnByte;
@ -90,18 +90,18 @@ static BYTE xchg_spi (
/* Receive multiple byte */ /* Receive multiple byte */
static void rcvr_spi_multi ( static void rcvr_spi_multi (
BYTE *buff, /* Pointer to data buffer */ BYTE *buff, // Pointer to data buffer
UINT btr /* Number of bytes to receive (16, 64 or 512) */ UINT btr // Number of bytes to receive (16, 64 or 512)
) { ) {
ONBOARD_SD_SPI.dmaTransfer(0, const_cast<uint8_t*>(buff), btr); ONBOARD_SD_SPI.dmaTransfer(0, const_cast<uint8_t*>(buff), btr);
} }
#if _DISKIO_WRITE #if _DISKIO_WRITE
/* Send multiple bytes */ // Send multiple bytes
static void xmit_spi_multi ( static void xmit_spi_multi (
const BYTE *buff, /* Pointer to the data */ const BYTE *buff, // Pointer to the data
UINT btx /* Number of bytes to send (multiple of 16) */ UINT btx // Number of bytes to send (multiple of 16)
) { ) {
ONBOARD_SD_SPI.dmaSend(const_cast<uint8_t*>(buff), btx); ONBOARD_SD_SPI.dmaSend(const_cast<uint8_t*>(buff), btx);
} }
@ -112,16 +112,15 @@ static void rcvr_spi_multi (
/* Wait for card ready */ /* Wait for card ready */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static int wait_ready ( /* 1:Ready, 0:Timeout */ static int wait_ready ( // 1:Ready, 0:Timeout
UINT wt /* Timeout [ms] */ UINT wt // Timeout [ms]
) { ) {
BYTE d; BYTE d;
timeout = millis() + wt; timeout = millis() + wt;
do { do {
d = xchg_spi(0xFF); d = xchg_spi(0xFF);
/* This loop takes a while. Insert rot_rdq() here for multitask environment. */ // This loop takes a while. Insert rot_rdq() here for multitask environment.
} while (d != 0xFF && (timeout > millis())); /* Wait for card goes ready or timeout */ } while (d != 0xFF && (timeout > millis())); // Wait for card goes ready or timeout
return (d == 0xFF) ? 1 : 0; return (d == 0xFF) ? 1 : 0;
} }
@ -131,21 +130,21 @@ static int wait_ready ( /* 1:Ready, 0:Timeout */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static void deselect() { static void deselect() {
CS_HIGH(); /* CS = H */ CS_HIGH(); // CS = H
xchg_spi(0xFF); /* Dummy clock (force DO hi-z for multiple slave SPI) */ xchg_spi(0xFF); // Dummy clock (force DO hi-z for multiple slave SPI)
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
/* Select card and wait for ready */ /* Select card and wait for ready */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static int select() { /* 1:OK, 0:Timeout */ static int select() { // 1:OK, 0:Timeout
CS_LOW(); /* CS = L */ CS_LOW(); // CS = L
xchg_spi(0xFF); /* Dummy clock (force DO enabled) */ xchg_spi(0xFF); // Dummy clock (force DO enabled)
if (wait_ready(500)) return 1; /* Leading busy check: Wait for card ready */ if (wait_ready(500)) return 1; // Leading busy check: Wait for card ready
deselect(); /* Timeout */ deselect(); // Timeout
return 0; return 0;
} }
@ -153,16 +152,18 @@ static int select() { /* 1:OK, 0:Timeout */
/* Control SPI module (Platform dependent) */ /* Control SPI module (Platform dependent) */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static void power_on() { /* Enable SSP module and attach it to I/O pads */ // Enable SSP module and attach it to I/O pads
static void sd_power_on() {
ONBOARD_SD_SPI.setModule(ONBOARD_SPI_DEVICE); ONBOARD_SD_SPI.setModule(ONBOARD_SPI_DEVICE);
ONBOARD_SD_SPI.begin(); ONBOARD_SD_SPI.begin();
ONBOARD_SD_SPI.setBitOrder(MSBFIRST); ONBOARD_SD_SPI.setBitOrder(MSBFIRST);
ONBOARD_SD_SPI.setDataMode(SPI_MODE0); ONBOARD_SD_SPI.setDataMode(SPI_MODE0);
OUT_WRITE(ONBOARD_SD_CS_PIN, HIGH); /* Set CS# high */ OUT_WRITE(ONBOARD_SD_CS_PIN, HIGH); // Set CS# high
} }
static void power_off() { /* Disable SPI function */ // Disable SPI function
select(); /* Wait for card ready */ static void sd_power_off() {
select(); // Wait for card ready
deselect(); deselect();
} }
@ -170,23 +171,23 @@ static void power_off() { /* Disable SPI function */
/* Receive a data packet from the MMC */ /* Receive a data packet from the MMC */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static int rcvr_datablock ( /* 1:OK, 0:Error */ static int rcvr_datablock ( // 1:OK, 0:Error
BYTE *buff, /* Data buffer */ BYTE *buff, // Data buffer
UINT btr /* Data block length (byte) */ UINT btr // Data block length (byte)
) { ) {
BYTE token; BYTE token;
timeout = millis() + 200; timeout = millis() + 200;
do { /* Wait for DataStart token in timeout of 200ms */ do { // Wait for DataStart token in timeout of 200ms
token = xchg_spi(0xFF); token = xchg_spi(0xFF);
/* This loop will take a while. Insert rot_rdq() here for multitask environment. */ // This loop will take a while. Insert rot_rdq() here for multitask environment.
} while ((token == 0xFF) && (timeout > millis())); } while ((token == 0xFF) && (timeout > millis()));
if (token != 0xFE) return 0; /* Function fails if invalid DataStart token or timeout */ if (token != 0xFE) return 0; // Function fails if invalid DataStart token or timeout
rcvr_spi_multi(buff, btr); /* Store trailing data to the buffer */ rcvr_spi_multi(buff, btr); // Store trailing data to the buffer
xchg_spi(0xFF); xchg_spi(0xFF); /* Discard CRC */ xchg_spi(0xFF); xchg_spi(0xFF); // Discard CRC
return 1; /* Function succeeded */ return 1; // Function succeeded
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
@ -195,25 +196,25 @@ static int rcvr_datablock ( /* 1:OK, 0:Error */
#if _DISKIO_WRITE #if _DISKIO_WRITE
static int xmit_datablock ( /* 1:OK, 0:Failed */ static int xmit_datablock( // 1:OK, 0:Failed
const BYTE *buff, /* Ponter to 512 byte data to be sent */ const BYTE *buff, // Pointer to 512 byte data to be sent
BYTE token /* Token */ BYTE token // Token
) { ) {
BYTE resp; BYTE resp;
if (!wait_ready(500)) return 0; /* Leading busy check: Wait for card ready to accept data block */ if (!wait_ready(500)) return 0; // Leading busy check: Wait for card ready to accept data block
xchg_spi(token); /* Send token */ xchg_spi(token); // Send token
if (token == 0xFD) return 1; /* Do not send data if token is StopTran */ if (token == 0xFD) return 1; // Do not send data if token is StopTran
xmit_spi_multi(buff, 512); /* Data */ xmit_spi_multi(buff, 512); // Data
xchg_spi(0xFF); xchg_spi(0xFF); /* Dummy CRC */ xchg_spi(0xFF); xchg_spi(0xFF); // Dummy CRC
resp = xchg_spi(0xFF); /* Receive data resp */ resp = xchg_spi(0xFF); // Receive data resp
return (resp & 0x1F) == 0x05 ? 1 : 0; /* Data was accepted or not */ return (resp & 0x1F) == 0x05 ? 1 : 0; // Data was accepted or not
/* Busy check is done at next transmission */ // Busy check is done at next transmission
} }
#endif // _DISKIO_WRITE #endif // _DISKIO_WRITE
@ -222,43 +223,43 @@ static int rcvr_datablock ( /* 1:OK, 0:Error */
/* Send a command packet to the MMC */ /* Send a command packet to the MMC */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static BYTE send_cmd ( /* Return value: R1 resp (bit7==1:Failed to send) */ static BYTE send_cmd( // Return value: R1 resp (bit7==1:Failed to send)
BYTE cmd, /* Command index */ BYTE cmd, // Command index
DWORD arg /* Argument */ DWORD arg // Argument
) { ) {
BYTE n, res; BYTE n, res;
if (cmd & 0x80) { /* Send a CMD55 prior to ACMD<n> */ if (cmd & 0x80) { // Send a CMD55 prior to ACMD<n>
cmd &= 0x7F; cmd &= 0x7F;
res = send_cmd(CMD55, 0); res = send_cmd(CMD55, 0);
if (res > 1) return res; if (res > 1) return res;
} }
/* Select the card and wait for ready except to stop multiple block read */ // Select the card and wait for ready except to stop multiple block read
if (cmd != CMD12) { if (cmd != CMD12) {
deselect(); deselect();
if (!select()) return 0xFF; if (!select()) return 0xFF;
} }
/* Send command packet */ // Send command packet
xchg_spi(0x40 | cmd); /* Start + command index */ xchg_spi(0x40 | cmd); // Start + command index
xchg_spi((BYTE)(arg >> 24)); /* Argument[31..24] */ xchg_spi((BYTE)(arg >> 24)); // Argument[31..24]
xchg_spi((BYTE)(arg >> 16)); /* Argument[23..16] */ xchg_spi((BYTE)(arg >> 16)); // Argument[23..16]
xchg_spi((BYTE)(arg >> 8)); /* Argument[15..8] */ xchg_spi((BYTE)(arg >> 8)); // Argument[15..8]
xchg_spi((BYTE)arg); /* Argument[7..0] */ xchg_spi((BYTE)arg); // Argument[7..0]
n = 0x01; /* Dummy CRC + Stop */ n = 0x01; // Dummy CRC + Stop
if (cmd == CMD0) n = 0x95; /* Valid CRC for CMD0(0) */ if (cmd == CMD0) n = 0x95; // Valid CRC for CMD0(0)
if (cmd == CMD8) n = 0x87; /* Valid CRC for CMD8(0x1AA) */ if (cmd == CMD8) n = 0x87; // Valid CRC for CMD8(0x1AA)
xchg_spi(n); xchg_spi(n);
/* Receive command resp */ // Receive command response
if (cmd == CMD12) xchg_spi(0xFF); /* Diacard following one byte when CMD12 */ if (cmd == CMD12) xchg_spi(0xFF); // Discard the following byte when CMD12
n = 10; /* Wait for response (10 bytes max) */ n = 10; // Wait for response (10 bytes max)
do do
res = xchg_spi(0xFF); res = xchg_spi(0xFF);
while ((res & 0x80) && --n); while ((res & 0x80) && --n);
return res; /* Return received response */ return res; // Return received response
} }
/*-------------------------------------------------------------------------- /*--------------------------------------------------------------------------
@ -270,49 +271,52 @@ static BYTE send_cmd ( /* Return value: R1 resp (bit7==1:Failed to send) */
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
DSTATUS disk_initialize ( DSTATUS disk_initialize (
BYTE drv /* Physical drive number (0) */ BYTE drv // Physical drive number (0)
) { ) {
BYTE n, cmd, ty, ocr[4]; BYTE n, cmd, ty, ocr[4];
if (drv) return STA_NOINIT; /* Supports only drive 0 */ if (drv) return STA_NOINIT; // Supports only drive 0
power_on(); /* Initialize SPI */ sd_power_on(); // Initialize SPI
if (Stat & STA_NODISK) return Stat; /* Is a card existing in the soket? */ if (Stat & STA_NODISK) return Stat; // Is a card existing in the soket?
FCLK_SLOW(); FCLK_SLOW();
for (n = 10; n; n--) xchg_spi(0xFF); /* Send 80 dummy clocks */ for (n = 10; n; n--) xchg_spi(0xFF); // Send 80 dummy clocks
ty = 0; ty = 0;
if (send_cmd(CMD0, 0) == 1) { /* Put the card SPI state */ if (send_cmd(CMD0, 0) == 1) { // Put the card SPI state
timeout = millis() + 1000; /* Initialization timeout = 1 sec */ timeout = millis() + 1000; // Initialization timeout = 1 sec
if (send_cmd(CMD8, 0x1AA) == 1) { /* Is the catd SDv2? */ if (send_cmd(CMD8, 0x1AA) == 1) { // Is the catd SDv2?
for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF); /* Get 32 bit return value of R7 resp */ for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF); // Get 32 bit return value of R7 resp
if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* Does the card support 2.7-3.6V? */ if (ocr[2] == 0x01 && ocr[3] == 0xAA) { // Does the card support 2.7-3.6V?
while ((timeout > millis()) && send_cmd(ACMD41, 1UL << 30)) ; /* Wait for end of initialization with ACMD41(HCS) */ while ((timeout > millis()) && send_cmd(ACMD41, 1UL << 30)); // Wait for end of initialization with ACMD41(HCS)
if ((timeout > millis()) && send_cmd(CMD58, 0) == 0) { /* Check CCS bit in the OCR */ if ((timeout > millis()) && send_cmd(CMD58, 0) == 0) { // Check CCS bit in the OCR
for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF); for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);
ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2; /* Check if the card is SDv2 */ ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2; // Check if the card is SDv2
} }
} }
} else { /* Not an SDv2 card */ }
if (send_cmd(ACMD41, 0) <= 1) { /* SDv1 or MMCv3? */ else { // Not an SDv2 card
ty = CT_SD1; cmd = ACMD41; /* SDv1 (ACMD41(0)) */ if (send_cmd(ACMD41, 0) <= 1) { // SDv1 or MMCv3?
} else { ty = CT_SD1; cmd = ACMD41; // SDv1 (ACMD41(0))
ty = CT_MMC; cmd = CMD1; /* MMCv3 (CMD1(0)) */ }
else {
ty = CT_MMC; cmd = CMD1; // MMCv3 (CMD1(0))
} }
while ((timeout > millis()) && send_cmd(cmd, 0)) ; /* Wait for the card leaves idle state */ while ((timeout > millis()) && send_cmd(cmd, 0)); // Wait for the card leaves idle state
if (!(timeout > millis()) || send_cmd(CMD16, 512) != 0) /* Set block length: 512 */ if (!(timeout > millis()) || send_cmd(CMD16, 512) != 0) // Set block length: 512
ty = 0; ty = 0;
} }
} }
CardType = ty; /* Card type */ CardType = ty; // Card type
deselect(); deselect();
if (ty) { /* OK */ if (ty) { // OK
FCLK_FAST(); /* Set fast clock */ FCLK_FAST(); // Set fast clock
Stat &= ~STA_NOINIT; /* Clear STA_NOINIT flag */ Stat &= ~STA_NOINIT; // Clear STA_NOINIT flag
} else { /* Failed */ }
power_off(); else { // Failed
sd_power_off();
Stat = STA_NOINIT; Stat = STA_NOINIT;
} }
@ -324,10 +328,10 @@ DSTATUS disk_initialize (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
DSTATUS disk_status ( DSTATUS disk_status (
BYTE drv /* Physical drive number (0) */ BYTE drv // Physical drive number (0)
) { ) {
if (drv) return STA_NOINIT; /* Supports only drive 0 */ if (drv) return STA_NOINIT; // Supports only drive 0
return Stat; /* Return disk status */ return Stat; // Return disk status
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
@ -335,28 +339,28 @@ DSTATUS disk_status (
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
DRESULT disk_read ( DRESULT disk_read (
BYTE drv, /* Physical drive number (0) */ BYTE drv, // Physical drive number (0)
BYTE *buff, /* Pointer to the data buffer to store read data */ BYTE *buff, // Pointer to the data buffer to store read data
DWORD sector, /* Start sector number (LBA) */ DWORD sector, // Start sector number (LBA)
UINT count /* Number of sectors to read (1..128) */ UINT count // Number of sectors to read (1..128)
) { ) {
BYTE cmd; BYTE cmd;
if (drv || !count) return RES_PARERR; /* Check parameter */ if (drv || !count) return RES_PARERR; // Check parameter
if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check if drive is ready */ if (Stat & STA_NOINIT) return RES_NOTRDY; // Check if drive is ready
if (!(CardType & CT_BLOCK)) sector *= 512; /* LBA ot BA conversion (byte addressing cards) */ if (!(CardType & CT_BLOCK)) sector *= 512; // LBA ot BA conversion (byte addressing cards)
FCLK_FAST(); FCLK_FAST();
cmd = count > 1 ? CMD18 : CMD17; /* READ_MULTIPLE_BLOCK : READ_SINGLE_BLOCK */ cmd = count > 1 ? CMD18 : CMD17; // READ_MULTIPLE_BLOCK : READ_SINGLE_BLOCK
if (send_cmd(cmd, sector) == 0) { if (send_cmd(cmd, sector) == 0) {
do { do {
if (!rcvr_datablock(buff, 512)) break; if (!rcvr_datablock(buff, 512)) break;
buff += 512; buff += 512;
} while (--count); } while (--count);
if (cmd == CMD18) send_cmd(CMD12, 0); /* STOP_TRANSMISSION */ if (cmd == CMD18) send_cmd(CMD12, 0); // STOP_TRANSMISSION
} }
deselect(); deselect();
return count ? RES_ERROR : RES_OK; /* Return result */ return count ? RES_ERROR : RES_OK; // Return result
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
@ -366,36 +370,36 @@ DRESULT disk_read (
#if _DISKIO_WRITE #if _DISKIO_WRITE
DRESULT disk_write( DRESULT disk_write(
BYTE drv, /* Physical drive number (0) */ BYTE drv, // Physical drive number (0)
const BYTE *buff, /* Ponter to the data to write */ const BYTE *buff, // Pointer to the data to write
DWORD sector, /* Start sector number (LBA) */ DWORD sector, // Start sector number (LBA)
UINT count /* Number of sectors to write (1..128) */ UINT count // Number of sectors to write (1..128)
) { ) {
if (drv || !count) return RES_PARERR; /* Check parameter */ if (drv || !count) return RES_PARERR; // Check parameter
if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check drive status */ if (Stat & STA_NOINIT) return RES_NOTRDY; // Check drive status
if (Stat & STA_PROTECT) return RES_WRPRT; /* Check write protect */ if (Stat & STA_PROTECT) return RES_WRPRT; // Check write protect
FCLK_FAST(); FCLK_FAST();
if (!(CardType & CT_BLOCK)) sector *= 512; /* LBA ==> BA conversion (byte addressing cards) */ if (!(CardType & CT_BLOCK)) sector *= 512; // LBA ==> BA conversion (byte addressing cards)
if (count == 1) { /* Single sector write */ if (count == 1) { // Single sector write
if ((send_cmd(CMD24, sector) == 0) /* WRITE_BLOCK */ if ((send_cmd(CMD24, sector) == 0) // WRITE_BLOCK
&& xmit_datablock(buff, 0xFE)) { && xmit_datablock(buff, 0xFE)) {
count = 0; count = 0;
} }
} }
else { /* Multiple sector write */ else { // Multiple sector write
if (CardType & CT_SDC) send_cmd(ACMD23, count); /* Predefine number of sectors */ if (CardType & CT_SDC) send_cmd(ACMD23, count); // Predefine number of sectors
if (send_cmd(CMD25, sector) == 0) { /* WRITE_MULTIPLE_BLOCK */ if (send_cmd(CMD25, sector) == 0) { // WRITE_MULTIPLE_BLOCK
do { do {
if (!xmit_datablock(buff, 0xFC)) break; if (!xmit_datablock(buff, 0xFC)) break;
buff += 512; buff += 512;
} while (--count); } while (--count);
if (!xmit_datablock(0, 0xFD)) count = 1; /* STOP_TRAN token */ if (!xmit_datablock(0, 0xFD)) count = 1; // STOP_TRAN token
} }
} }
deselect(); deselect();
return count ? RES_ERROR : RES_OK; /* Return result */ return count ? RES_ERROR : RES_OK; // Return result
} }
#endif // _DISKIO_WRITE #endif // _DISKIO_WRITE
@ -407,9 +411,9 @@ DRESULT disk_read (
#if _DISKIO_IOCTL #if _DISKIO_IOCTL
DRESULT disk_ioctl ( DRESULT disk_ioctl (
BYTE drv, /* Physical drive number (0) */ BYTE drv, // Physical drive number (0)
BYTE cmd, /* Control command code */ BYTE cmd, // Control command code
void *buff /* Pointer to the conrtol data */ void *buff // Pointer to the conrtol data
) { ) {
DRESULT res; DRESULT res;
BYTE n, csd[16], *ptr = (BYTE *)buff; BYTE n, csd[16], *ptr = (BYTE *)buff;
@ -420,22 +424,23 @@ DRESULT disk_read (
UINT dc; UINT dc;
#endif #endif
if (drv) return RES_PARERR; /* Check parameter */ if (drv) return RES_PARERR; // Check parameter
if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check if drive is ready */ if (Stat & STA_NOINIT) return RES_NOTRDY; // Check if drive is ready
res = RES_ERROR; res = RES_ERROR;
FCLK_FAST(); FCLK_FAST();
switch (cmd) { switch (cmd) {
case CTRL_SYNC: /* Wait for end of internal write process of the drive */ case CTRL_SYNC: // Wait for end of internal write process of the drive
if (select()) res = RES_OK; if (select()) res = RES_OK;
break; break;
case GET_SECTOR_COUNT: /* Get drive capacity in unit of sector (DWORD) */ case GET_SECTOR_COUNT: // Get drive capacity in unit of sector (DWORD)
if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {
if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */ if ((csd[0] >> 6) == 1) { // SDC ver 2.00
csize = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1; csize = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1;
*(DWORD*)buff = csize << 10; *(DWORD*)buff = csize << 10;
} else { /* SDC ver 1.XX or MMC ver 3 */ }
else { // SDC ver 1.XX or MMC ver 3
n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2; n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1; csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
*(DWORD*)buff = csize << (n - 9); *(DWORD*)buff = csize << (n - 9);
@ -444,21 +449,23 @@ DRESULT disk_read (
} }
break; break;
case GET_BLOCK_SIZE: /* Get erase block size in unit of sector (DWORD) */ case GET_BLOCK_SIZE: // Get erase block size in unit of sector (DWORD)
if (CardType & CT_SD2) { /* SDC ver 2.00 */ if (CardType & CT_SD2) { // SDC ver 2.00
if (send_cmd(ACMD13, 0) == 0) { /* Read SD status */ if (send_cmd(ACMD13, 0) == 0) { // Read SD status
xchg_spi(0xFF); xchg_spi(0xFF);
if (rcvr_datablock(csd, 16)) { /* Read partial block */ if (rcvr_datablock(csd, 16)) { // Read partial block
for (n = 64 - 16; n; n--) xchg_spi(0xFF); /* Purge trailing data */ for (n = 64 - 16; n; n--) xchg_spi(0xFF); // Purge trailing data
*(DWORD*)buff = 16UL << (csd[10] >> 4); *(DWORD*)buff = 16UL << (csd[10] >> 4);
res = RES_OK; res = RES_OK;
} }
} }
} else { /* SDC ver 1.XX or MMC */ }
if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { /* Read CSD */ else { // SDC ver 1.XX or MMC
if (CardType & CT_SD1) { /* SDC ver 1.XX */ if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) { // Read CSD
if (CardType & CT_SD1) { // SDC ver 1.XX
*(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1); *(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
} else { /* MMC */ }
else { // MMC
*(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1); *(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
} }
res = RES_OK; res = RES_OK;
@ -466,47 +473,47 @@ DRESULT disk_read (
} }
break; break;
case CTRL_TRIM: /* Erase a block of sectors (used when _USE_TRIM in ffconf.h is 1) */ case CTRL_TRIM: // Erase a block of sectors (used when _USE_TRIM in ffconf.h is 1)
if (!(CardType & CT_SDC)) break; /* Check if the card is SDC */ if (!(CardType & CT_SDC)) break; // Check if the card is SDC
if (disk_ioctl(drv, MMC_GET_CSD, csd)) break; /* Get CSD */ if (disk_ioctl(drv, MMC_GET_CSD, csd)) break; // Get CSD
if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break; /* Check if sector erase can be applied to the card */ if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break; // Check if sector erase can be applied to the card
dp = (DWORD *)buff; st = dp[0]; ed = dp[1]; /* Load sector block */ dp = (DWORD *)buff; st = dp[0]; ed = dp[1]; // Load sector block
if (!(CardType & CT_BLOCK)) { if (!(CardType & CT_BLOCK)) {
st *= 512; ed *= 512; st *= 512; ed *= 512;
} }
if (send_cmd(CMD32, st) == 0 && send_cmd(CMD33, ed) == 0 && send_cmd(CMD38, 0) == 0 && wait_ready(30000)) { /* Erase sector block */ if (send_cmd(CMD32, st) == 0 && send_cmd(CMD33, ed) == 0 && send_cmd(CMD38, 0) == 0 && wait_ready(30000)) { // Erase sector block
res = RES_OK; /* FatFs does not check result of this command */ res = RES_OK; // FatFs does not check result of this command
} }
break; break;
/* Following commands are never used by FatFs module */ // The following commands are never used by FatFs module
case MMC_GET_TYPE: /* Get MMC/SDC type (BYTE) */ case MMC_GET_TYPE: // Get MMC/SDC type (BYTE)
*ptr = CardType; *ptr = CardType;
res = RES_OK; res = RES_OK;
break; break;
case MMC_GET_CSD: /* Read CSD (16 bytes) */ case MMC_GET_CSD: // Read CSD (16 bytes)
if (send_cmd(CMD9, 0) == 0 && rcvr_datablock(ptr, 16)) { /* READ_CSD */ if (send_cmd(CMD9, 0) == 0 && rcvr_datablock(ptr, 16)) {
res = RES_OK; res = RES_OK;
} }
break; break;
case MMC_GET_CID: /* Read CID (16 bytes) */ case MMC_GET_CID: // Read CID (16 bytes)
if (send_cmd(CMD10, 0) == 0 && rcvr_datablock(ptr, 16)) { /* READ_CID */ if (send_cmd(CMD10, 0) == 0 && rcvr_datablock(ptr, 16)) {
res = RES_OK; res = RES_OK;
} }
break; break;
case MMC_GET_OCR: /* Read OCR (4 bytes) */ case MMC_GET_OCR: // Read OCR (4 bytes)
if (send_cmd(CMD58, 0) == 0) { /* READ_OCR */ if (send_cmd(CMD58, 0) == 0) {
for (n = 4; n; n--) *ptr++ = xchg_spi(0xFF); for (n = 4; n; n--) *ptr++ = xchg_spi(0xFF);
res = RES_OK; res = RES_OK;
} }
break; break;
case MMC_GET_SDSTAT: /* Read SD status (64 bytes) */ case MMC_GET_SDSTAT: // Read SD status (64 bytes)
if (send_cmd(ACMD13, 0) == 0) { /* SD_STATUS */ if (send_cmd(ACMD13, 0) == 0) {
xchg_spi(0xFF); xchg_spi(0xFF);
if (rcvr_datablock(ptr, 64)) res = RES_OK; if (rcvr_datablock(ptr, 64)) res = RES_OK;
} }

Write Preview
Loading…
Cancel
Save