root / arduino-1.0 / libraries / SD / utility / Sd2Card.cpp @ 58d82c77
History | View | Annotate | Download (19.2 KB)
1 |
/* Arduino Sd2Card Library
|
---|---|
2 |
* Copyright (C) 2009 by William Greiman
|
3 |
*
|
4 |
* This file is part of the Arduino Sd2Card Library
|
5 |
*
|
6 |
* This Library is free software: you can redistribute it and/or modify
|
7 |
* it under the terms of the GNU General Public License as published by
|
8 |
* the Free Software Foundation, either version 3 of the License, or
|
9 |
* (at your option) any later version.
|
10 |
*
|
11 |
* This Library is distributed in the hope that it will be useful,
|
12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
14 |
* GNU General Public License for more details.
|
15 |
*
|
16 |
* You should have received a copy of the GNU General Public License
|
17 |
* along with the Arduino Sd2Card Library. If not, see
|
18 |
* <http://www.gnu.org/licenses/>.
|
19 |
*/
|
20 |
#include <Arduino.h> |
21 |
#include "Sd2Card.h" |
22 |
//------------------------------------------------------------------------------
|
23 |
#ifndef SOFTWARE_SPI
|
24 |
// functions for hardware SPI
|
25 |
/** Send a byte to the card */
|
26 |
static void spiSend(uint8_t b) { |
27 |
SPDR = b; |
28 |
while (!(SPSR & (1 << SPIF))); |
29 |
} |
30 |
/** Receive a byte from the card */
|
31 |
static uint8_t spiRec(void) { |
32 |
spiSend(0XFF);
|
33 |
return SPDR;
|
34 |
} |
35 |
#else // SOFTWARE_SPI |
36 |
//------------------------------------------------------------------------------
|
37 |
/** nop to tune soft SPI timing */
|
38 |
#define nop asm volatile ("nop\n\t") |
39 |
//------------------------------------------------------------------------------
|
40 |
/** Soft SPI receive */
|
41 |
uint8_t spiRec(void) {
|
42 |
uint8_t data = 0;
|
43 |
// no interrupts during byte receive - about 8 us
|
44 |
cli(); |
45 |
// output pin high - like sending 0XFF
|
46 |
fastDigitalWrite(SPI_MOSI_PIN, HIGH); |
47 |
|
48 |
for (uint8_t i = 0; i < 8; i++) { |
49 |
fastDigitalWrite(SPI_SCK_PIN, HIGH); |
50 |
|
51 |
// adjust so SCK is nice
|
52 |
nop; |
53 |
nop; |
54 |
|
55 |
data <<= 1;
|
56 |
|
57 |
if (fastDigitalRead(SPI_MISO_PIN)) data |= 1; |
58 |
|
59 |
fastDigitalWrite(SPI_SCK_PIN, LOW); |
60 |
} |
61 |
// enable interrupts
|
62 |
sei(); |
63 |
return data;
|
64 |
} |
65 |
//------------------------------------------------------------------------------
|
66 |
/** Soft SPI send */
|
67 |
void spiSend(uint8_t data) {
|
68 |
// no interrupts during byte send - about 8 us
|
69 |
cli(); |
70 |
for (uint8_t i = 0; i < 8; i++) { |
71 |
fastDigitalWrite(SPI_SCK_PIN, LOW); |
72 |
|
73 |
fastDigitalWrite(SPI_MOSI_PIN, data & 0X80);
|
74 |
|
75 |
data <<= 1;
|
76 |
|
77 |
fastDigitalWrite(SPI_SCK_PIN, HIGH); |
78 |
} |
79 |
// hold SCK high for a few ns
|
80 |
nop; |
81 |
nop; |
82 |
nop; |
83 |
nop; |
84 |
|
85 |
fastDigitalWrite(SPI_SCK_PIN, LOW); |
86 |
// enable interrupts
|
87 |
sei(); |
88 |
} |
89 |
#endif // SOFTWARE_SPI |
90 |
//------------------------------------------------------------------------------
|
91 |
// send command and return error code. Return zero for OK
|
92 |
uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) { |
93 |
// end read if in partialBlockRead mode
|
94 |
readEnd(); |
95 |
|
96 |
// select card
|
97 |
chipSelectLow(); |
98 |
|
99 |
// wait up to 300 ms if busy
|
100 |
waitNotBusy(300);
|
101 |
|
102 |
// send command
|
103 |
spiSend(cmd | 0x40);
|
104 |
|
105 |
// send argument
|
106 |
for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s); |
107 |
|
108 |
// send CRC
|
109 |
uint8_t crc = 0XFF;
|
110 |
if (cmd == CMD0) crc = 0X95; // correct crc for CMD0 with arg 0 |
111 |
if (cmd == CMD8) crc = 0X87; // correct crc for CMD8 with arg 0X1AA |
112 |
spiSend(crc); |
113 |
|
114 |
// wait for response
|
115 |
for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++); |
116 |
return status_;
|
117 |
} |
118 |
//------------------------------------------------------------------------------
|
119 |
/**
|
120 |
* Determine the size of an SD flash memory card.
|
121 |
*
|
122 |
* \return The number of 512 byte data blocks in the card
|
123 |
* or zero if an error occurs.
|
124 |
*/
|
125 |
uint32_t Sd2Card::cardSize(void) {
|
126 |
csd_t csd; |
127 |
if (!readCSD(&csd)) return 0; |
128 |
if (csd.v1.csd_ver == 0) { |
129 |
uint8_t read_bl_len = csd.v1.read_bl_len; |
130 |
uint16_t c_size = (csd.v1.c_size_high << 10)
|
131 |
| (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;
|
132 |
uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)
|
133 |
| csd.v1.c_size_mult_low; |
134 |
return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7); |
135 |
} else if (csd.v2.csd_ver == 1) { |
136 |
uint32_t c_size = ((uint32_t)csd.v2.c_size_high << 16)
|
137 |
| (csd.v2.c_size_mid << 8) | csd.v2.c_size_low;
|
138 |
return (c_size + 1) << 10; |
139 |
} else {
|
140 |
error(SD_CARD_ERROR_BAD_CSD); |
141 |
return 0; |
142 |
} |
143 |
} |
144 |
//------------------------------------------------------------------------------
|
145 |
void Sd2Card::chipSelectHigh(void) { |
146 |
digitalWrite(chipSelectPin_, HIGH); |
147 |
} |
148 |
//------------------------------------------------------------------------------
|
149 |
void Sd2Card::chipSelectLow(void) { |
150 |
digitalWrite(chipSelectPin_, LOW); |
151 |
} |
152 |
//------------------------------------------------------------------------------
|
153 |
/** Erase a range of blocks.
|
154 |
*
|
155 |
* \param[in] firstBlock The address of the first block in the range.
|
156 |
* \param[in] lastBlock The address of the last block in the range.
|
157 |
*
|
158 |
* \note This function requests the SD card to do a flash erase for a
|
159 |
* range of blocks. The data on the card after an erase operation is
|
160 |
* either 0 or 1, depends on the card vendor. The card must support
|
161 |
* single block erase.
|
162 |
*
|
163 |
* \return The value one, true, is returned for success and
|
164 |
* the value zero, false, is returned for failure.
|
165 |
*/
|
166 |
uint8_t Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) { |
167 |
if (!eraseSingleBlockEnable()) {
|
168 |
error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK); |
169 |
goto fail;
|
170 |
} |
171 |
if (type_ != SD_CARD_TYPE_SDHC) {
|
172 |
firstBlock <<= 9;
|
173 |
lastBlock <<= 9;
|
174 |
} |
175 |
if (cardCommand(CMD32, firstBlock)
|
176 |
|| cardCommand(CMD33, lastBlock) |
177 |
|| cardCommand(CMD38, 0)) {
|
178 |
error(SD_CARD_ERROR_ERASE); |
179 |
goto fail;
|
180 |
} |
181 |
if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
|
182 |
error(SD_CARD_ERROR_ERASE_TIMEOUT); |
183 |
goto fail;
|
184 |
} |
185 |
chipSelectHigh(); |
186 |
return true; |
187 |
|
188 |
fail:
|
189 |
chipSelectHigh(); |
190 |
return false; |
191 |
} |
192 |
//------------------------------------------------------------------------------
|
193 |
/** Determine if card supports single block erase.
|
194 |
*
|
195 |
* \return The value one, true, is returned if single block erase is supported.
|
196 |
* The value zero, false, is returned if single block erase is not supported.
|
197 |
*/
|
198 |
uint8_t Sd2Card::eraseSingleBlockEnable(void) {
|
199 |
csd_t csd; |
200 |
return readCSD(&csd) ? csd.v1.erase_blk_en : 0; |
201 |
} |
202 |
//------------------------------------------------------------------------------
|
203 |
/**
|
204 |
* Initialize an SD flash memory card.
|
205 |
*
|
206 |
* \param[in] sckRateID SPI clock rate selector. See setSckRate().
|
207 |
* \param[in] chipSelectPin SD chip select pin number.
|
208 |
*
|
209 |
* \return The value one, true, is returned for success and
|
210 |
* the value zero, false, is returned for failure. The reason for failure
|
211 |
* can be determined by calling errorCode() and errorData().
|
212 |
*/
|
213 |
uint8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) { |
214 |
errorCode_ = inBlock_ = partialBlockRead_ = type_ = 0;
|
215 |
chipSelectPin_ = chipSelectPin; |
216 |
// 16-bit init start time allows over a minute
|
217 |
uint16_t t0 = (uint16_t)millis(); |
218 |
uint32_t arg; |
219 |
|
220 |
// set pin modes
|
221 |
pinMode(chipSelectPin_, OUTPUT); |
222 |
chipSelectHigh(); |
223 |
pinMode(SPI_MISO_PIN, INPUT); |
224 |
pinMode(SPI_MOSI_PIN, OUTPUT); |
225 |
pinMode(SPI_SCK_PIN, OUTPUT); |
226 |
|
227 |
#ifndef SOFTWARE_SPI
|
228 |
// SS must be in output mode even it is not chip select
|
229 |
pinMode(SS_PIN, OUTPUT); |
230 |
digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin
|
231 |
// Enable SPI, Master, clock rate f_osc/128
|
232 |
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0); |
233 |
// clear double speed
|
234 |
SPSR &= ~(1 << SPI2X);
|
235 |
#endif // SOFTWARE_SPI |
236 |
|
237 |
// must supply min of 74 clock cycles with CS high.
|
238 |
for (uint8_t i = 0; i < 10; i++) spiSend(0XFF); |
239 |
|
240 |
chipSelectLow(); |
241 |
|
242 |
// command to go idle in SPI mode
|
243 |
while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) { |
244 |
if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
|
245 |
error(SD_CARD_ERROR_CMD0); |
246 |
goto fail;
|
247 |
} |
248 |
} |
249 |
// check SD version
|
250 |
if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) { |
251 |
type(SD_CARD_TYPE_SD1); |
252 |
} else {
|
253 |
// only need last byte of r7 response
|
254 |
for (uint8_t i = 0; i < 4; i++) status_ = spiRec(); |
255 |
if (status_ != 0XAA) { |
256 |
error(SD_CARD_ERROR_CMD8); |
257 |
goto fail;
|
258 |
} |
259 |
type(SD_CARD_TYPE_SD2); |
260 |
} |
261 |
// initialize card and send host supports SDHC if SD2
|
262 |
arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0; |
263 |
|
264 |
while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
|
265 |
// check for timeout
|
266 |
if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
|
267 |
error(SD_CARD_ERROR_ACMD41); |
268 |
goto fail;
|
269 |
} |
270 |
} |
271 |
// if SD2 read OCR register to check for SDHC card
|
272 |
if (type() == SD_CARD_TYPE_SD2) {
|
273 |
if (cardCommand(CMD58, 0)) { |
274 |
error(SD_CARD_ERROR_CMD58); |
275 |
goto fail;
|
276 |
} |
277 |
if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC); |
278 |
// discard rest of ocr - contains allowed voltage range
|
279 |
for (uint8_t i = 0; i < 3; i++) spiRec(); |
280 |
} |
281 |
chipSelectHigh(); |
282 |
|
283 |
#ifndef SOFTWARE_SPI
|
284 |
return setSckRate(sckRateID);
|
285 |
#else // SOFTWARE_SPI |
286 |
return true; |
287 |
#endif // SOFTWARE_SPI |
288 |
|
289 |
fail:
|
290 |
chipSelectHigh(); |
291 |
return false; |
292 |
} |
293 |
//------------------------------------------------------------------------------
|
294 |
/**
|
295 |
* Enable or disable partial block reads.
|
296 |
*
|
297 |
* Enabling partial block reads improves performance by allowing a block
|
298 |
* to be read over the SPI bus as several sub-blocks. Errors may occur
|
299 |
* if the time between reads is too long since the SD card may timeout.
|
300 |
* The SPI SS line will be held low until the entire block is read or
|
301 |
* readEnd() is called.
|
302 |
*
|
303 |
* Use this for applications like the Adafruit Wave Shield.
|
304 |
*
|
305 |
* \param[in] value The value TRUE (non-zero) or FALSE (zero).)
|
306 |
*/
|
307 |
void Sd2Card::partialBlockRead(uint8_t value) {
|
308 |
readEnd(); |
309 |
partialBlockRead_ = value; |
310 |
} |
311 |
//------------------------------------------------------------------------------
|
312 |
/**
|
313 |
* Read a 512 byte block from an SD card device.
|
314 |
*
|
315 |
* \param[in] block Logical block to be read.
|
316 |
* \param[out] dst Pointer to the location that will receive the data.
|
317 |
|
318 |
* \return The value one, true, is returned for success and
|
319 |
* the value zero, false, is returned for failure.
|
320 |
*/
|
321 |
uint8_t Sd2Card::readBlock(uint32_t block, uint8_t* dst) { |
322 |
return readData(block, 0, 512, dst); |
323 |
} |
324 |
//------------------------------------------------------------------------------
|
325 |
/**
|
326 |
* Read part of a 512 byte block from an SD card.
|
327 |
*
|
328 |
* \param[in] block Logical block to be read.
|
329 |
* \param[in] offset Number of bytes to skip at start of block
|
330 |
* \param[out] dst Pointer to the location that will receive the data.
|
331 |
* \param[in] count Number of bytes to read
|
332 |
* \return The value one, true, is returned for success and
|
333 |
* the value zero, false, is returned for failure.
|
334 |
*/
|
335 |
uint8_t Sd2Card::readData(uint32_t block, |
336 |
uint16_t offset, uint16_t count, uint8_t* dst) { |
337 |
uint16_t n; |
338 |
if (count == 0) return true; |
339 |
if ((count + offset) > 512) { |
340 |
goto fail;
|
341 |
} |
342 |
if (!inBlock_ || block != block_ || offset < offset_) {
|
343 |
block_ = block; |
344 |
// use address if not SDHC card
|
345 |
if (type()!= SD_CARD_TYPE_SDHC) block <<= 9; |
346 |
if (cardCommand(CMD17, block)) {
|
347 |
error(SD_CARD_ERROR_CMD17); |
348 |
goto fail;
|
349 |
} |
350 |
if (!waitStartBlock()) {
|
351 |
goto fail;
|
352 |
} |
353 |
offset_ = 0;
|
354 |
inBlock_ = 1;
|
355 |
} |
356 |
|
357 |
#ifdef OPTIMIZE_HARDWARE_SPI
|
358 |
// start first spi transfer
|
359 |
SPDR = 0XFF;
|
360 |
|
361 |
// skip data before offset
|
362 |
for (;offset_ < offset; offset_++) {
|
363 |
while (!(SPSR & (1 << SPIF))); |
364 |
SPDR = 0XFF;
|
365 |
} |
366 |
// transfer data
|
367 |
n = count - 1;
|
368 |
for (uint16_t i = 0; i < n; i++) { |
369 |
while (!(SPSR & (1 << SPIF))); |
370 |
dst[i] = SPDR; |
371 |
SPDR = 0XFF;
|
372 |
} |
373 |
// wait for last byte
|
374 |
while (!(SPSR & (1 << SPIF))); |
375 |
dst[n] = SPDR; |
376 |
|
377 |
#else // OPTIMIZE_HARDWARE_SPI |
378 |
|
379 |
// skip data before offset
|
380 |
for (;offset_ < offset; offset_++) {
|
381 |
spiRec(); |
382 |
} |
383 |
// transfer data
|
384 |
for (uint16_t i = 0; i < count; i++) { |
385 |
dst[i] = spiRec(); |
386 |
} |
387 |
#endif // OPTIMIZE_HARDWARE_SPI |
388 |
|
389 |
offset_ += count; |
390 |
if (!partialBlockRead_ || offset_ >= 512) { |
391 |
// read rest of data, checksum and set chip select high
|
392 |
readEnd(); |
393 |
} |
394 |
return true; |
395 |
|
396 |
fail:
|
397 |
chipSelectHigh(); |
398 |
return false; |
399 |
} |
400 |
//------------------------------------------------------------------------------
|
401 |
/** Skip remaining data in a block when in partial block read mode. */
|
402 |
void Sd2Card::readEnd(void) { |
403 |
if (inBlock_) {
|
404 |
// skip data and crc
|
405 |
#ifdef OPTIMIZE_HARDWARE_SPI
|
406 |
// optimize skip for hardware
|
407 |
SPDR = 0XFF;
|
408 |
while (offset_++ < 513) { |
409 |
while (!(SPSR & (1 << SPIF))); |
410 |
SPDR = 0XFF;
|
411 |
} |
412 |
// wait for last crc byte
|
413 |
while (!(SPSR & (1 << SPIF))); |
414 |
#else // OPTIMIZE_HARDWARE_SPI |
415 |
while (offset_++ < 514) spiRec(); |
416 |
#endif // OPTIMIZE_HARDWARE_SPI |
417 |
chipSelectHigh(); |
418 |
inBlock_ = 0;
|
419 |
} |
420 |
} |
421 |
//------------------------------------------------------------------------------
|
422 |
/** read CID or CSR register */
|
423 |
uint8_t Sd2Card::readRegister(uint8_t cmd, void* buf) {
|
424 |
uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
|
425 |
if (cardCommand(cmd, 0)) { |
426 |
error(SD_CARD_ERROR_READ_REG); |
427 |
goto fail;
|
428 |
} |
429 |
if (!waitStartBlock()) goto fail; |
430 |
// transfer data
|
431 |
for (uint16_t i = 0; i < 16; i++) dst[i] = spiRec(); |
432 |
spiRec(); // get first crc byte
|
433 |
spiRec(); // get second crc byte
|
434 |
chipSelectHigh(); |
435 |
return true; |
436 |
|
437 |
fail:
|
438 |
chipSelectHigh(); |
439 |
return false; |
440 |
} |
441 |
//------------------------------------------------------------------------------
|
442 |
/**
|
443 |
* Set the SPI clock rate.
|
444 |
*
|
445 |
* \param[in] sckRateID A value in the range [0, 6].
|
446 |
*
|
447 |
* The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
|
448 |
* SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
|
449 |
* for \a scsRateID = 6.
|
450 |
*
|
451 |
* \return The value one, true, is returned for success and the value zero,
|
452 |
* false, is returned for an invalid value of \a sckRateID.
|
453 |
*/
|
454 |
uint8_t Sd2Card::setSckRate(uint8_t sckRateID) { |
455 |
if (sckRateID > 6) { |
456 |
error(SD_CARD_ERROR_SCK_RATE); |
457 |
return false; |
458 |
} |
459 |
// see avr processor datasheet for SPI register bit definitions
|
460 |
if ((sckRateID & 1) || sckRateID == 6) { |
461 |
SPSR &= ~(1 << SPI2X);
|
462 |
} else {
|
463 |
SPSR |= (1 << SPI2X);
|
464 |
} |
465 |
SPCR &= ~((1 <<SPR1) | (1 << SPR0)); |
466 |
SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0) |
467 |
| (sckRateID & 2 ? (1 << SPR0) : 0); |
468 |
return true; |
469 |
} |
470 |
//------------------------------------------------------------------------------
|
471 |
// wait for card to go not busy
|
472 |
uint8_t Sd2Card::waitNotBusy(uint16_t timeoutMillis) { |
473 |
uint16_t t0 = millis(); |
474 |
do {
|
475 |
if (spiRec() == 0XFF) return true; |
476 |
} |
477 |
while (((uint16_t)millis() - t0) < timeoutMillis);
|
478 |
return false; |
479 |
} |
480 |
//------------------------------------------------------------------------------
|
481 |
/** Wait for start block token */
|
482 |
uint8_t Sd2Card::waitStartBlock(void) {
|
483 |
uint16_t t0 = millis(); |
484 |
while ((status_ = spiRec()) == 0XFF) { |
485 |
if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
|
486 |
error(SD_CARD_ERROR_READ_TIMEOUT); |
487 |
goto fail;
|
488 |
} |
489 |
} |
490 |
if (status_ != DATA_START_BLOCK) {
|
491 |
error(SD_CARD_ERROR_READ); |
492 |
goto fail;
|
493 |
} |
494 |
return true; |
495 |
|
496 |
fail:
|
497 |
chipSelectHigh(); |
498 |
return false; |
499 |
} |
500 |
//------------------------------------------------------------------------------
|
501 |
/**
|
502 |
* Writes a 512 byte block to an SD card.
|
503 |
*
|
504 |
* \param[in] blockNumber Logical block to be written.
|
505 |
* \param[in] src Pointer to the location of the data to be written.
|
506 |
* \return The value one, true, is returned for success and
|
507 |
* the value zero, false, is returned for failure.
|
508 |
*/
|
509 |
uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
|
510 |
#if SD_PROTECT_BLOCK_ZERO
|
511 |
// don't allow write to first block
|
512 |
if (blockNumber == 0) { |
513 |
error(SD_CARD_ERROR_WRITE_BLOCK_ZERO); |
514 |
goto fail;
|
515 |
} |
516 |
#endif // SD_PROTECT_BLOCK_ZERO |
517 |
|
518 |
// use address if not SDHC card
|
519 |
if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9; |
520 |
if (cardCommand(CMD24, blockNumber)) {
|
521 |
error(SD_CARD_ERROR_CMD24); |
522 |
goto fail;
|
523 |
} |
524 |
if (!writeData(DATA_START_BLOCK, src)) goto fail; |
525 |
|
526 |
// wait for flash programming to complete
|
527 |
if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
|
528 |
error(SD_CARD_ERROR_WRITE_TIMEOUT); |
529 |
goto fail;
|
530 |
} |
531 |
// response is r2 so get and check two bytes for nonzero
|
532 |
if (cardCommand(CMD13, 0) || spiRec()) { |
533 |
error(SD_CARD_ERROR_WRITE_PROGRAMMING); |
534 |
goto fail;
|
535 |
} |
536 |
chipSelectHigh(); |
537 |
return true; |
538 |
|
539 |
fail:
|
540 |
chipSelectHigh(); |
541 |
return false; |
542 |
} |
543 |
//------------------------------------------------------------------------------
|
544 |
/** Write one data block in a multiple block write sequence */
|
545 |
uint8_t Sd2Card::writeData(const uint8_t* src) {
|
546 |
// wait for previous write to finish
|
547 |
if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
|
548 |
error(SD_CARD_ERROR_WRITE_MULTIPLE); |
549 |
chipSelectHigh(); |
550 |
return false; |
551 |
} |
552 |
return writeData(WRITE_MULTIPLE_TOKEN, src);
|
553 |
} |
554 |
//------------------------------------------------------------------------------
|
555 |
// send one block of data for write block or write multiple blocks
|
556 |
uint8_t Sd2Card::writeData(uint8_t token, const uint8_t* src) {
|
557 |
#ifdef OPTIMIZE_HARDWARE_SPI
|
558 |
|
559 |
// send data - optimized loop
|
560 |
SPDR = token; |
561 |
|
562 |
// send two byte per iteration
|
563 |
for (uint16_t i = 0; i < 512; i += 2) { |
564 |
while (!(SPSR & (1 << SPIF))); |
565 |
SPDR = src[i]; |
566 |
while (!(SPSR & (1 << SPIF))); |
567 |
SPDR = src[i+1];
|
568 |
} |
569 |
|
570 |
// wait for last data byte
|
571 |
while (!(SPSR & (1 << SPIF))); |
572 |
|
573 |
#else // OPTIMIZE_HARDWARE_SPI |
574 |
spiSend(token); |
575 |
for (uint16_t i = 0; i < 512; i++) { |
576 |
spiSend(src[i]); |
577 |
} |
578 |
#endif // OPTIMIZE_HARDWARE_SPI |
579 |
spiSend(0xff); // dummy crc |
580 |
spiSend(0xff); // dummy crc |
581 |
|
582 |
status_ = spiRec(); |
583 |
if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
|
584 |
error(SD_CARD_ERROR_WRITE); |
585 |
chipSelectHigh(); |
586 |
return false; |
587 |
} |
588 |
return true; |
589 |
} |
590 |
//------------------------------------------------------------------------------
|
591 |
/** Start a write multiple blocks sequence.
|
592 |
*
|
593 |
* \param[in] blockNumber Address of first block in sequence.
|
594 |
* \param[in] eraseCount The number of blocks to be pre-erased.
|
595 |
*
|
596 |
* \note This function is used with writeData() and writeStop()
|
597 |
* for optimized multiple block writes.
|
598 |
*
|
599 |
* \return The value one, true, is returned for success and
|
600 |
* the value zero, false, is returned for failure.
|
601 |
*/
|
602 |
uint8_t Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) { |
603 |
#if SD_PROTECT_BLOCK_ZERO
|
604 |
// don't allow write to first block
|
605 |
if (blockNumber == 0) { |
606 |
error(SD_CARD_ERROR_WRITE_BLOCK_ZERO); |
607 |
goto fail;
|
608 |
} |
609 |
#endif // SD_PROTECT_BLOCK_ZERO |
610 |
// send pre-erase count
|
611 |
if (cardAcmd(ACMD23, eraseCount)) {
|
612 |
error(SD_CARD_ERROR_ACMD23); |
613 |
goto fail;
|
614 |
} |
615 |
// use address if not SDHC card
|
616 |
if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9; |
617 |
if (cardCommand(CMD25, blockNumber)) {
|
618 |
error(SD_CARD_ERROR_CMD25); |
619 |
goto fail;
|
620 |
} |
621 |
return true; |
622 |
|
623 |
fail:
|
624 |
chipSelectHigh(); |
625 |
return false; |
626 |
} |
627 |
//------------------------------------------------------------------------------
|
628 |
/** End a write multiple blocks sequence.
|
629 |
*
|
630 |
* \return The value one, true, is returned for success and
|
631 |
* the value zero, false, is returned for failure.
|
632 |
*/
|
633 |
uint8_t Sd2Card::writeStop(void) {
|
634 |
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail; |
635 |
spiSend(STOP_TRAN_TOKEN); |
636 |
if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail; |
637 |
chipSelectHigh(); |
638 |
return true; |
639 |
|
640 |
fail:
|
641 |
error(SD_CARD_ERROR_STOP_TRAN); |
642 |
chipSelectHigh(); |
643 |
return false; |
644 |
} |