Brendan Unikewicz
updates
Fork of
SDFileSystem
by 
Neil Thiessen
Diff: SDFileSystem.cpp
- Revision:
- 11:67ddc53e3983
- Parent:
- 10:395539a1481a
- Child:
- 12:eebddab6eff2
--- a/SDFileSystem.cpp Tue Aug 12 14:58:07 2014 +0000
+++ b/SDFileSystem.cpp Thu Aug 14 22:27:07 2014 +0000
@@ -72,10 +72,10 @@
if (enabled && !m_Crc) {
//Send CMD59(0x00000001) to enable CRC
m_Crc = true;
- writeCommand(CMD59, 0x00000001);
+ commandTransaction(CMD59, 0x00000001);
} else if (!enabled && m_Crc) {
//Send CMD59(0x00000000) to disable CRC
- writeCommand(CMD59, 0x00000000);
+ commandTransaction(CMD59, 0x00000000);
m_Crc = false;
}
}
@@ -92,9 +92,23 @@
m_LargeFrames = enabled;
}
+int SDFileSystem::unmount()
+{
+ //Unmount the filesystem
+ FATFileSystem::unmount();
+
+ //Change the status to not initialized, and the card type to none
+ m_Status |= STA_NOINIT;
+ m_CardType = CARD_NONE;
+
+ //Always succeeds
+ return 0;
+}
+
int SDFileSystem::disk_initialize()
{
- char resp;
+ char token;
+ unsigned int resp;
//Make sure there's a card in the socket before proceeding
checkSocket();
@@ -114,26 +128,32 @@
m_Spi.write(0xFF);
//Write CMD0(0x00000000) to reset the card
- resp = writeCommand(CMD0, 0x00000000);
- if (resp != 0x01) {
+ if (commandTransaction(CMD0, 0x00000000) != 0x01) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
}
+ //Send CMD59(0x00000001) to enable CRC if necessary
+ if (m_Crc) {
+ if (commandTransaction(CMD59, 0x00000001) != 0x01) {
+ //Initialization failed
+ m_CardType = CARD_UNKNOWN;
+ return m_Status;
+ }
+ }
+
//Write CMD8(0x000001AA) to see if this is an SDCv2 card
- resp = writeCommand(CMD8, 0x000001AA);
- if (resp == 0x01) {
+ if (commandTransaction(CMD8, 0x000001AA, &resp) == 0x01) {
//This is an SDCv2 card, get the 32-bit return value and verify the voltage range/check pattern
- if ((readReturn() & 0xFFF) != 0x1AA) {
+ if ((resp & 0xFFF) != 0x1AA) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
}
//Send CMD58(0x00000000) to read the OCR, and verify that the card supports 3.2-3.3V
- resp = writeCommand(CMD58, 0x00000000);
- if (resp != 0x01 || !(readReturn() & (1 << 20))) {
+ if (commandTransaction(CMD58, 0x00000000, &resp) != 0x01 || !(resp & (1 << 20))) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
@@ -141,24 +161,23 @@
//Send ACMD41(0x40100000) repeatedly for up to 1 second to initialize the card
for (int i = 0; i < 1000; i++) {
- resp = writeCommand(ACMD41, 0x40100000);
- if (resp != 0x01)
+ token = commandTransaction(ACMD41, 0x40100000);
+ if (token != 0x01)
break;
wait_ms(1);
}
//Check if the card initialized
- if (resp != 0x00) {
+ if (token != 0x00) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
}
//Send CMD58(0x00000000) to read the OCR
- resp = writeCommand(CMD58, 0x00000000);
- if (resp == 0x00) {
+ if (commandTransaction(CMD58, 0x00000000, &resp) == 0x00) {
//Check the CCS bit to determine if this is a high capacity card
- if (readReturn() & (1 << 30))
+ if (resp & (1 << 30))
m_CardType = CARD_SDHC;
else
m_CardType = CARD_SD;
@@ -170,8 +189,7 @@
} else {
//Didn't respond or illegal command, this is either an SDCv1 or MMC card
//Send CMD58(0x00000000) to read the OCR, and verify that the card supports 3.2-3.3V
- resp = writeCommand(CMD58, 0x00000000);
- if (resp != 0x01 || !(readReturn() & (1 << 20))) {
+ if (commandTransaction(CMD58, 0x00000000, &resp) != 0x01 || !(resp & (1 << 20))) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
@@ -179,27 +197,27 @@
//Try to initialize the card using ACMD41(0x00100000) for 1 second
for (int i = 0; i < 1000; i++) {
- resp = writeCommand(ACMD41, 0x00100000);
- if (resp != 0x01)
+ token = commandTransaction(ACMD41, 0x00100000);
+ if (token != 0x01)
break;
wait_ms(1);
}
//Check if the card initialized
- if (resp == 0x00) {
+ if (token == 0x00) {
//This is an SDCv1 standard capacity card
m_CardType = CARD_SD;
} else {
//Try to initialize the card using CMD1(0x00100000) for 1 second
for (int i = 0; i < 1000; i++) {
- resp = writeCommand(CMD1, 0x00100000);
- if (resp != 0x01)
+ token = commandTransaction(CMD1, 0x00100000);
+ if (token != 0x01)
break;
wait_ms(1);
}
//Check if the card initialized
- if (resp == 0x00) {
+ if (token == 0x00) {
//This is an MMCv3 card
m_CardType = CARD_MMC;
} else {
@@ -210,20 +228,9 @@
}
}
- //Send CMD59(0x00000001) to enable CRC if necessary
- if (m_Crc) {
- resp = writeCommand(CMD59, 0x00000001);
- if (resp != 0x00) {
- //Initialization failed
- m_CardType = CARD_UNKNOWN;
- return m_Status;
- }
- }
-
//Send CMD16(0x00000200) to force the block size to 512B if necessary
if (m_CardType != CARD_SDHC) {
- resp = writeCommand(CMD16, 0x00000200);
- if (resp != 0x00) {
+ if (commandTransaction(CMD16, 0x00000200) != 0x00) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
@@ -232,8 +239,7 @@
//Send ACMD42(0x00000000) to disconnect the internal pull-up resistor on pin 1 if necessary
if (m_CardType != CARD_MMC) {
- resp = writeCommand(ACMD42, 0x00000000);
- if (resp != 0x00) {
+ if (commandTransaction(ACMD42, 0x00000000) != 0x00) {
//Initialization failed
m_CardType = CARD_UNKNOWN;
return m_Status;
@@ -264,34 +270,26 @@
return m_Status;
}
-int SDFileSystem::disk_read(uint8_t* buffer, uint64_t sector)
+int SDFileSystem::disk_read(uint8_t* buffer, uint64_t sector, uint8_t count)
{
//Make sure the card is initialized before proceeding
if (m_Status & STA_NOINIT)
return RES_NOTRDY;
- //Convert from LBA to a byte address for standard capacity cards
- if (m_CardType != CARD_SDHC)
- sector *= 512;
-
- //Try to read the block up to 3 times
- for (int i = 0; i < 3; i++) {
- //Send CMD17(sector) to read a single block
- if (writeCommand(CMD17, sector) == 0x00) {
- //Try to read the sector, and return if successful
- if (readData((char*)buffer, 512))
- return RES_OK;
- } else {
- //The command failed
- return RES_ERROR;
- }
+ //Read a single block, or multiple blocks
+ if (count > 1) {
+ if (readBlocks((char*)buffer, sector, count))
+ return RES_OK;
+ } else {
+ if (readBlock((char*)buffer, sector))
+ return RES_OK;
}
- //The read operation failed 3 times
+ //The read operation failed
return RES_ERROR;
}
-int SDFileSystem::disk_write(const uint8_t* buffer, uint64_t sector)
+int SDFileSystem::disk_write(const uint8_t* buffer, uint64_t sector, uint8_t count)
{
//Make sure the card is initialized before proceeding
if (m_Status & STA_NOINIT)
@@ -301,24 +299,16 @@
if (m_Status & STA_PROTECT)
return RES_WRPRT;
- //Convert from LBA to a byte address for older cards
- if (m_CardType != CARD_SDHC)
- sector *= 512;
-
- //Try to write the block up to 3 times
- for (int i = 0; i < 3; i++) {
- //Send CMD24(sector) to write a single block
- if (writeCommand(CMD24, sector) == 0x00) {
- //Try to write the sector, and return if successful
- if (writeData((char*)buffer))
- return RES_OK;
- } else {
- //The command failed
- return RES_ERROR;
- }
+ //Write a single block, or multiple blocks
+ if (count > 1) {
+ if(writeBlocks((const char*)buffer, sector, count))
+ return RES_OK;
+ } else {
+ if(writeBlock((const char*)buffer, sector))
+ return RES_OK;
}
- //The write operation failed 3 times
+ //The write operation failed
return RES_ERROR;
}
@@ -340,12 +330,18 @@
return 0;
//Try to read the CSD register up to 3 times
- for (int i = 0; i < 3; i++) {
+ for (int f = 0; f < 3; f++) {
+ //Select the card, and wait for ready
+ if (!select())
+ break;
+
//Send CMD9(0x00000000) to read the CSD register
- if (writeCommand(CMD9, 0x00000000) == 0x00) {
- //Receive the 16B CSD data
+ if (command(CMD9, 0x00000000) == 0x00) {
+ //Read the 16B CSD data block
char csd[16];
- if (readData(csd, 16)) {
+ bool success = readData(csd, 16);
+ deselect();
+ if (success) {
//Calculate the sector count based on the card type
if ((csd[0] >> 6) == 0x01) {
//Calculate the sector count for a high capacity card
@@ -360,12 +356,13 @@
}
}
} else {
- //The command failed
- return 0;
+ //The command failed, get out
+ break;
}
}
//The read operation failed 3 times
+ deselect();
return 0;
}
@@ -418,27 +415,40 @@
//Deassert /CS
m_Cs = 1;
- //Send 8 dummy clocks with DI held high to disable DO (will also initiate any internal write process)
+ //Send 8 dummy clocks with DI held high to disable DO
m_Spi.write(0xFF);
}
-char SDFileSystem::writeCommand(char cmd, unsigned int arg)
+inline char SDFileSystem::commandTransaction(char cmd, unsigned int arg, unsigned int* resp)
{
- char resp;
+ //Select the card, and wait for ready
+ if (!select())
+ return 0xFF;
+
+ //Perform the command transaction
+ char token = command(cmd, arg, resp);
+
+ //Deselect the card, and return the R1 response token
+ deselect();
+ return token;
+}
+
+char SDFileSystem::command(char cmd, unsigned int arg, unsigned int* resp)
+{
+ char token;
//Try to send the command up to 3 times
- for (int i = 0; i < 3; i++) {
+ for (int f = 0; f < 3; f++) {
//Send CMD55(0x00000000) prior to an application specific command
- if (cmd == ACMD41 || cmd == ACMD42) {
- resp = writeCommand(CMD55, 0x00000000);
- if (resp > 0x01)
- return resp;
+ if (cmd == ACMD23 || cmd == ACMD41 || cmd == ACMD42) {
+ token = command(CMD55, 0x00000000);
+ if (token > 0x01)
+ return token;
+
+ //Some cards need a dummy byte between CMD55 and an ACMD
+ m_Spi.write(0xFF);
}
- //Select the card, and wait for ready
- if (!select())
- return 0xFF;
-
//Prepare the command packet
char cmdPacket[6];
cmdPacket[0] = cmd;
@@ -452,44 +462,50 @@
cmdPacket[5] = 0x01;
//Send the command packet
- for (int b = 0; b < 6; b++)
- m_Spi.write(cmdPacket[b]);
+ for (int i = 0; i < 6; i++)
+ m_Spi.write(cmdPacket[i]);
- //Allow up to 8 bytes of delay for the command response
- for (int b = 0; b < 9; b++) {
- resp = m_Spi.write(0xFF);
- if (!(resp & 0x80))
+ //Discard the stuff byte immediately following CMD12
+ if (cmd == CMD12)
+ m_Spi.write(0xFF);
+
+ //Allow up to 8 bytes of delay for the R1 response token
+ for (int i = 0; i < 9; i++) {
+ token = m_Spi.write(0xFF);
+ if (!(token & 0x80))
break;
}
- //Deselect the card on errors, or if the transaction is finished
- if (resp > 0x01 || !(cmd == CMD8 || cmd == CMD9 || cmd == CMD17 || cmd == CMD24 || cmd == CMD55 || cmd == CMD58))
- deselect();
+ //Verify the R1 response token
+ if (token == 0xFF) {
+ //No data was received, get out early
+ break;
+ } else if (token & (1 << 3)) {
+ //There was a CRC error, try again
+ continue;
+ } else if (token > 0x01) {
+ //An error occured, get out early
+ break;
+ }
- //Return the response unless there was a CRC error
- if (resp == 0xFF || !(resp & (1 << 3)))
- return resp;
+ //Handle R2 and R3/R7 response tokens
+ if (cmd == CMD13 && resp != NULL) {
+ //Read the R2 response value
+ *resp = m_Spi.write(0xFF);
+ } else if ((cmd == CMD8 || cmd == CMD58) && resp != NULL) {
+ //Read the R3/R7 response value
+ *resp = (m_Spi.write(0xFF) << 24);
+ *resp |= (m_Spi.write(0xFF) << 16);
+ *resp |= (m_Spi.write(0xFF) << 8);
+ *resp |= m_Spi.write(0xFF);
+ }
+
+ //The command was successful
+ break;
}
- //The command failed 3 times
- return 0xFF;
-}
-
-unsigned int SDFileSystem::readReturn()
-{
- unsigned int ret;
-
- //Read the 32-bit response value
- ret = (m_Spi.write(0xFF) << 24);
- ret |= (m_Spi.write(0xFF) << 16);
- ret |= (m_Spi.write(0xFF) << 8);
- ret |= m_Spi.write(0xFF);
-
- //Deselect the card
- deselect();
-
- //Return the response value
- return ret;
+ //Return the R1 response token
+ return token;
}
bool SDFileSystem::readData(char* buffer, int length)
@@ -497,7 +513,7 @@
char token;
unsigned short crc;
- //Wait for up to 200ms for the data token to arrive
+ //Wait for up to 200ms for the start block token to arrive
for (int i = 0; i < 200; i++) {
token = m_Spi.write(0xFF);
if (token != 0xFF)
@@ -506,10 +522,8 @@
}
//Make sure the token is valid
- if (token != 0xFE) {
- deselect();
+ if (token != 0xFE)
return false;
- }
//Check if large frames are enabled or not
if (m_LargeFrames) {
@@ -539,36 +553,29 @@
crc |= m_Spi.write(0xFF);
}
- //Deselect the card
- deselect();
-
//Return the validity of the CRC16 checksum (if enabled)
return (!m_Crc || crc == CRC16(buffer, length));
}
-bool SDFileSystem::writeData(const char* buffer)
+char SDFileSystem::writeData(const char* buffer, char token)
{
- //Wait for up to 500ms for the card to become ready
- if (!waitReady(500)) {
- //We timed out, deselect and indicate failure
- deselect();
- return false;
- }
-
- //Send the data token
- m_Spi.write(0xFE);
-
//Calculate the CRC16 checksum for the data block (if enabled)
unsigned short crc = (m_Crc) ? CRC16(buffer, 512) : 0xFFFF;
+ //Wait for the card to become ready
+ while (!m_Spi.write(0xFF));
+
+ //Send the start block token
+ m_Spi.write(token);
+
//Check if large frames are enabled or not
if (m_LargeFrames) {
//Switch to 16-bit frames for better performance
m_Spi.format(16, 0);
//Write the data block from the buffer
- for (int b = 0; b < 512; b += 2)
- m_Spi.write((buffer[b] << 8) | buffer[b + 1]);
+ for (int i = 0; i < 512; i += 2)
+ m_Spi.write((buffer[i] << 8) | buffer[i + 1]);
//Send the CRC16 checksum for the data block
m_Spi.write(crc);
@@ -577,20 +584,247 @@
m_Spi.format(8, 0);
} else {
//Write the data block from the buffer
- for (int b = 0; b < 512; b++)
- m_Spi.write(buffer[b]);
+ for (int i = 0; i < 512; i++)
+ m_Spi.write(buffer[i]);
//Send the CRC16 checksum for the data block
m_Spi.write(crc >> 8);
m_Spi.write(crc);
}
- //Receive the data response
- char resp = m_Spi.write(0xFF);
+ //Return the data response token
+ return (m_Spi.write(0xFF) & 0x1F);
+}
+
+inline bool SDFileSystem::readBlock(char* buffer, unsigned long long lba)
+{
+ //Try to read the block up to 3 times
+ for (int f = 0; f < 3; f++) {
+ //Select the card, and wait for ready
+ if (!select())
+ break;
+
+ //Send CMD17(block) to read a single block
+ if (command(CMD17, (m_CardType == CARD_SDHC) ? lba : lba * 512) == 0x00) {
+ //Try to read the block, and deselect the card
+ bool success = readData(buffer, 512);
+ deselect();
+
+ //Return if successful
+ if (success)
+ return true;
+ } else {
+ //The command failed, get out
+ break;
+ }
+ }
+
+ //The single block read failed
+ deselect();
+ return false;
+}
+
+inline bool SDFileSystem::readBlocks(char* buffer, unsigned long long lba, int count)
+{
+ //Try to read each block up to 3 times
+ for (int f = 0; f < 3;) {
+ //Select the card, and wait for ready
+ if (!select())
+ break;
- //Deselect the card (this will initiate the internal write process)
+ //Send CMD18(block) to read multiple blocks
+ if (command(CMD18, (m_CardType == CARD_SDHC) ? lba : lba * 512) == 0x00) {
+ //Try to read all of the data blocks
+ do {
+ //Read the next block and break on errors
+ if (!readData(buffer, 512)) {
+ f++;
+ break;
+ }
+
+ //Update the variables
+ lba++;
+ buffer += 512;
+ f = 0;
+ } while (--count);
+
+ //Send CMD12(0x00000000) to stop the transmission
+ if (command(CMD12, 0x00000000) != 0x00) {
+ //The command failed, get out
+ break;
+ }
+
+ //Only wait for CMD12 if the read was unsuccessful
+ if (count)
+ while (!m_Spi.write(0xFF));
+
+ //Deselect the card
+ deselect();
+
+ //Return if successful
+ if (count == 0)
+ return true;
+ } else {
+ //The command failed, get out
+ break;
+ }
+ }
+
+ //The multiple block read failed
deselect();
+ return false;
+}
- //Return success/failure
- return ((resp & 0x1F) == 0x05);
+inline bool SDFileSystem::writeBlock(const char* buffer, unsigned long long lba)
+{
+ //Try to write the block up to 3 times
+ for (int f = 0; f < 3; f++) {
+ //Select the card, and wait for ready
+ if (!select())
+ break;
+
+ //Send CMD24(block) to write a single block
+ if (command(CMD24, (m_CardType == CARD_SDHC) ? lba : lba * 512) == 0x00) {
+ //Try to write the block, and deselect the card
+ char token = writeData(buffer, 0xFE);
+ deselect();
+
+ //Check the data response token
+ if (token == 0x0A) {
+ //A CRC error occured, try again
+ continue;
+ } else if (token == 0x0C) {
+ //A write error occured, get out
+ break;
+ }
+
+ //Send CMD13(0x00000000) to verify that the programming was successful
+ unsigned int resp;
+ if (commandTransaction(CMD13, 0x00000000, &resp) != 0x00 || resp != 0x00) {
+ //Some manner of unrecoverable write error occured during programming, get out
+ break;
+ }
+
+ //The data was written successfully
+ return true;
+ } else {
+ //The command failed, get out
+ break;
+ }
+ }
+
+ //The single block write failed
+ deselect();
+ return false;
}
+
+inline bool SDFileSystem::writeBlocks(const char* buffer, unsigned long long lba, int count)
+{
+ char token;
+ const char* currentBuffer = buffer;
+ unsigned long long currentLba = lba;
+ int currentCount = count;
+
+ //Try to write each block up to 3 times
+ for (int f = 0; f < 3;) {
+ //If this is an SD card, send ACMD23(count) to set the number of blocks to pre-erase
+ if (m_CardType != CARD_MMC) {
+ if (commandTransaction(ACMD23, currentCount) != 0x00) {
+ //The command failed, get out
+ break;
+ }
+ }
+
+ //Select the card, and wait for ready
+ if (!select())
+ break;
+
+ //Send CMD25(block) to write multiple blocks
+ if (command(CMD25, (m_CardType == CARD_SDHC) ? currentLba : currentLba * 512) == 0x00) {
+ //Try to write all of the data blocks
+ do {
+ //Write the next block and break on errors
+ token = writeData(currentBuffer, 0xFC);
+ if (token != 0x05) {
+ f++;
+ break;
+ }
+
+ //Update the variables
+ currentBuffer += 512;
+ f = 0;
+ } while (--currentCount);
+
+ //Wait for the card to finish processing the last block
+ while (!m_Spi.write(0xFF));
+
+ //Finalize the transmission
+ if (currentCount == 0) {
+ //Send the stop tran token
+ m_Spi.write(0xFD);
+
+ //Wait for the programming to complete, and deselect the card
+ while (!m_Spi.write(0xFF));
+ deselect();
+
+ //Send CMD13(0x00000000) to verify that the programming was successful
+ unsigned int resp;
+ if (commandTransaction(CMD13, 0x00000000, &resp) != 0x00 || resp != 0x00) {
+ //Some manner of unrecoverable write error occured during programming, get out
+ break;
+ }
+
+ //The data was written successfully
+ return true;
+ } else {
+ //Send CMD12(0x00000000) to abort the transmission
+ if (command(CMD12, 0x00000000) != 0x00) {
+ //The command failed, get out
+ break;
+ }
+
+ //Wait for CMD12 to complete, and deselect the card
+ while (!m_Spi.write(0xFF));
+ deselect();
+
+ //Check the error token
+ if (token == 0x0A) {
+ //Determine the number of well written blocks if possible
+ unsigned int writtenBlocks = 0;
+ if (m_CardType != CARD_MMC) {
+ //Send ACMD22(0x00000000) to get the number of well written blocks
+ if (commandTransaction(ACMD22, 0x00000000) == 0x00) {
+ //Read the data
+ char acmdData[4];
+ if (readData(acmdData, 4)) {
+ //Extract the number of well written blocks
+ writtenBlocks = acmdData[0] << 24;
+ writtenBlocks |= acmdData[1] << 16;
+ writtenBlocks |= acmdData[2] << 8;
+ writtenBlocks |= acmdData[3];
+ }
+ }
+ }
+
+ //Roll back the variables based on the number of well written blocks
+ currentBuffer = buffer + (writtenBlocks * 512);
+ currentLba = lba + writtenBlocks;
+ currentCount = count - writtenBlocks;
+
+ //Try again
+ continue;
+ } else {
+ //A write error occured, get out
+ break;
+ }
+ }
+ } else {
+ //The command failed, get out
+ break;
+ }
+ }
+
+ //The multiple block write failed
+ deselect();
+ return false;
+}