Slight modification to SDFileSystem so that if the first initialization doesn't do the trick it tries doing it again (which so far has fixed every issue for me)
Fork of SDFileSystem by
SDFileSystem.cpp
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2006-2012 ARM Limited 00003 * 00004 * Permission is hereby granted, free of charge, to any person obtaining a copy 00005 * of this software and associated documentation files (the "Software"), to deal 00006 * in the Software without restriction, including without limitation the rights 00007 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 00008 * copies of the Software, and to permit persons to whom the Software is 00009 * furnished to do so, subject to the following conditions: 00010 * 00011 * The above copyright notice and this permission notice shall be included in 00012 * all copies or substantial portions of the Software. 00013 * 00014 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00015 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00016 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 00017 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00018 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 00019 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 00020 * SOFTWARE. 00021 */ 00022 /* Introduction 00023 * ------------ 00024 * SD and MMC cards support a number of interfaces, but common to them all 00025 * is one based on SPI. This is the one I'm implmenting because it means 00026 * it is much more portable even though not so performant, and we already 00027 * have the mbed SPI Interface! 00028 * 00029 * The main reference I'm using is Chapter 7, "SPI Mode" of: 00030 * http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf 00031 * 00032 * SPI Startup 00033 * ----------- 00034 * The SD card powers up in SD mode. The SPI interface mode is selected by 00035 * asserting CS low and sending the reset command (CMD0). The card will 00036 * respond with a (R1) response. 00037 * 00038 * CMD8 is optionally sent to determine the voltage range supported, and 00039 * indirectly determine whether it is a version 1.x SD/non-SD card or 00040 * version 2.x. I'll just ignore this for now. 00041 * 00042 * ACMD41 is repeatedly issued to initialise the card, until "in idle" 00043 * (bit 0) of the R1 response goes to '0', indicating it is initialised. 00044 * 00045 * You should also indicate whether the host supports High Capicity cards, 00046 * and check whether the card is high capacity - i'll also ignore this 00047 * 00048 * SPI Protocol 00049 * ------------ 00050 * The SD SPI protocol is based on transactions made up of 8-bit words, with 00051 * the host starting every bus transaction by asserting the CS signal low. The 00052 * card always responds to commands, data blocks and errors. 00053 * 00054 * The protocol supports a CRC, but by default it is off (except for the 00055 * first reset CMD0, where the CRC can just be pre-calculated, and CMD8) 00056 * I'll leave the CRC off I think! 00057 * 00058 * Standard capacity cards have variable data block sizes, whereas High 00059 * Capacity cards fix the size of data block to 512 bytes. I'll therefore 00060 * just always use the Standard Capacity cards with a block size of 512 bytes. 00061 * This is set with CMD16. 00062 * 00063 * You can read and write single blocks (CMD17, CMD25) or multiple blocks 00064 * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When 00065 * the card gets a read command, it responds with a response token, and then 00066 * a data token or an error. 00067 * 00068 * SPI Command Format 00069 * ------------------ 00070 * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC. 00071 * 00072 * +---------------+------------+------------+-----------+----------+--------------+ 00073 * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 | 00074 * +---------------+------------+------------+-----------+----------+--------------+ 00075 * 00076 * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95) 00077 * 00078 * All Application Specific commands shall be preceded with APP_CMD (CMD55). 00079 * 00080 * SPI Response Format 00081 * ------------------- 00082 * The main response format (R1) is a status byte (normally zero). Key flags: 00083 * idle - 1 if the card is in an idle state/initialising 00084 * cmd - 1 if an illegal command code was detected 00085 * 00086 * +-------------------------------------------------+ 00087 * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle | 00088 * +-------------------------------------------------+ 00089 * 00090 * R1b is the same, except it is followed by a busy signal (zeros) until 00091 * the first non-zero byte when it is ready again. 00092 * 00093 * Data Response Token 00094 * ------------------- 00095 * Every data block written to the card is acknowledged by a byte 00096 * response token 00097 * 00098 * +----------------------+ 00099 * | xxx | 0 | status | 1 | 00100 * +----------------------+ 00101 * 010 - OK! 00102 * 101 - CRC Error 00103 * 110 - Write Error 00104 * 00105 * Single Block Read and Write 00106 * --------------------------- 00107 * 00108 * Block transfers have a byte header, followed by the data, followed 00109 * by a 16-bit CRC. In our case, the data will always be 512 bytes. 00110 * 00111 * +------+---------+---------+- - - -+---------+-----------+----------+ 00112 * | 0xFE | data[0] | data[1] | | data[n] | crc[15:8] | crc[7:0] | 00113 * +------+---------+---------+- - - -+---------+-----------+----------+ 00114 */ 00115 #include "SDFileSystem.h" 00116 #include "mbed_debug.h" 00117 00118 #define SD_COMMAND_TIMEOUT 5000 00119 00120 #define SD_DBG 0 00121 00122 SDFileSystem::SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name) : 00123 FATFileSystem(name), _spi(mosi, miso, sclk), _cs(cs) { 00124 _cs = 1; 00125 tried_again=0; 00126 } 00127 00128 #define R1_IDLE_STATE (1 << 0) 00129 #define R1_ERASE_RESET (1 << 1) 00130 #define R1_ILLEGAL_COMMAND (1 << 2) 00131 #define R1_COM_CRC_ERROR (1 << 3) 00132 #define R1_ERASE_SEQUENCE_ERROR (1 << 4) 00133 #define R1_ADDRESS_ERROR (1 << 5) 00134 #define R1_PARAMETER_ERROR (1 << 6) 00135 00136 // Types 00137 // - v1.x Standard Capacity 00138 // - v2.x Standard Capacity 00139 // - v2.x High Capacity 00140 // - Not recognised as an SD Card 00141 #define SDCARD_FAIL 0 00142 #define SDCARD_V1 1 00143 #define SDCARD_V2 2 00144 #define SDCARD_V2HC 3 00145 00146 int SDFileSystem::initialise_card() { 00147 // Set to 100kHz for initialisation, and clock card with cs = 1 00148 _spi.frequency(100000); 00149 _cs = 1; 00150 for (int i = 0; i < 16; i++) { 00151 _spi.write(0xFF); 00152 } 00153 00154 // send CMD0, should return with all zeros except IDLE STATE set (bit 0) 00155 if (_cmd(0, 0) != R1_IDLE_STATE) { 00156 if(!tried_again) 00157 { 00158 tried_again=1; 00159 return initialise_card(); //for good luck, try it again? 00160 } 00161 debug("No disk, or could not put SD card in to SPI idle state\n"); 00162 return SDCARD_FAIL; 00163 } 00164 00165 // send CMD8 to determine whther it is ver 2.x 00166 int r = _cmd8(); 00167 if (r == R1_IDLE_STATE) { 00168 return initialise_card_v2(); 00169 } else if (r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) { 00170 return initialise_card_v1(); 00171 } else { 00172 debug("Not in idle state after sending CMD8 (not an SD card?)\n"); 00173 return SDCARD_FAIL; 00174 } 00175 } 00176 00177 int SDFileSystem::initialise_card_v1() { 00178 for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) { 00179 _cmd(55, 0); 00180 if (_cmd(41, 0) == 0) { 00181 cdv = 512; 00182 debug_if(SD_DBG, "\n\rInit: SEDCARD_V1\n\r"); 00183 return SDCARD_V1; 00184 } 00185 } 00186 00187 debug("Timeout waiting for v1.x card\n"); 00188 return SDCARD_FAIL; 00189 } 00190 00191 int SDFileSystem::initialise_card_v2() { 00192 for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) { 00193 wait_ms(50); 00194 _cmd58(); 00195 _cmd(55, 0); 00196 if (_cmd(41, 0x40000000) == 0) { 00197 _cmd58(); 00198 debug_if(SD_DBG, "\n\rInit: SDCARD_V2\n\r"); 00199 cdv = 1; 00200 return SDCARD_V2; 00201 } 00202 } 00203 00204 debug("Timeout waiting for v2.x card\n"); 00205 return SDCARD_FAIL; 00206 } 00207 00208 int SDFileSystem::disk_initialize() { 00209 int i = initialise_card(); 00210 debug_if(SD_DBG, "init card = %d\n", i); 00211 _sectors = _sd_sectors(); 00212 00213 // Set block length to 512 (CMD16) 00214 if (_cmd(16, 512) != 0) { 00215 debug("Set 512-byte block timed out\n"); 00216 return 1; 00217 } 00218 00219 _spi.frequency(1000000); // Set to 1MHz for data transfer 00220 return 0; 00221 } 00222 00223 int SDFileSystem::disk_write(const uint8_t *buffer, uint64_t block_number) { 00224 // set write address for single block (CMD24) 00225 if (_cmd(24, block_number * cdv) != 0) { 00226 return 1; 00227 } 00228 00229 // send the data block 00230 _write(buffer, 512); 00231 return 0; 00232 } 00233 00234 int SDFileSystem::disk_read(uint8_t *buffer, uint64_t block_number) { 00235 // set read address for single block (CMD17) 00236 if (_cmd(17, block_number * cdv) != 0) { 00237 return 1; 00238 } 00239 00240 // receive the data 00241 _read(buffer, 512); 00242 return 0; 00243 } 00244 00245 int SDFileSystem::disk_status() { return 0; } 00246 int SDFileSystem::disk_sync() { return 0; } 00247 uint64_t SDFileSystem::disk_sectors() { return _sectors; } 00248 00249 00250 // PRIVATE FUNCTIONS 00251 int SDFileSystem::_cmd(int cmd, int arg) { 00252 _cs = 0; 00253 00254 // send a command 00255 _spi.write(0x40 | cmd); 00256 _spi.write(arg >> 24); 00257 _spi.write(arg >> 16); 00258 _spi.write(arg >> 8); 00259 _spi.write(arg >> 0); 00260 _spi.write(0x95); 00261 00262 // wait for the repsonse (response[7] == 0) 00263 for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) { 00264 int response = _spi.write(0xFF); 00265 if (!(response & 0x80)) { 00266 _cs = 1; 00267 _spi.write(0xFF); 00268 return response; 00269 } 00270 } 00271 _cs = 1; 00272 _spi.write(0xFF); 00273 return -1; // timeout 00274 } 00275 int SDFileSystem::_cmdx(int cmd, int arg) { 00276 _cs = 0; 00277 00278 // send a command 00279 _spi.write(0x40 | cmd); 00280 _spi.write(arg >> 24); 00281 _spi.write(arg >> 16); 00282 _spi.write(arg >> 8); 00283 _spi.write(arg >> 0); 00284 _spi.write(0x95); 00285 00286 // wait for the repsonse (response[7] == 0) 00287 for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) { 00288 int response = _spi.write(0xFF); 00289 if (!(response & 0x80)) { 00290 return response; 00291 } 00292 } 00293 _cs = 1; 00294 _spi.write(0xFF); 00295 return -1; // timeout 00296 } 00297 00298 00299 int SDFileSystem::_cmd58() { 00300 _cs = 0; 00301 int arg = 0; 00302 00303 // send a command 00304 _spi.write(0x40 | 58); 00305 _spi.write(arg >> 24); 00306 _spi.write(arg >> 16); 00307 _spi.write(arg >> 8); 00308 _spi.write(arg >> 0); 00309 _spi.write(0x95); 00310 00311 // wait for the repsonse (response[7] == 0) 00312 for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) { 00313 int response = _spi.write(0xFF); 00314 if (!(response & 0x80)) { 00315 int ocr = _spi.write(0xFF) << 24; 00316 ocr |= _spi.write(0xFF) << 16; 00317 ocr |= _spi.write(0xFF) << 8; 00318 ocr |= _spi.write(0xFF) << 0; 00319 _cs = 1; 00320 _spi.write(0xFF); 00321 return response; 00322 } 00323 } 00324 _cs = 1; 00325 _spi.write(0xFF); 00326 return -1; // timeout 00327 } 00328 00329 int SDFileSystem::_cmd8() { 00330 _cs = 0; 00331 00332 // send a command 00333 _spi.write(0x40 | 8); // CMD8 00334 _spi.write(0x00); // reserved 00335 _spi.write(0x00); // reserved 00336 _spi.write(0x01); // 3.3v 00337 _spi.write(0xAA); // check pattern 00338 _spi.write(0x87); // crc 00339 00340 // wait for the repsonse (response[7] == 0) 00341 for (int i = 0; i < SD_COMMAND_TIMEOUT * 1000; i++) { 00342 char response[5]; 00343 response[0] = _spi.write(0xFF); 00344 if (!(response[0] & 0x80)) { 00345 for (int j = 1; j < 5; j++) { 00346 response[i] = _spi.write(0xFF); 00347 } 00348 _cs = 1; 00349 _spi.write(0xFF); 00350 return response[0]; 00351 } 00352 } 00353 _cs = 1; 00354 _spi.write(0xFF); 00355 return -1; // timeout 00356 } 00357 00358 int SDFileSystem::_read(uint8_t *buffer, uint32_t length) { 00359 _cs = 0; 00360 00361 // read until start byte (0xFF) 00362 while (_spi.write(0xFF) != 0xFE); 00363 00364 // read data 00365 for (int i = 0; i < length; i++) { 00366 buffer[i] = _spi.write(0xFF); 00367 } 00368 _spi.write(0xFF); // checksum 00369 _spi.write(0xFF); 00370 00371 _cs = 1; 00372 _spi.write(0xFF); 00373 return 0; 00374 } 00375 00376 int SDFileSystem::_write(const uint8_t*buffer, uint32_t length) { 00377 _cs = 0; 00378 00379 // indicate start of block 00380 _spi.write(0xFE); 00381 00382 // write the data 00383 for (int i = 0; i < length; i++) { 00384 _spi.write(buffer[i]); 00385 } 00386 00387 // write the checksum 00388 _spi.write(0xFF); 00389 _spi.write(0xFF); 00390 00391 // check the response token 00392 if ((_spi.write(0xFF) & 0x1F) != 0x05) { 00393 _cs = 1; 00394 _spi.write(0xFF); 00395 return 1; 00396 } 00397 00398 // wait for write to finish 00399 while (_spi.write(0xFF) == 0); 00400 00401 _cs = 1; 00402 _spi.write(0xFF); 00403 return 0; 00404 } 00405 00406 static uint32_t ext_bits(unsigned char *data, int msb, int lsb) { 00407 uint32_t bits = 0; 00408 uint32_t size = 1 + msb - lsb; 00409 for (int i = 0; i < size; i++) { 00410 uint32_t position = lsb + i; 00411 uint32_t byte = 15 - (position >> 3); 00412 uint32_t bit = position & 0x7; 00413 uint32_t value = (data[byte] >> bit) & 1; 00414 bits |= value << i; 00415 } 00416 return bits; 00417 } 00418 00419 uint64_t SDFileSystem::_sd_sectors() { 00420 uint32_t c_size, c_size_mult, read_bl_len; 00421 uint32_t block_len, mult, blocknr, capacity; 00422 uint32_t hc_c_size; 00423 uint64_t blocks; 00424 00425 // CMD9, Response R2 (R1 byte + 16-byte block read) 00426 if (_cmdx(9, 0) != 0) { 00427 debug("Didn't get a response from the disk\n"); 00428 return 0; 00429 } 00430 00431 uint8_t csd[16]; 00432 if (_read(csd, 16) != 0) { 00433 debug("Couldn't read csd response from disk\n"); 00434 return 0; 00435 } 00436 00437 // csd_structure : csd[127:126] 00438 // c_size : csd[73:62] 00439 // c_size_mult : csd[49:47] 00440 // read_bl_len : csd[83:80] - the *maximum* read block length 00441 00442 int csd_structure = ext_bits(csd, 127, 126); 00443 00444 switch (csd_structure) { 00445 case 0: 00446 cdv = 512; 00447 c_size = ext_bits(csd, 73, 62); 00448 c_size_mult = ext_bits(csd, 49, 47); 00449 read_bl_len = ext_bits(csd, 83, 80); 00450 00451 block_len = 1 << read_bl_len; 00452 mult = 1 << (c_size_mult + 2); 00453 blocknr = (c_size + 1) * mult; 00454 capacity = blocknr * block_len; 00455 blocks = capacity / 512; 00456 debug_if(SD_DBG, "\n\rSDCard\n\rc_size: %d \n\rcapacity: %ld \n\rsectors: %lld\n\r", c_size, capacity, blocks); 00457 break; 00458 00459 case 1: 00460 cdv = 1; 00461 hc_c_size = ext_bits(csd, 63, 48); 00462 blocks = (hc_c_size+1)*1024; 00463 debug_if(SD_DBG, "\n\rSDHC Card \n\rhc_c_size: %d\n\rcapacity: %lld \n\rsectors: %lld\n\r", hc_c_size, blocks*512, blocks); 00464 break; 00465 00466 default: 00467 debug("CSD struct unsupported\r\n"); 00468 return 0; 00469 }; 00470 return blocks; 00471 }
Generated on Mon Jul 18 2022 18:01:37 by 1.7.2