2 * This file is part of Cleanflight and Betaflight.
4 * Cleanflight and Betaflight are free software. You can redistribute
5 * this software and/or modify this software under the terms of the
6 * GNU General Public License as published by the Free Software
7 * Foundation, either version 3 of the License, or (at your option)
10 * Cleanflight and Betaflight are distributed in the hope that they
11 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 * See the GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this software.
18 * If not, see <http://www.gnu.org/licenses/>.
28 #include "drivers/bus_spi.h"
29 #include "drivers/dma.h"
30 #include "drivers/dma_reqmap.h"
31 #include "drivers/io.h"
32 #include "drivers/nvic.h"
33 #include "drivers/time.h"
35 #include "pg/bus_spi.h"
36 #include "pg/sdcard.h"
39 #include "sdcard_impl.h"
40 #include "sdcard_standard.h"
42 #ifdef AFATFS_USE_INTROSPECTIVE_LOGGING
43 #define SDCARD_PROFILING
46 #define SDCARD_INIT_NUM_DUMMY_BYTES 10
47 #define SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY 8
48 // Chosen so that CMD8 will have the same CRC as CMD0:
49 #define SDCARD_IF_COND_CHECK_PATTERN 0xAB
51 /* Spec calls for under 400KHz */
52 #define SDCARD_MAX_SPI_INIT_CLK_HZ 400000
54 /* Operational speed <= 25MHz */
55 #define SDCARD_MAX_SPI_CLK_HZ 25000000
57 #define SDCARD_SPI_MODE SPI_MODE0_POL_LOW_EDGE_1ST
58 //#define SDCARD_SPI_MODE SPI_MODE3_POL_HIGH_EDGE_2ND
60 /* Break up 512-byte SD card sectors into chunks of this size when writing without DMA to reduce the peak overhead
61 * per call to sdcard_poll().
63 #define SDCARD_NON_DMA_CHUNK_SIZE 256
66 * Returns true if the card has already been, or is currently, initializing and hasn't encountered enough errors to
67 * trip our error threshold and be disabled (i.e. our card is in and working!)
69 static bool sdcardSpi_isFunctional(void)
71 return sdcard
.state
!= SDCARD_STATE_NOT_PRESENT
;
74 static void sdcard_select(void)
76 IOLo(sdcard
.dev
.busType_u
.spi
.csnPin
);
79 static void sdcard_deselect(void)
81 // As per the SD-card spec, give the card 8 dummy clocks so it can finish its operation
82 //spiReadWrite(&sdcard.dev, 0xFF);
86 delayMicroseconds(10);
87 IOHi(sdcard
.dev
.busType_u
.spi
.csnPin
);
91 * Handle a failure of an SD card operation by resetting the card back to its initialization phase.
93 * Increments the failure counter, and when the failure threshold is reached, disables the card until
94 * the next call to sdcard_init().
96 static void sdcard_reset(void)
98 if (!sdcard_isInserted()) {
99 sdcard
.state
= SDCARD_STATE_NOT_PRESENT
;
103 if (sdcard
.state
>= SDCARD_STATE_READY
) {
104 spiSetClkDivisor(&sdcard
.dev
, spiCalculateDivider(SDCARD_MAX_SPI_INIT_CLK_HZ
));
107 sdcard
.failureCount
++;
108 if (sdcard
.failureCount
>= SDCARD_MAX_CONSECUTIVE_FAILURES
) {
109 sdcard
.state
= SDCARD_STATE_NOT_PRESENT
;
111 sdcard
.operationStartTime
= millis();
112 sdcard
.state
= SDCARD_STATE_RESET
;
117 // Called in ISR context
118 // Wait until idle indicated by a read value of 0xff
119 busStatus_e
sdcard_callbackIdle(uint32_t arg
)
121 sdcard_t
*sdcard
= (sdcard_t
*)arg
;
122 extDevice_t
*dev
= &sdcard
->dev
;
124 uint8_t idleByte
= dev
->bus
->curSegment
->u
.buffers
.rxData
[0];
126 if (idleByte
== 0xff) {
130 if (--sdcard
->idleCount
== 0) {
131 dev
->bus
->curSegment
->u
.buffers
.rxData
[0] = 0x00;
139 // Called in ISR context
140 // Wait until idle is no longer indicated by a read value of 0xff
141 busStatus_e
sdcard_callbackNotIdle(uint32_t arg
)
143 sdcard_t
*sdcard
= (sdcard_t
*)arg
;
144 extDevice_t
*dev
= &sdcard
->dev
;
146 uint8_t idleByte
= dev
->bus
->curSegment
->u
.buffers
.rxData
[0];
148 if (idleByte
!= 0xff) {
152 if (sdcard
->idleCount
-- == 0) {
161 * The SD card spec requires 8 clock cycles to be sent by us on the bus after most commands so it can finish its
162 * processing of that command. The easiest way for us to do this is to just wait for the bus to become idle before
163 * we transmit a command, sending at least 8-bits onto the bus when we do so.
165 static bool sdcard_waitForIdle(int maxBytesToWait
)
169 // Note that this does not release the CS at the end of the transaction
170 busSegment_t segments
[] = {
171 {.u
.buffers
= {NULL
, &idleByte
}, sizeof(idleByte
), false, sdcard_callbackIdle
},
172 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
175 sdcard
.idleCount
= maxBytesToWait
;
177 spiSequence(&sdcard
.dev
, &segments
[0]);
179 // Block pending completion of SPI access
180 spiWait(&sdcard
.dev
);
182 return (idleByte
== 0xff);
186 * Wait for up to maxDelay 0xFF idle bytes to arrive from the card, returning the first non-idle byte found.
188 * Returns 0xFF on failure.
190 static uint8_t sdcard_waitForNonIdleByte(int maxDelay
)
194 // Note that this does not release the CS at the end of the transaction
195 busSegment_t segments
[] = {
196 {.u
.buffers
= {NULL
, &idleByte
}, sizeof(idleByte
), false, sdcard_callbackNotIdle
},
197 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
200 sdcard
.idleCount
= maxDelay
;
202 spiSequence(&sdcard
.dev
, &segments
[0]);
204 // Block pending completion of SPI access
205 spiWait(&sdcard
.dev
);
211 * Waits up to SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY bytes for the card to become ready, send a command to the card
212 * with the given argument, waits up to SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY bytes for a reply, and returns the
213 * first non-0xFF byte of the reply.
215 * You must select the card first with sdcard_select() and deselect it afterwards with sdcard_deselect().
217 * Upon failure, 0xFF is returned.
219 static uint8_t sdcard_sendCommand(uint8_t commandCode
, uint32_t commandArgument
)
221 uint8_t command
[6] = {
223 commandArgument
>> 24,
224 commandArgument
>> 16,
225 commandArgument
>> 8,
227 0x95 /* Static CRC. This CRC is valid for CMD0 with a 0 argument, and CMD8 with 0x1AB argument, which are the only
228 commands that require a CRC */
233 // Note that this does not release the CS at the end of the transaction
234 busSegment_t segments
[] = {
235 {.u
.buffers
= {command
, NULL
}, sizeof(command
), false, NULL
},
236 {.u
.buffers
= {NULL
, &idleByte
}, sizeof(idleByte
), false, sdcard_callbackNotIdle
},
237 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
240 if (!sdcard_waitForIdle(SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY
) && commandCode
!= SDCARD_COMMAND_GO_IDLE_STATE
)
243 sdcard
.idleCount
= SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY
;
245 spiSequence(&sdcard
.dev
, &segments
[0]);
247 // Block pending completion of SPI access
248 spiWait(&sdcard
.dev
);
253 static uint8_t sdcard_sendAppCommand(uint8_t commandCode
, uint32_t commandArgument
)
255 sdcard_sendCommand(SDCARD_COMMAND_APP_CMD
, 0);
257 return sdcard_sendCommand(commandCode
, commandArgument
);
261 * Sends an IF_COND message to the card to check its version and validate its voltage requirements. Sets the global
262 * sdCardVersion with the detected version (0, 1, or 2) and returns true if the card is compatible.
264 static bool sdcard_validateInterfaceCondition(void)
266 uint8_t ifCondReply
[4];
272 uint8_t status
= sdcard_sendCommand(SDCARD_COMMAND_SEND_IF_COND
, (SDCARD_VOLTAGE_ACCEPTED_2_7_to_3_6
<< 8) | SDCARD_IF_COND_CHECK_PATTERN
);
274 // Don't deselect the card right away, because we'll want to read the rest of its reply if it's a V2 card
276 if (status
== (SDCARD_R1_STATUS_BIT_ILLEGAL_COMMAND
| SDCARD_R1_STATUS_BIT_IDLE
)) {
277 // V1 cards don't support this command
279 } else if (status
== SDCARD_R1_STATUS_BIT_IDLE
) {
280 // Note that this does not release the CS at the end of the transaction
281 busSegment_t segments
[] = {
282 {.u
.buffers
= {NULL
, ifCondReply
}, sizeof(ifCondReply
), false, NULL
},
283 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
286 spiSequence(&sdcard
.dev
, &segments
[0]);
288 // Block pending completion of SPI access
289 spiWait(&sdcard
.dev
);
292 * We don't bother to validate the SDCard's operating voltage range since the spec requires it to accept our
293 * 3.3V, but do check that it echoed back our check pattern properly.
295 if (ifCondReply
[3] == SDCARD_IF_COND_CHECK_PATTERN
) {
302 return sdcard
.version
> 0;
305 static bool sdcard_readOCRRegister(uint32_t *result
)
309 uint8_t status
= sdcard_sendCommand(SDCARD_COMMAND_READ_OCR
, 0);
313 // Note that this does not release the CS at the end of the transaction
314 busSegment_t segments
[] = {
315 {.u
.buffers
= {NULL
, response
}, sizeof(response
), false, NULL
},
316 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
319 spiSequence(&sdcard
.dev
, &segments
[0]);
321 // Block pending completion of SPI access
322 spiWait(&sdcard
.dev
);
327 *result
= (response
[0] << 24) | (response
[1] << 16) | (response
[2] << 8) | response
[3];
338 SDCARD_RECEIVE_SUCCESS
,
339 SDCARD_RECEIVE_BLOCK_IN_PROGRESS
,
341 } sdcardReceiveBlockStatus_e
;
344 * Attempt to receive a data block from the SD card.
346 * Return true on success, otherwise the card has not responded yet and you should retry later.
348 static sdcardReceiveBlockStatus_e
sdcard_receiveDataBlock(uint8_t *buffer
, int count
)
350 uint8_t dataToken
= sdcard_waitForNonIdleByte(8);
352 if (dataToken
== 0xFF) {
353 return SDCARD_RECEIVE_BLOCK_IN_PROGRESS
;
356 if (dataToken
!= SDCARD_SINGLE_BLOCK_READ_START_TOKEN
) {
357 return SDCARD_RECEIVE_ERROR
;
360 // Note that this does not release the CS at the end of the transaction
361 busSegment_t segments
[] = {
362 {.u
.buffers
= {NULL
, buffer
}, count
, false, NULL
},
363 // Discard trailing CRC, we don't care
364 {.u
.buffers
= {NULL
, NULL
}, 2, false, NULL
},
365 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
368 spiSequence(&sdcard
.dev
, &segments
[0]);
370 // Block pending completion of SPI access
371 spiWait(&sdcard
.dev
);
373 return SDCARD_RECEIVE_SUCCESS
;
376 static bool sdcard_sendDataBlockFinish(void)
378 uint16_t dummyCRC
= 0;
379 uint8_t dataResponseToken
;
380 // Note that this does not release the CS at the end of the transaction
381 busSegment_t segments
[] = {
382 {.u
.buffers
= {(uint8_t *)&dummyCRC
, NULL
}, sizeof(dummyCRC
), false, NULL
},
383 {.u
.buffers
= {NULL
, &dataResponseToken
}, sizeof(dataResponseToken
), false, NULL
},
384 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
387 spiSequence(&sdcard
.dev
, &segments
[0]);
389 // Block pending completion of SPI access
390 spiWait(&sdcard
.dev
);
393 * Check if the card accepted the write (no CRC error / no address error)
395 * The lower 5 bits are structured as follows:
400 * 010 - Data accepted
404 return (dataResponseToken
& 0x1F) == 0x05;
408 * Begin sending a buffer of SDCARD_BLOCK_SIZE bytes to the SD card.
410 static void sdcard_sendDataBlockBegin(uint8_t *buffer
, bool multiBlockWrite
)
412 static uint8_t token
;
414 token
= multiBlockWrite
? SDCARD_MULTIPLE_BLOCK_WRITE_START_TOKEN
: SDCARD_SINGLE_BLOCK_WRITE_START_TOKEN
;
416 // Note that this does not release the CS at the end of the transaction
417 static busSegment_t segments
[] = {
418 // Write a single 0xff
419 {.u
.buffers
= {NULL
, NULL
}, 1, false, NULL
},
420 {.u
.buffers
= {&token
, NULL
}, sizeof(token
), false, NULL
},
421 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
422 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
425 segments
[2].u
.buffers
.txData
= buffer
;
426 segments
[2].len
= spiUseDMA(&sdcard
.dev
) ? SDCARD_BLOCK_SIZE
: SDCARD_NON_DMA_CHUNK_SIZE
;
428 spiSequence(&sdcard
.dev
, &segments
[0]);
430 // Don't block pending completion of SPI access
433 static bool sdcard_receiveCID(void)
437 if (sdcard_receiveDataBlock(cid
, sizeof(cid
)) != SDCARD_RECEIVE_SUCCESS
) {
441 sdcard
.metadata
.manufacturerID
= cid
[0];
442 sdcard
.metadata
.oemID
= (cid
[1] << 8) | cid
[2];
443 sdcard
.metadata
.productName
[0] = cid
[3];
444 sdcard
.metadata
.productName
[1] = cid
[4];
445 sdcard
.metadata
.productName
[2] = cid
[5];
446 sdcard
.metadata
.productName
[3] = cid
[6];
447 sdcard
.metadata
.productName
[4] = cid
[7];
448 sdcard
.metadata
.productRevisionMajor
= cid
[8] >> 4;
449 sdcard
.metadata
.productRevisionMinor
= cid
[8] & 0x0F;
450 sdcard
.metadata
.productSerial
= (cid
[9] << 24) | (cid
[10] << 16) | (cid
[11] << 8) | cid
[12];
451 sdcard
.metadata
.productionYear
= (((cid
[13] & 0x0F) << 4) | (cid
[14] >> 4)) + 2000;
452 sdcard
.metadata
.productionMonth
= cid
[14] & 0x0F;
457 static bool sdcard_fetchCSD(void)
459 uint32_t readBlockLen
, blockCount
, blockCountMult
;
460 uint64_t capacityBytes
;
464 /* The CSD command's data block should always arrive within 8 idle clock cycles (SD card spec). This is because
465 * the information about card latency is stored in the CSD register itself, so we can't use that yet!
468 sdcard_sendCommand(SDCARD_COMMAND_SEND_CSD
, 0) == 0
469 && sdcard_receiveDataBlock((uint8_t*) &sdcard
.csd
, sizeof(sdcard
.csd
)) == SDCARD_RECEIVE_SUCCESS
470 && SDCARD_GET_CSD_FIELD(sdcard
.csd
, 1, TRAILER
) == 1;
473 switch (SDCARD_GET_CSD_FIELD(sdcard
.csd
, 1, CSD_STRUCTURE_VER
)) {
474 case SDCARD_CSD_STRUCTURE_VERSION_1
:
475 // Block size in bytes (doesn't have to be 512)
476 readBlockLen
= 1 << SDCARD_GET_CSD_FIELD(sdcard
.csd
, 1, READ_BLOCK_LEN
);
477 blockCountMult
= 1 << (SDCARD_GET_CSD_FIELD(sdcard
.csd
, 1, CSIZE_MULT
) + 2);
478 blockCount
= (SDCARD_GET_CSD_FIELD(sdcard
.csd
, 1, CSIZE
) + 1) * blockCountMult
;
480 // We could do this in 32 bits but it makes the 2GB case awkward
481 capacityBytes
= (uint64_t) blockCount
* readBlockLen
;
483 // Re-express that capacity (max 2GB) in our standard 512-byte block size
484 sdcard
.metadata
.numBlocks
= capacityBytes
/ SDCARD_BLOCK_SIZE
;
486 case SDCARD_CSD_STRUCTURE_VERSION_2
:
487 sdcard
.metadata
.numBlocks
= (SDCARD_GET_CSD_FIELD(sdcard
.csd
, 2, CSIZE
) + 1) * 1024;
500 * Check if the SD Card has completed its startup sequence. Must be called with sdcard.state == SDCARD_STATE_INITIALIZATION.
502 * Returns true if the card has finished its init process.
504 static bool sdcard_checkInitDone(void)
508 uint8_t status
= sdcard_sendAppCommand(SDCARD_ACOMMAND_SEND_OP_COND
, sdcard
.version
== 2 ? 1 << 30 /* We support high capacity cards */ : 0);
512 // When card init is complete, the idle bit in the response becomes zero.
513 return status
== 0x00;
516 void sdcardSpi_preInit(const sdcardConfig_t
*config
)
518 spiPreinitRegister(config
->chipSelectTag
, IOCFG_IPU
, 1);
522 * Begin the initialization process for the SD card. This must be called first before any other sdcard_ routine.
524 static void sdcardSpi_init(const sdcardConfig_t
*config
, const spiPinConfig_t
*spiConfig
)
528 sdcard
.enabled
= config
->mode
;
529 if (!sdcard
.enabled
) {
530 sdcard
.state
= SDCARD_STATE_NOT_PRESENT
;
534 spiSetBusInstance(&sdcard
.dev
, config
->device
);
537 if (config
->chipSelectTag
) {
538 chipSelectIO
= IOGetByTag(config
->chipSelectTag
);
539 IOInit(chipSelectIO
, OWNER_SDCARD_CS
, 0);
540 IOConfigGPIO(chipSelectIO
, SPI_IO_CS_CFG
);
542 chipSelectIO
= IO_NONE
;
544 sdcard
.dev
.busType_u
.spi
.csnPin
= chipSelectIO
;
546 // Set the clock phase/polarity
547 spiSetClkPhasePolarity(&sdcard
.dev
, true);
549 // Set the callback argument when calling back to this driver for DMA completion
550 sdcard
.dev
.callbackArg
= (uint32_t)&sdcard
;
552 // Max frequency is initially 400kHz
554 spiSetClkDivisor(&sdcard
.dev
, spiCalculateDivider(SDCARD_MAX_SPI_INIT_CLK_HZ
));
556 // SDCard wants 1ms minimum delay after power is applied to it
559 // Transmit at least 74 dummy clock cycles with CS high so the SD card can start up
560 IOHi(sdcard
.dev
.busType_u
.spi
.csnPin
);
562 // Note that this does not release the CS at the end of the transaction
563 busSegment_t segments
[] = {
564 // Write a single 0xff
565 {.u
.buffers
= {NULL
, NULL
}, SDCARD_INIT_NUM_DUMMY_BYTES
, false, NULL
},
566 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
569 spiSequence(&sdcard
.dev
, &segments
[0]);
571 // Block pending completion of SPI access
572 spiWait(&sdcard
.dev
);
574 sdcard
.operationStartTime
= millis();
575 sdcard
.state
= SDCARD_STATE_RESET
;
576 sdcard
.failureCount
= 0;
579 static bool sdcard_setBlockLength(uint32_t blockLen
)
583 uint8_t status
= sdcard_sendCommand(SDCARD_COMMAND_SET_BLOCKLEN
, blockLen
);
591 * Returns true if the card is ready to accept read/write commands.
593 static bool sdcard_isReady(void)
595 return sdcard
.state
== SDCARD_STATE_READY
|| sdcard
.state
== SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
;
599 * Send the stop-transmission token to complete a multi-block write.
602 * SDCARD_OPERATION_IN_PROGRESS - We're now waiting for that stop to complete, the card will enter
603 * the SDCARD_STATE_STOPPING_MULTIPLE_BLOCK_WRITE state.
604 * SDCARD_OPERATION_SUCCESS - The multi-block write finished immediately, the card will enter
605 * the SDCARD_READY state.
608 static sdcardOperationStatus_e
sdcard_endWriteBlocks(void)
610 uint8_t token
= SDCARD_MULTIPLE_BLOCK_WRITE_STOP_TOKEN
;
611 sdcard
.multiWriteBlocksRemain
= 0;
613 // Note that this does not release the CS at the end of the transaction
614 busSegment_t segments
[] = {
615 // 8 dummy clocks to guarantee N_WR clocks between the last card response and this token
616 {.u
.buffers
= {NULL
, NULL
}, 1, false, NULL
},
617 {.u
.buffers
= {&token
, NULL
}, sizeof(token
), false, NULL
},
618 {.u
.buffers
= {NULL
, NULL
}, 0, false, NULL
},
621 spiSequence(&sdcard
.dev
, &segments
[0]);
623 // Block pending completion of SPI access
624 spiWait(&sdcard
.dev
);
626 // Card may choose to raise a busy (non-0xFF) signal after at most N_BR (1 byte) delay
627 if (sdcard_waitForNonIdleByte(1) == 0xFF) {
628 sdcard
.state
= SDCARD_STATE_READY
;
629 return SDCARD_OPERATION_SUCCESS
;
631 sdcard
.state
= SDCARD_STATE_STOPPING_MULTIPLE_BLOCK_WRITE
;
632 sdcard
.operationStartTime
= millis();
634 return SDCARD_OPERATION_IN_PROGRESS
;
639 * Call periodically for the SD card to perform in-progress transfers.
641 * Returns true if the card is ready to accept commands.
643 static bool sdcardSpi_poll(void)
645 if (!sdcard
.enabled
) {
646 sdcard
.state
= SDCARD_STATE_NOT_PRESENT
;
653 #ifdef SDCARD_PROFILING
654 bool profilingComplete
;
658 switch (sdcard
.state
) {
659 case SDCARD_STATE_RESET
:
662 initStatus
= sdcard_sendCommand(SDCARD_COMMAND_GO_IDLE_STATE
, 0);
666 if (initStatus
== SDCARD_R1_STATUS_BIT_IDLE
) {
667 // Check card voltage and version
668 if (sdcard_validateInterfaceCondition()) {
670 sdcard
.state
= SDCARD_STATE_CARD_INIT_IN_PROGRESS
;
673 // Bad reply/voltage, we ought to refrain from accessing the card.
674 sdcard
.state
= SDCARD_STATE_NOT_PRESENT
;
679 case SDCARD_STATE_CARD_INIT_IN_PROGRESS
:
680 if (sdcard_checkInitDone()) {
681 if (sdcard
.version
== 2) {
682 // Check for high capacity card
685 if (!sdcard_readOCRRegister(&ocr
)) {
690 sdcard
.highCapacity
= (ocr
& (1 << 30)) != 0;
692 // Version 1 cards are always low-capacity
693 sdcard
.highCapacity
= false;
696 // Now fetch the CSD and CID registers
697 if (sdcard_fetchCSD()) {
700 uint8_t status
= sdcard_sendCommand(SDCARD_COMMAND_SEND_CID
, 0);
703 // Keep the card selected to receive the response block
704 sdcard
.state
= SDCARD_STATE_INITIALIZATION_RECEIVE_CID
;
715 case SDCARD_STATE_INITIALIZATION_RECEIVE_CID
:
716 if (sdcard_receiveCID()) {
719 /* The spec is a little iffy on what the default block size is for Standard Size cards (it can be changed on
720 * standard size cards) so let's just set it to 512 explicitly so we don't have a problem.
722 if (!sdcard
.highCapacity
&& !sdcard_setBlockLength(SDCARD_BLOCK_SIZE
)) {
727 // Now we're done with init and we can switch to the full speed clock (<25MHz)
729 spiSetClkDivisor(&sdcard
.dev
, spiCalculateDivider(SDCARD_MAX_SPI_CLK_HZ
));
731 sdcard
.multiWriteBlocksRemain
= 0;
733 sdcard
.state
= SDCARD_STATE_READY
;
735 } // else keep waiting for the CID to arrive
737 case SDCARD_STATE_SENDING_WRITE
:
738 // Have we finished sending the write yet?
739 sendComplete
= !spiIsBusy(&sdcard
.dev
);
741 if (!spiUseDMA(&sdcard
.dev
)) {
742 // Send another chunk
743 spiReadWriteBuf(&sdcard
.dev
, sdcard
.pendingOperation
.buffer
+ SDCARD_NON_DMA_CHUNK_SIZE
* sdcard
.pendingOperation
.chunkIndex
, NULL
, SDCARD_NON_DMA_CHUNK_SIZE
);
745 sdcard
.pendingOperation
.chunkIndex
++;
747 sendComplete
= sdcard
.pendingOperation
.chunkIndex
== SDCARD_BLOCK_SIZE
/ SDCARD_NON_DMA_CHUNK_SIZE
;
751 // Finish up by sending the CRC and checking the SD-card's acceptance/rejectance
752 if (sdcard_sendDataBlockFinish()) {
753 // The SD card is now busy committing that write to the card
754 sdcard
.state
= SDCARD_STATE_WAITING_FOR_WRITE
;
755 sdcard
.operationStartTime
= millis();
757 // Since we've transmitted the buffer we can go ahead and tell the caller their operation is complete
758 if (sdcard
.pendingOperation
.callback
) {
759 sdcard
.pendingOperation
.callback(SDCARD_BLOCK_OPERATION_WRITE
, sdcard
.pendingOperation
.blockIndex
, sdcard
.pendingOperation
.buffer
, sdcard
.pendingOperation
.callbackData
);
762 /* Our write was rejected! This could be due to a bad address but we hope not to attempt that, so assume
763 * the card is broken and needs reset.
767 // Announce write failure:
768 if (sdcard
.pendingOperation
.callback
) {
769 sdcard
.pendingOperation
.callback(SDCARD_BLOCK_OPERATION_WRITE
, sdcard
.pendingOperation
.blockIndex
, NULL
, sdcard
.pendingOperation
.callbackData
);
776 case SDCARD_STATE_WAITING_FOR_WRITE
:
777 if (sdcard_waitForIdle(SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY
)) {
778 #ifdef SDCARD_PROFILING
779 profilingComplete
= true;
782 sdcard
.failureCount
= 0; // Assume the card is good if it can complete a write
784 // Still more blocks left to write in a multi-block chain?
785 if (sdcard
.multiWriteBlocksRemain
> 1) {
786 sdcard
.multiWriteBlocksRemain
--;
787 sdcard
.multiWriteNextBlock
++;
788 sdcard
.state
= SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
;
789 } else if (sdcard
.multiWriteBlocksRemain
== 1) {
790 // This function changes the sd card state for us whether immediately succesful or delayed:
791 if (sdcard_endWriteBlocks() == SDCARD_OPERATION_SUCCESS
) {
794 #ifdef SDCARD_PROFILING
795 // Wait for the multi-block write to be terminated before finishing timing
796 profilingComplete
= false;
800 sdcard
.state
= SDCARD_STATE_READY
;
804 #ifdef SDCARD_PROFILING
805 if (profilingComplete
&& sdcard
.profiler
) {
806 sdcard
.profiler(SDCARD_BLOCK_OPERATION_WRITE
, sdcard
.pendingOperation
.blockIndex
, micros() - sdcard
.pendingOperation
.profileStartTime
);
809 } else if (millis() > sdcard
.operationStartTime
+ SDCARD_TIMEOUT_WRITE_MSEC
) {
811 * The caller has already been told that their write has completed, so they will have discarded
812 * their buffer and have no hope of retrying the operation. But this should be very rare and it allows
813 * them to reuse their buffer milliseconds faster than they otherwise would.
819 case SDCARD_STATE_READING
:
820 switch (sdcard_receiveDataBlock(sdcard
.pendingOperation
.buffer
, SDCARD_BLOCK_SIZE
)) {
821 case SDCARD_RECEIVE_SUCCESS
:
824 sdcard
.state
= SDCARD_STATE_READY
;
825 sdcard
.failureCount
= 0; // Assume the card is good if it can complete a read
827 #ifdef SDCARD_PROFILING
828 if (sdcard
.profiler
) {
829 sdcard
.profiler(SDCARD_BLOCK_OPERATION_READ
, sdcard
.pendingOperation
.blockIndex
, micros() - sdcard
.pendingOperation
.profileStartTime
);
833 if (sdcard
.pendingOperation
.callback
) {
834 sdcard
.pendingOperation
.callback(
835 SDCARD_BLOCK_OPERATION_READ
,
836 sdcard
.pendingOperation
.blockIndex
,
837 sdcard
.pendingOperation
.buffer
,
838 sdcard
.pendingOperation
.callbackData
842 case SDCARD_RECEIVE_BLOCK_IN_PROGRESS
:
843 if (millis() <= sdcard
.operationStartTime
+ SDCARD_TIMEOUT_READ_MSEC
) {
844 break; // Timeout not reached yet so keep waiting
846 // Timeout has expired, so fall through to convert to a fatal error
849 case SDCARD_RECEIVE_ERROR
:
854 if (sdcard
.pendingOperation
.callback
) {
855 sdcard
.pendingOperation
.callback(
856 SDCARD_BLOCK_OPERATION_READ
,
857 sdcard
.pendingOperation
.blockIndex
,
859 sdcard
.pendingOperation
.callbackData
867 case SDCARD_STATE_STOPPING_MULTIPLE_BLOCK_WRITE
:
868 if (sdcard_waitForIdle(SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY
)) {
871 sdcard
.state
= SDCARD_STATE_READY
;
873 #ifdef SDCARD_PROFILING
874 if (sdcard
.profiler
) {
875 sdcard
.profiler(SDCARD_BLOCK_OPERATION_WRITE
, sdcard
.pendingOperation
.blockIndex
, micros() - sdcard
.pendingOperation
.profileStartTime
);
878 } else if (millis() > sdcard
.operationStartTime
+ SDCARD_TIMEOUT_WRITE_MSEC
) {
883 case SDCARD_STATE_NOT_PRESENT
:
888 // Is the card's initialization taking too long?
889 if (sdcard
.state
>= SDCARD_STATE_RESET
&& sdcard
.state
< SDCARD_STATE_READY
890 && millis() - sdcard
.operationStartTime
> SDCARD_TIMEOUT_INIT_MILLIS
) {
894 return sdcard_isReady();
898 * Write the 512-byte block from the given buffer into the block with the given index.
900 * If the write does not complete immediately, your callback will be called later. If the write was successful, the
901 * buffer pointer will be the same buffer you originally passed in, otherwise the buffer will be set to NULL.
904 * SDCARD_OPERATION_IN_PROGRESS - Your buffer is currently being transmitted to the card and your callback will be
905 * called later to report the completion. The buffer pointer must remain valid until
907 * SDCARD_OPERATION_SUCCESS - Your buffer has been transmitted to the card now.
908 * SDCARD_OPERATION_BUSY - The card is already busy and cannot accept your write
909 * SDCARD_OPERATION_FAILURE - Your write was rejected by the card, card will be reset
911 static sdcardOperationStatus_e
sdcardSpi_writeBlock(uint32_t blockIndex
, uint8_t *buffer
, sdcard_operationCompleteCallback_c callback
, uint32_t callbackData
)
915 #ifdef SDCARD_PROFILING
916 sdcard
.pendingOperation
.profileStartTime
= micros();
920 switch (sdcard
.state
) {
921 case SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
:
922 // Do we need to cancel the previous multi-block write?
923 if (blockIndex
!= sdcard
.multiWriteNextBlock
) {
924 if (sdcard_endWriteBlocks() == SDCARD_OPERATION_SUCCESS
) {
925 // Now we've entered the ready state, we can try again
928 return SDCARD_OPERATION_BUSY
;
932 // We're continuing a multi-block write
934 case SDCARD_STATE_READY
:
935 // We're not continuing a multi-block write so we need to send a single-block write command
938 // Standard size cards use byte addressing, high capacity cards use block addressing
939 status
= sdcard_sendCommand(SDCARD_COMMAND_WRITE_BLOCK
, sdcard
.highCapacity
? blockIndex
: blockIndex
* SDCARD_BLOCK_SIZE
);
946 return SDCARD_OPERATION_FAILURE
;
950 return SDCARD_OPERATION_BUSY
;
953 sdcard_sendDataBlockBegin(buffer
, sdcard
.state
== SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
);
955 sdcard
.pendingOperation
.buffer
= buffer
;
956 sdcard
.pendingOperation
.blockIndex
= blockIndex
;
957 sdcard
.pendingOperation
.callback
= callback
;
958 sdcard
.pendingOperation
.callbackData
= callbackData
;
959 sdcard
.pendingOperation
.chunkIndex
= 1; // (for non-DMA transfers) we've sent chunk #0 already
960 sdcard
.state
= SDCARD_STATE_SENDING_WRITE
;
962 return SDCARD_OPERATION_IN_PROGRESS
;
966 * Begin writing a series of consecutive blocks beginning at the given block index. This will allow (but not require)
967 * the SD card to pre-erase the number of blocks you specifiy, which can allow the writes to complete faster.
969 * Afterwards, just call sdcard_writeBlock() as normal to write those blocks consecutively.
971 * It's okay to abort the multi-block write at any time by writing to a non-consecutive address, or by performing a read.
974 * SDCARD_OPERATION_SUCCESS - Multi-block write has been queued
975 * SDCARD_OPERATION_BUSY - The card is already busy and cannot accept your write
976 * SDCARD_OPERATION_FAILURE - A fatal error occured, card will be reset
978 static sdcardOperationStatus_e
sdcardSpi_beginWriteBlocks(uint32_t blockIndex
, uint32_t blockCount
)
980 if (sdcard
.state
!= SDCARD_STATE_READY
) {
981 if (sdcard
.state
== SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
) {
982 if (blockIndex
== sdcard
.multiWriteNextBlock
) {
983 // Assume that the caller wants to continue the multi-block write they already have in progress!
984 return SDCARD_OPERATION_SUCCESS
;
985 } else if (sdcard_endWriteBlocks() != SDCARD_OPERATION_SUCCESS
) {
986 return SDCARD_OPERATION_BUSY
;
987 } // Else we've completed the previous multi-block write and can fall through to start the new one
989 return SDCARD_OPERATION_BUSY
;
996 sdcard_sendAppCommand(SDCARD_ACOMMAND_SET_WR_BLOCK_ERASE_COUNT
, blockCount
) == 0
997 && sdcard_sendCommand(SDCARD_COMMAND_WRITE_MULTIPLE_BLOCK
, sdcard
.highCapacity
? blockIndex
: blockIndex
* SDCARD_BLOCK_SIZE
) == 0
999 sdcard
.state
= SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
;
1000 sdcard
.multiWriteBlocksRemain
= blockCount
;
1001 sdcard
.multiWriteNextBlock
= blockIndex
;
1003 // Leave the card selected
1004 return SDCARD_OPERATION_SUCCESS
;
1010 return SDCARD_OPERATION_FAILURE
;
1015 * Read the 512-byte block with the given index into the given 512-byte buffer.
1017 * When the read completes, your callback will be called. If the read was successful, the buffer pointer will be the
1018 * same buffer you originally passed in, otherwise the buffer will be set to NULL.
1020 * You must keep the pointer to the buffer valid until the operation completes!
1023 * true - The operation was successfully queued for later completion, your callback will be called later
1024 * false - The operation could not be started due to the card being busy (try again later).
1026 static bool sdcardSpi_readBlock(uint32_t blockIndex
, uint8_t *buffer
, sdcard_operationCompleteCallback_c callback
, uint32_t callbackData
)
1028 if (sdcard
.state
!= SDCARD_STATE_READY
) {
1029 if (sdcard
.state
== SDCARD_STATE_WRITING_MULTIPLE_BLOCKS
) {
1030 if (sdcard_endWriteBlocks() != SDCARD_OPERATION_SUCCESS
) {
1038 #ifdef SDCARD_PROFILING
1039 sdcard
.pendingOperation
.profileStartTime
= micros();
1044 // Standard size cards use byte addressing, high capacity cards use block addressing
1045 uint8_t status
= sdcard_sendCommand(SDCARD_COMMAND_READ_SINGLE_BLOCK
, sdcard
.highCapacity
? blockIndex
: blockIndex
* SDCARD_BLOCK_SIZE
);
1048 sdcard
.pendingOperation
.buffer
= buffer
;
1049 sdcard
.pendingOperation
.blockIndex
= blockIndex
;
1050 sdcard
.pendingOperation
.callback
= callback
;
1051 sdcard
.pendingOperation
.callbackData
= callbackData
;
1053 sdcard
.state
= SDCARD_STATE_READING
;
1055 sdcard
.operationStartTime
= millis();
1057 // Leave the card selected for the whole transaction
1068 * Returns true if the SD card has successfully completed its startup procedures.
1070 static bool sdcardSpi_isInitialized(void)
1072 return sdcard
.state
>= SDCARD_STATE_READY
;
1075 static const sdcardMetadata_t
* sdcardSpi_getMetadata(void)
1077 return &sdcard
.metadata
;
1080 #ifdef SDCARD_PROFILING
1082 static void sdcardSpi_setProfilerCallback(sdcard_profilerCallback_c callback
)
1084 sdcard
.profiler
= callback
;
1089 sdcardVTable_t sdcardSpiVTable
= {
1092 sdcardSpi_readBlock
,
1093 sdcardSpi_beginWriteBlocks
,
1094 sdcardSpi_writeBlock
,
1096 sdcardSpi_isFunctional
,
1097 sdcardSpi_isInitialized
,
1098 sdcardSpi_getMetadata
,
1099 #ifdef SDCARD_PROFILING
1100 sdcardSpi_setProfilerCallback
,