Prof Greg Egan / Mbed 2 deprecated UAVXArm-GKE

UAVX Multicopter Flight Controller.

Dependencies:   mbed

SDFileSystem/SDFileSystem.cpp@2:90292f8bd179, 2011-04-26 (annotated)

Committer:
gke
Date:
Tue Apr 26 12:12:29 2011 +0000
Revision:
2:90292f8bd179
Parent:
0:62a1c91a859a 
Not flightworthy. Posted for others to make use of the I2C SW code.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gke 0:62a1c91a859a 1 /* mbed SDFileSystem Library, for providing file access to SD cards
gke 0:62a1c91a859a 2 * Copyright (c) 2008-2010, sford
gke 0:62a1c91a859a 3 *
gke 0:62a1c91a859a 4 * Permission is hereby granted, free of charge, to any person obtaining a copy
gke 0:62a1c91a859a 5 * of this software and associated documentation files (the "Software"), to deal
gke 0:62a1c91a859a 6 * in the Software without restriction, including without limitation the rights
gke 0:62a1c91a859a 7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
gke 0:62a1c91a859a 8 * copies of the Software, and to permit persons to whom the Software is
gke 0:62a1c91a859a 9 * furnished to do so, subject to the following conditions:
gke 0:62a1c91a859a 10 *
gke 0:62a1c91a859a 11 * The above copyright notice and this permission notice shall be included in
gke 0:62a1c91a859a 12 * all copies or substantial portions of the Software.
gke 0:62a1c91a859a 13 *
gke 0:62a1c91a859a 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
gke 0:62a1c91a859a 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
gke 0:62a1c91a859a 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
gke 0:62a1c91a859a 17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
gke 0:62a1c91a859a 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
gke 0:62a1c91a859a 19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
gke 0:62a1c91a859a 20 * THE SOFTWARE.
gke 0:62a1c91a859a 21 */
gke 0:62a1c91a859a 22
gke 0:62a1c91a859a 23 /* Introduction
gke 0:62a1c91a859a 24 * ------------
gke 0:62a1c91a859a 25 * SD and MMC cards support a number of interfaces, but common to them all
gke 0:62a1c91a859a 26 * is one based on SPI. This is the one I'm implmenting because it means
gke 0:62a1c91a859a 27 * it is much more portable even though not so performant, and we already
gke 0:62a1c91a859a 28 * have the mbed SPI Interface!
gke 0:62a1c91a859a 29 *
gke 0:62a1c91a859a 30 * The main reference I'm using is Chapter 7, "SPI Mode" of:
gke 0:62a1c91a859a 31 * http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
gke 0:62a1c91a859a 32 *
gke 0:62a1c91a859a 33 * SPI Startup
gke 0:62a1c91a859a 34 * -----------
gke 0:62a1c91a859a 35 * The SD card powers up in SD mode. The SPI interface mode is selected by
gke 0:62a1c91a859a 36 * asserting CS low and sending the reset command (CMD0). The card will
gke 0:62a1c91a859a 37 * respond with a (R1) response.
gke 0:62a1c91a859a 38 *
gke 0:62a1c91a859a 39 * CMD8 is optionally sent to determine the voltage range supported, and
gke 0:62a1c91a859a 40 * indirectly determine whether it is a version 1.x SD/non-SD card or
gke 0:62a1c91a859a 41 * version 2.x. I'll just ignore this for now.
gke 0:62a1c91a859a 42 *
gke 0:62a1c91a859a 43 * ACMD41 is repeatedly issued to initialise the card, until "in idle"
gke 0:62a1c91a859a 44 * (bit 0) of the R1 response goes to '0', indicating it is initialised.
gke 0:62a1c91a859a 45 *
gke 0:62a1c91a859a 46 * You should also indicate whether the host supports High Capicity cards,
gke 0:62a1c91a859a 47 * and check whether the card is high capacity - i'll also ignore this
gke 0:62a1c91a859a 48 *
gke 0:62a1c91a859a 49 * SPI Protocol
gke 0:62a1c91a859a 50 * ------------
gke 0:62a1c91a859a 51 * The SD SPI protocol is based on transactions made up of 8-bit words, with
gke 0:62a1c91a859a 52 * the host starting every bus transaction by asserting the CS signal low. The
gke 0:62a1c91a859a 53 * card always responds to commands, data blocks and errors.
gke 0:62a1c91a859a 54 *
gke 0:62a1c91a859a 55 * The protocol supports a CRC, but by default it is off (except for the
gke 0:62a1c91a859a 56 * first reset CMD0, where the CRC can just be pre-calculated, and CMD8)
gke 0:62a1c91a859a 57 * I'll leave the CRC off I think!
gke 0:62a1c91a859a 58 *
gke 0:62a1c91a859a 59 * Standard capacity cards have variable data block sizes, whereas High
gke 0:62a1c91a859a 60 * Capacity cards fix the size of data block to 512 bytes. I'll therefore
gke 0:62a1c91a859a 61 * just always use the Standard Capacity cards with a block size of 512 bytes.
gke 0:62a1c91a859a 62 * This is set with CMD16.
gke 0:62a1c91a859a 63 *
gke 0:62a1c91a859a 64 * You can read and write single blocks (CMD17, CMD25) or multiple blocks
gke 0:62a1c91a859a 65 * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When
gke 0:62a1c91a859a 66 * the card gets a read command, it responds with a response token, and then
gke 0:62a1c91a859a 67 * a data token or an error.
gke 0:62a1c91a859a 68 *
gke 0:62a1c91a859a 69 * SPI Command Format
gke 0:62a1c91a859a 70 * ------------------
gke 0:62a1c91a859a 71 * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC.
gke 0:62a1c91a859a 72 *
gke 0:62a1c91a859a 73 * +---------------+------------+------------+-----------+----------+--------------+
gke 0:62a1c91a859a 74 * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 |
gke 0:62a1c91a859a 75 * +---------------+------------+------------+-----------+----------+--------------+
gke 0:62a1c91a859a 76 *
gke 0:62a1c91a859a 77 * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95)
gke 0:62a1c91a859a 78 *
gke 0:62a1c91a859a 79 * All Application Specific commands shall be preceded with APP_CMD (CMD55).
gke 0:62a1c91a859a 80 *
gke 0:62a1c91a859a 81 * SPI Response Format
gke 0:62a1c91a859a 82 * -------------------
gke 0:62a1c91a859a 83 * The main response format (R1) is a status byte (normally zero). Key flags:
gke 0:62a1c91a859a 84 * idle - 1 if the card is in an idle state/initialising
gke 0:62a1c91a859a 85 * cmd - 1 if an illegal command code was detected
gke 0:62a1c91a859a 86 *
gke 0:62a1c91a859a 87 * +-------------------------------------------------+
gke 0:62a1c91a859a 88 * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle |
gke 0:62a1c91a859a 89 * +-------------------------------------------------+
gke 0:62a1c91a859a 90 *
gke 0:62a1c91a859a 91 * R1b is the same, except it is followed by a busy signal (zeros) until
gke 0:62a1c91a859a 92 * the first non-zero byte when it is ready again.
gke 0:62a1c91a859a 93 *
gke 0:62a1c91a859a 94 * Data Response Token
gke 0:62a1c91a859a 95 * -------------------
gke 0:62a1c91a859a 96 * Every data block written to the card is acknowledged by a byte
gke 0:62a1c91a859a 97 * response token
gke 0:62a1c91a859a 98 *
gke 0:62a1c91a859a 99 * +----------------------+
gke 0:62a1c91a859a 100 * | xxx | 0 | status | 1 |
gke 0:62a1c91a859a 101 * +----------------------+
gke 0:62a1c91a859a 102 * 010 - OK!
gke 0:62a1c91a859a 103 * 101 - CRC Error
gke 0:62a1c91a859a 104 * 110 - Write Error
gke 0:62a1c91a859a 105 *
gke 0:62a1c91a859a 106 * Single Block Read and Write
gke 0:62a1c91a859a 107 * ---------------------------
gke 0:62a1c91a859a 108 *
gke 0:62a1c91a859a 109 * Block transfers have a byte header, followed by the data, followed
gke 0:62a1c91a859a 110 * by a 16-bit CRC. In our case, the data will always be 512 bytes.
gke 0:62a1c91a859a 111 *
gke 0:62a1c91a859a 112 * +------+---------+---------+- - - -+---------+-----------+----------+
gke 0:62a1c91a859a 113 * | 0xFE | data[0] | data[1] | | data[n] | crc[15:8] | crc[7:0] |
gke 0:62a1c91a859a 114 * +------+---------+---------+- - - -+---------+-----------+----------+
gke 0:62a1c91a859a 115 */
gke 0:62a1c91a859a 116
gke 0:62a1c91a859a 117 #include "SDFileSystem.h"
gke 0:62a1c91a859a 118
gke 0:62a1c91a859a 119 #define SD_COMMAND_TIMEOUT 5000
gke 0:62a1c91a859a 120
gke 0:62a1c91a859a 121 SDFileSystem::SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name) :
gke 0:62a1c91a859a 122 FATFileSystem(name), _spi(mosi, miso, sclk), _cs(cs) {
gke 0:62a1c91a859a 123 _cs = 1;
gke 0:62a1c91a859a 124 }
gke 0:62a1c91a859a 125
gke 0:62a1c91a859a 126 #define R1_IDLE_STATE (1 << 0)
gke 0:62a1c91a859a 127 #define R1_ERASE_RESET (1 << 1)
gke 0:62a1c91a859a 128 #define R1_ILLEGAL_COMMAND (1 << 2)
gke 0:62a1c91a859a 129 #define R1_COM_CRC_ERROR (1 << 3)
gke 0:62a1c91a859a 130 #define R1_ERASE_SEQUENCE_ERROR (1 << 4)
gke 0:62a1c91a859a 131 #define R1_ADDRESS_ERROR (1 << 5)
gke 0:62a1c91a859a 132 #define R1_PARAMETER_ERROR (1 << 6)
gke 0:62a1c91a859a 133
gke 0:62a1c91a859a 134 // Types
gke 0:62a1c91a859a 135 // - v1.x Standard Capacity
gke 0:62a1c91a859a 136 // - v2.x Standard Capacity
gke 0:62a1c91a859a 137 // - v2.x High Capacity
gke 0:62a1c91a859a 138 // - Not recognised as an SD Card
gke 0:62a1c91a859a 139
gke 0:62a1c91a859a 140 #define SDCARD_FAIL 0
gke 0:62a1c91a859a 141 #define SDCARD_V1 1
gke 0:62a1c91a859a 142 #define SDCARD_V2 2
gke 0:62a1c91a859a 143 #define SDCARD_V2HC 3
gke 0:62a1c91a859a 144
gke 0:62a1c91a859a 145 int SDFileSystem::initialise_card() {
gke 0:62a1c91a859a 146 // Set to 100kHz for initialisation, and clock card with cs = 1
gke 0:62a1c91a859a 147 _spi.frequency(100000);
gke 0:62a1c91a859a 148 _cs = 1;
gke 0:62a1c91a859a 149 for(int i=0; i<16; i++) {
gke 0:62a1c91a859a 150 _spi.write(0xFF);
gke 0:62a1c91a859a 151 }
gke 0:62a1c91a859a 152
gke 0:62a1c91a859a 153 // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
gke 0:62a1c91a859a 154 if(_cmd(0, 0) != R1_IDLE_STATE) {
gke 0:62a1c91a859a 155 fprintf(stderr, "No disk, or could not put SD card in to SPI idle state\n");
gke 0:62a1c91a859a 156 return SDCARD_FAIL;
gke 0:62a1c91a859a 157 }
gke 0:62a1c91a859a 158
gke 0:62a1c91a859a 159 // send CMD8 to determine whther it is ver 2.x
gke 0:62a1c91a859a 160 int r = _cmd8();
gke 0:62a1c91a859a 161 if(r == R1_IDLE_STATE) {
gke 0:62a1c91a859a 162 return initialise_card_v2();
gke 0:62a1c91a859a 163 } else if(r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) {
gke 0:62a1c91a859a 164 return initialise_card_v1();
gke 0:62a1c91a859a 165 } else {
gke 0:62a1c91a859a 166 fprintf(stderr, "Not in idle state after sending CMD8 (not an SD card?)\n");
gke 0:62a1c91a859a 167 return SDCARD_FAIL;
gke 0:62a1c91a859a 168 }
gke 0:62a1c91a859a 169 }
gke 0:62a1c91a859a 170
gke 0:62a1c91a859a 171 int SDFileSystem::initialise_card_v1() {
gke 0:62a1c91a859a 172 for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
gke 0:62a1c91a859a 173 _cmd(55, 0);
gke 0:62a1c91a859a 174 if(_cmd(41, 0) == 0) {
gke 0:62a1c91a859a 175 return SDCARD_V1;
gke 0:62a1c91a859a 176 }
gke 0:62a1c91a859a 177 }
gke 0:62a1c91a859a 178
gke 0:62a1c91a859a 179 fprintf(stderr, "Timeout waiting for v1.x card\n");
gke 0:62a1c91a859a 180 return SDCARD_FAIL;
gke 0:62a1c91a859a 181 }
gke 0:62a1c91a859a 182
gke 0:62a1c91a859a 183 int SDFileSystem::initialise_card_v2() {
gke 0:62a1c91a859a 184
gke 0:62a1c91a859a 185 for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
gke 0:62a1c91a859a 186 _cmd(55, 0);
gke 0:62a1c91a859a 187 if(_cmd(41, 0) == 0) {
gke 0:62a1c91a859a 188 _cmd58();
gke 0:62a1c91a859a 189 return SDCARD_V2;
gke 0:62a1c91a859a 190 }
gke 0:62a1c91a859a 191 }
gke 0:62a1c91a859a 192
gke 0:62a1c91a859a 193 fprintf(stderr, "Timeout waiting for v2.x card\n");
gke 0:62a1c91a859a 194 return SDCARD_FAIL;
gke 0:62a1c91a859a 195 }
gke 0:62a1c91a859a 196
gke 0:62a1c91a859a 197 int SDFileSystem::disk_initialize() {
gke 0:62a1c91a859a 198
gke 0:62a1c91a859a 199 int i = initialise_card();
gke 0:62a1c91a859a 200 // printf("init card = %d\n", i);
gke 0:62a1c91a859a 201 // printf("OK\n");
gke 0:62a1c91a859a 202
gke 0:62a1c91a859a 203 _sectors = _sd_sectors();
gke 0:62a1c91a859a 204
gke 0:62a1c91a859a 205 // Set block length to 512 (CMD16)
gke 0:62a1c91a859a 206 if(_cmd(16, 512) != 0) {
gke 0:62a1c91a859a 207 fprintf(stderr, "Set 512-byte block timed out\n");
gke 0:62a1c91a859a 208 return 1;
gke 0:62a1c91a859a 209 }
gke 0:62a1c91a859a 210
gke 0:62a1c91a859a 211 _spi.frequency(1000000); // Set to 1MHz for data transfer
gke 0:62a1c91a859a 212 return 0;
gke 0:62a1c91a859a 213 }
gke 0:62a1c91a859a 214
gke 0:62a1c91a859a 215 int SDFileSystem::disk_write(const char *buffer, int block_number) {
gke 0:62a1c91a859a 216 // set write address for single block (CMD24)
gke 0:62a1c91a859a 217 if(_cmd(24, block_number * 512) != 0) {
gke 0:62a1c91a859a 218 return 1;
gke 0:62a1c91a859a 219 }
gke 0:62a1c91a859a 220
gke 0:62a1c91a859a 221 // send the data block
gke 0:62a1c91a859a 222 _write(buffer, 512);
gke 0:62a1c91a859a 223 return 0;
gke 0:62a1c91a859a 224 }
gke 0:62a1c91a859a 225
gke 0:62a1c91a859a 226 int SDFileSystem::disk_read(char *buffer, int block_number) {
gke 0:62a1c91a859a 227 // set read address for single block (CMD17)
gke 0:62a1c91a859a 228 if(_cmd(17, block_number * 512) != 0) {
gke 0:62a1c91a859a 229 return 1;
gke 0:62a1c91a859a 230 }
gke 0:62a1c91a859a 231
gke 0:62a1c91a859a 232 // receive the data
gke 0:62a1c91a859a 233 _read(buffer, 512);
gke 0:62a1c91a859a 234 return 0;
gke 0:62a1c91a859a 235 }
gke 0:62a1c91a859a 236
gke 0:62a1c91a859a 237 int SDFileSystem::disk_status() { return 0; }
gke 0:62a1c91a859a 238 int SDFileSystem::disk_sync() { return 0; }
gke 0:62a1c91a859a 239 int SDFileSystem::disk_sectors() { return _sectors; }
gke 0:62a1c91a859a 240
gke 0:62a1c91a859a 241 // PRIVATE FUNCTIONS
gke 0:62a1c91a859a 242
gke 0:62a1c91a859a 243 int SDFileSystem::_cmd(int cmd, int arg) {
gke 0:62a1c91a859a 244 _cs = 0;
gke 0:62a1c91a859a 245
gke 0:62a1c91a859a 246 // send a command
gke 0:62a1c91a859a 247 _spi.write(0x40 | cmd);
gke 0:62a1c91a859a 248 _spi.write(arg >> 24);
gke 0:62a1c91a859a 249 _spi.write(arg >> 16);
gke 0:62a1c91a859a 250 _spi.write(arg >> 8);
gke 0:62a1c91a859a 251 _spi.write(arg >> 0);
gke 0:62a1c91a859a 252 _spi.write(0x95);
gke 0:62a1c91a859a 253
gke 0:62a1c91a859a 254 // wait for the repsonse (response[7] == 0)
gke 0:62a1c91a859a 255 for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
gke 0:62a1c91a859a 256 int response = _spi.write(0xFF);
gke 0:62a1c91a859a 257 if(!(response & 0x80)) {
gke 0:62a1c91a859a 258 _cs = 1;
gke 0:62a1c91a859a 259 _spi.write(0xFF);
gke 0:62a1c91a859a 260 return response;
gke 0:62a1c91a859a 261 }
gke 0:62a1c91a859a 262 }
gke 0:62a1c91a859a 263 _cs = 1;
gke 0:62a1c91a859a 264 _spi.write(0xFF);
gke 0:62a1c91a859a 265 return -1; // timeout
gke 0:62a1c91a859a 266 }
gke 0:62a1c91a859a 267 int SDFileSystem::_cmdx(int cmd, int arg) {
gke 0:62a1c91a859a 268 _cs = 0;
gke 0:62a1c91a859a 269
gke 0:62a1c91a859a 270 // send a command
gke 0:62a1c91a859a 271 _spi.write(0x40 | cmd);
gke 0:62a1c91a859a 272 _spi.write(arg >> 24);
gke 0:62a1c91a859a 273 _spi.write(arg >> 16);
gke 0:62a1c91a859a 274 _spi.write(arg >> 8);
gke 0:62a1c91a859a 275 _spi.write(arg >> 0);
gke 0:62a1c91a859a 276 _spi.write(0x95);
gke 0:62a1c91a859a 277
gke 0:62a1c91a859a 278 // wait for the repsonse (response[7] == 0)
gke 0:62a1c91a859a 279 for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
gke 0:62a1c91a859a 280 int response = _spi.write(0xFF);
gke 0:62a1c91a859a 281 if(!(response & 0x80)) {
gke 0:62a1c91a859a 282 return response;
gke 0:62a1c91a859a 283 }
gke 0:62a1c91a859a 284 }
gke 0:62a1c91a859a 285 _cs = 1;
gke 0:62a1c91a859a 286 _spi.write(0xFF);
gke 0:62a1c91a859a 287 return -1; // timeout
gke 0:62a1c91a859a 288 }
gke 0:62a1c91a859a 289
gke 0:62a1c91a859a 290
gke 0:62a1c91a859a 291 int SDFileSystem::_cmd58() {
gke 0:62a1c91a859a 292 _cs = 0;
gke 0:62a1c91a859a 293 int arg = 0;
gke 0:62a1c91a859a 294
gke 0:62a1c91a859a 295 // send a command
gke 0:62a1c91a859a 296 _spi.write(0x40 | 58);
gke 0:62a1c91a859a 297 _spi.write(arg >> 24);
gke 0:62a1c91a859a 298 _spi.write(arg >> 16);
gke 0:62a1c91a859a 299 _spi.write(arg >> 8);
gke 0:62a1c91a859a 300 _spi.write(arg >> 0);
gke 0:62a1c91a859a 301 _spi.write(0x95);
gke 0:62a1c91a859a 302
gke 0:62a1c91a859a 303 // wait for the repsonse (response[7] == 0)
gke 0:62a1c91a859a 304 for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
gke 0:62a1c91a859a 305 int response = _spi.write(0xFF);
gke 0:62a1c91a859a 306 if(!(response & 0x80)) {
gke 0:62a1c91a859a 307 int ocr = _spi.write(0xFF) << 24;
gke 0:62a1c91a859a 308 ocr |= _spi.write(0xFF) << 16;
gke 0:62a1c91a859a 309 ocr |= _spi.write(0xFF) << 8;
gke 0:62a1c91a859a 310 ocr |= _spi.write(0xFF) << 0;
gke 0:62a1c91a859a 311 // printf("OCR = 0x%08X\n", ocr);
gke 0:62a1c91a859a 312 _cs = 1;
gke 0:62a1c91a859a 313 _spi.write(0xFF);
gke 0:62a1c91a859a 314 return response;
gke 0:62a1c91a859a 315 }
gke 0:62a1c91a859a 316 }
gke 0:62a1c91a859a 317 _cs = 1;
gke 0:62a1c91a859a 318 _spi.write(0xFF);
gke 0:62a1c91a859a 319 return -1; // timeout
gke 0:62a1c91a859a 320 }
gke 0:62a1c91a859a 321
gke 0:62a1c91a859a 322 int SDFileSystem::_cmd8() {
gke 0:62a1c91a859a 323 _cs = 0;
gke 0:62a1c91a859a 324
gke 0:62a1c91a859a 325 // send a command
gke 0:62a1c91a859a 326 _spi.write(0x40 | 8); // CMD8
gke 0:62a1c91a859a 327 _spi.write(0x00); // reserved
gke 0:62a1c91a859a 328 _spi.write(0x00); // reserved
gke 0:62a1c91a859a 329 _spi.write(0x01); // 3.3v
gke 0:62a1c91a859a 330 _spi.write(0xAA); // check pattern
gke 0:62a1c91a859a 331 _spi.write(0x87); // crc
gke 0:62a1c91a859a 332
gke 0:62a1c91a859a 333 // wait for the repsonse (response[7] == 0)
gke 0:62a1c91a859a 334 for(int i=0; i<SD_COMMAND_TIMEOUT * 1000; i++) {
gke 0:62a1c91a859a 335 char response[5];
gke 0:62a1c91a859a 336 response[0] = _spi.write(0xFF);
gke 0:62a1c91a859a 337 if(!(response[0] & 0x80)) {
gke 0:62a1c91a859a 338 for(int j=1; j<5; j++) {
gke 0:62a1c91a859a 339 response[i] = _spi.write(0xFF);
gke 0:62a1c91a859a 340 }
gke 0:62a1c91a859a 341 _cs = 1;
gke 0:62a1c91a859a 342 _spi.write(0xFF);
gke 0:62a1c91a859a 343 return response[0];
gke 0:62a1c91a859a 344 }
gke 0:62a1c91a859a 345 }
gke 0:62a1c91a859a 346 _cs = 1;
gke 0:62a1c91a859a 347 _spi.write(0xFF);
gke 0:62a1c91a859a 348 return -1; // timeout
gke 0:62a1c91a859a 349 }
gke 0:62a1c91a859a 350
gke 0:62a1c91a859a 351 int SDFileSystem::_read(char *buffer, int length) {
gke 0:62a1c91a859a 352 _cs = 0;
gke 0:62a1c91a859a 353
gke 0:62a1c91a859a 354 // read until start byte (0xFF)
gke 0:62a1c91a859a 355 while(_spi.write(0xFF) != 0xFE);
gke 0:62a1c91a859a 356
gke 0:62a1c91a859a 357 // read data
gke 0:62a1c91a859a 358 for(int i=0; i<length; i++) {
gke 0:62a1c91a859a 359 buffer[i] = _spi.write(0xFF);
gke 0:62a1c91a859a 360 }
gke 0:62a1c91a859a 361 _spi.write(0xFF); // checksum
gke 0:62a1c91a859a 362 _spi.write(0xFF);
gke 0:62a1c91a859a 363
gke 0:62a1c91a859a 364 _cs = 1;
gke 0:62a1c91a859a 365 _spi.write(0xFF);
gke 0:62a1c91a859a 366 return 0;
gke 0:62a1c91a859a 367 }
gke 0:62a1c91a859a 368
gke 0:62a1c91a859a 369 int SDFileSystem::_write(const char *buffer, int length) {
gke 0:62a1c91a859a 370 _cs = 0;
gke 0:62a1c91a859a 371
gke 0:62a1c91a859a 372 // indicate start of block
gke 0:62a1c91a859a 373 _spi.write(0xFE);
gke 0:62a1c91a859a 374
gke 0:62a1c91a859a 375 // write the data
gke 0:62a1c91a859a 376 for(int i=0; i<length; i++) {
gke 0:62a1c91a859a 377 _spi.write(buffer[i]);
gke 0:62a1c91a859a 378 }
gke 0:62a1c91a859a 379
gke 0:62a1c91a859a 380 // write the checksum
gke 0:62a1c91a859a 381 _spi.write(0xFF);
gke 0:62a1c91a859a 382 _spi.write(0xFF);
gke 0:62a1c91a859a 383
gke 0:62a1c91a859a 384 // check the repsonse token
gke 0:62a1c91a859a 385 if((_spi.write(0xFF) & 0x1F) != 0x05) {
gke 0:62a1c91a859a 386 _cs = 1;
gke 0:62a1c91a859a 387 _spi.write(0xFF);
gke 0:62a1c91a859a 388 return 1;
gke 0:62a1c91a859a 389 }
gke 0:62a1c91a859a 390
gke 0:62a1c91a859a 391 // wait for write to finish
gke 0:62a1c91a859a 392 while(_spi.write(0xFF) == 0);
gke 0:62a1c91a859a 393
gke 0:62a1c91a859a 394 _cs = 1;
gke 0:62a1c91a859a 395 _spi.write(0xFF);
gke 0:62a1c91a859a 396 return 0;
gke 0:62a1c91a859a 397 }
gke 0:62a1c91a859a 398
gke 0:62a1c91a859a 399 static int ext_bits(char *data, int msb, int lsb) {
gke 0:62a1c91a859a 400 int bits = 0;
gke 0:62a1c91a859a 401 int size = 1 + msb - lsb;
gke 0:62a1c91a859a 402 for(int i=0; i<size; i++) {
gke 0:62a1c91a859a 403 int position = lsb + i;
gke 0:62a1c91a859a 404 int byte = 15 - (position >> 3);
gke 0:62a1c91a859a 405 int bit = position & 0x7;
gke 0:62a1c91a859a 406 int value = (data[byte] >> bit) & 1;
gke 0:62a1c91a859a 407 bits |= value << i;
gke 0:62a1c91a859a 408 }
gke 0:62a1c91a859a 409 return bits;
gke 0:62a1c91a859a 410 }
gke 0:62a1c91a859a 411
gke 0:62a1c91a859a 412 int SDFileSystem::_sd_sectors() {
gke 0:62a1c91a859a 413
gke 0:62a1c91a859a 414 // CMD9, Response R2 (R1 byte + 16-byte block read)
gke 0:62a1c91a859a 415 if(_cmdx(9, 0) != 0) {
gke 0:62a1c91a859a 416 fprintf(stderr, "Didn't get a response from the disk\n");
gke 0:62a1c91a859a 417 return 0;
gke 0:62a1c91a859a 418 }
gke 0:62a1c91a859a 419
gke 0:62a1c91a859a 420 char csd[16];
gke 0:62a1c91a859a 421 if(_read(csd, 16) != 0) {
gke 0:62a1c91a859a 422 fprintf(stderr, "Couldn't read csd response from disk\n");
gke 0:62a1c91a859a 423 return 0;
gke 0:62a1c91a859a 424 }
gke 0:62a1c91a859a 425
gke 0:62a1c91a859a 426 // csd_structure : csd[127:126]
gke 0:62a1c91a859a 427 // c_size : csd[73:62]
gke 0:62a1c91a859a 428 // c_size_mult : csd[49:47]
gke 0:62a1c91a859a 429 // read_bl_len : csd[83:80] - the *maximum* read block length
gke 0:62a1c91a859a 430
gke 0:62a1c91a859a 431 int csd_structure = ext_bits(csd, 127, 126);
gke 0:62a1c91a859a 432 int c_size = ext_bits(csd, 73, 62);
gke 0:62a1c91a859a 433 int c_size_mult = ext_bits(csd, 49, 47);
gke 0:62a1c91a859a 434 int read_bl_len = ext_bits(csd, 83, 80);
gke 0:62a1c91a859a 435
gke 0:62a1c91a859a 436 // printf("CSD_STRUCT = %d\n", csd_structure);
gke 0:62a1c91a859a 437
gke 0:62a1c91a859a 438 if(csd_structure != 0) {
gke 0:62a1c91a859a 439 fprintf(stderr, "This disk tastes funny! I only know about type 0 CSD structures\n");
gke 0:62a1c91a859a 440 return 0;
gke 0:62a1c91a859a 441 }
gke 0:62a1c91a859a 442
gke 0:62a1c91a859a 443 // memory capacity = BLOCKNR * BLOCK_LEN
gke 0:62a1c91a859a 444 // where
gke 0:62a1c91a859a 445 // BLOCKNR = (C_SIZE+1) * MULT
gke 0:62a1c91a859a 446 // MULT = 2^(C_SIZE_MULT+2) (C_SIZE_MULT < 8)
gke 0:62a1c91a859a 447 // BLOCK_LEN = 2^READ_BL_LEN, (READ_BL_LEN < 12)
gke 0:62a1c91a859a 448
gke 0:62a1c91a859a 449 int block_len = 1 << read_bl_len;
gke 0:62a1c91a859a 450 int mult = 1 << (c_size_mult + 2);
gke 0:62a1c91a859a 451 int blocknr = (c_size + 1) * mult;
gke 0:62a1c91a859a 452 int capacity = blocknr * block_len;
gke 0:62a1c91a859a 453
gke 0:62a1c91a859a 454 int blocks = capacity / 512;
gke 0:62a1c91a859a 455
gke 0:62a1c91a859a 456 return blocks;
gke 0:62a1c91a859a 457 }