You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

637 line
18KB

  1. /* Arduino SdSpiCard Library
  2. * Copyright (C) 2012 by William Greiman
  3. *
  4. * This file is part of the Arduino SdSpiCard 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 SdSpiCard Library. If not, see
  18. * <http://www.gnu.org/licenses/>.
  19. */
  20. #include "SdSpiCard.h"
  21. #include "SdSpi.h"
  22. #if ENABLE_SPI_TRANSACTION
  23. #include <SPI.h>
  24. #endif // ENABLE_SPI_TRANSACTION
  25. // debug trace macro
  26. #define SD_TRACE(m, b)
  27. // #define SD_TRACE(m, b) Serial.print(m);Serial.println(b);
  28. //==============================================================================
  29. #if USE_SD_CRC
  30. // CRC functions
  31. //------------------------------------------------------------------------------
  32. static uint8_t CRC7(const uint8_t* data, uint8_t n) {
  33. uint8_t crc = 0;
  34. for (uint8_t i = 0; i < n; i++) {
  35. uint8_t d = data[i];
  36. for (uint8_t j = 0; j < 8; j++) {
  37. crc <<= 1;
  38. if ((d & 0x80) ^ (crc & 0x80)) {
  39. crc ^= 0x09;
  40. }
  41. d <<= 1;
  42. }
  43. }
  44. return (crc << 1) | 1;
  45. }
  46. //------------------------------------------------------------------------------
  47. #if USE_SD_CRC == 1
  48. // slower CRC-CCITT
  49. // uses the x^16,x^12,x^5,x^1 polynomial.
  50. static uint16_t CRC_CCITT(const uint8_t *data, size_t n) {
  51. uint16_t crc = 0;
  52. for (size_t i = 0; i < n; i++) {
  53. crc = (uint8_t)(crc >> 8) | (crc << 8);
  54. crc ^= data[i];
  55. crc ^= (uint8_t)(crc & 0xff) >> 4;
  56. crc ^= crc << 12;
  57. crc ^= (crc & 0xff) << 5;
  58. }
  59. return crc;
  60. }
  61. #elif USE_SD_CRC > 1 // CRC_CCITT
  62. //------------------------------------------------------------------------------
  63. // faster CRC-CCITT
  64. // uses the x^16,x^12,x^5,x^1 polynomial.
  65. #ifdef __AVR__
  66. static const uint16_t crctab[] PROGMEM = {
  67. #else // __AVR__
  68. static const uint16_t crctab[] = {
  69. #endif // __AVR__
  70. 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
  71. 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
  72. 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
  73. 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
  74. 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
  75. 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
  76. 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
  77. 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
  78. 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  79. 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
  80. 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
  81. 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
  82. 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
  83. 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
  84. 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
  85. 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
  86. 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
  87. 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  88. 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
  89. 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
  90. 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
  91. 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  92. 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
  93. 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
  94. 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
  95. 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
  96. 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  97. 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
  98. 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
  99. 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
  100. 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
  101. 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  102. };
  103. static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
  104. uint16_t crc = 0;
  105. for (size_t i = 0; i < n; i++) {
  106. #ifdef __AVR__
  107. crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
  108. #else // __AVR__
  109. crc = crctab[(crc >> 8 ^ data[i]) & 0XFF] ^ (crc << 8);
  110. #endif // __AVR__
  111. }
  112. return crc;
  113. }
  114. #endif // CRC_CCITT
  115. #endif // USE_SD_CRC
  116. //==============================================================================
  117. // SdSpiCard member functions
  118. //------------------------------------------------------------------------------
  119. bool SdSpiCard::begin(m_spi_t* spi, uint8_t chipSelectPin, uint8_t sckDivisor) {
  120. m_errorCode = m_type = 0;
  121. m_spi = spi;
  122. m_chipSelectPin = chipSelectPin;
  123. // 16-bit init start time allows over a minute
  124. uint16_t t0 = (uint16_t)millis();
  125. uint32_t arg;
  126. pinMode(m_chipSelectPin, OUTPUT);
  127. digitalWrite(m_chipSelectPin, HIGH);
  128. spiBegin();
  129. // set SCK rate for initialization commands
  130. m_sckDivisor = SPI_SCK_INIT_DIVISOR;
  131. spiInit(m_sckDivisor);
  132. // must supply min of 74 clock cycles with CS high.
  133. for (uint8_t i = 0; i < 10; i++) {
  134. spiSend(0XFF);
  135. }
  136. // command to go idle in SPI mode
  137. while (cardCommand(CMD0, 0) != R1_IDLE_STATE) {
  138. if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
  139. error(SD_CARD_ERROR_CMD0);
  140. goto fail;
  141. }
  142. }
  143. #if USE_SD_CRC
  144. if (cardCommand(CMD59, 1) != R1_IDLE_STATE) {
  145. error(SD_CARD_ERROR_CMD59);
  146. goto fail;
  147. }
  148. #endif // USE_SD_CRC
  149. // check SD version
  150. while (1) {
  151. if (cardCommand(CMD8, 0x1AA) == (R1_ILLEGAL_COMMAND | R1_IDLE_STATE)) {
  152. type(SD_CARD_TYPE_SD1);
  153. break;
  154. }
  155. for (uint8_t i = 0; i < 4; i++) {
  156. m_status = spiReceive();
  157. }
  158. if (m_status == 0XAA) {
  159. type(SD_CARD_TYPE_SD2);
  160. break;
  161. }
  162. if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
  163. error(SD_CARD_ERROR_CMD8);
  164. goto fail;
  165. }
  166. }
  167. // initialize card and send host supports SDHC if SD2
  168. arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
  169. while (cardAcmd(ACMD41, arg) != R1_READY_STATE) {
  170. // check for timeout
  171. if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
  172. error(SD_CARD_ERROR_ACMD41);
  173. goto fail;
  174. }
  175. }
  176. // if SD2 read OCR register to check for SDHC card
  177. if (type() == SD_CARD_TYPE_SD2) {
  178. if (cardCommand(CMD58, 0)) {
  179. error(SD_CARD_ERROR_CMD58);
  180. goto fail;
  181. }
  182. if ((spiReceive() & 0XC0) == 0XC0) {
  183. type(SD_CARD_TYPE_SDHC);
  184. }
  185. // Discard rest of ocr - contains allowed voltage range.
  186. for (uint8_t i = 0; i < 3; i++) {
  187. spiReceive();
  188. }
  189. }
  190. chipSelectHigh();
  191. m_sckDivisor = sckDivisor;
  192. return true;
  193. fail:
  194. chipSelectHigh();
  195. return false;
  196. }
  197. //------------------------------------------------------------------------------
  198. // send command and return error code. Return zero for OK
  199. uint8_t SdSpiCard::cardCommand(uint8_t cmd, uint32_t arg) {
  200. // select card
  201. chipSelectLow();
  202. // wait if busy
  203. waitNotBusy(SD_WRITE_TIMEOUT);
  204. uint8_t *pa = reinterpret_cast<uint8_t *>(&arg);
  205. #if USE_SD_CRC
  206. // form message
  207. uint8_t d[6] = {cmd | 0X40, pa[3], pa[2], pa[1], pa[0]};
  208. // add crc
  209. d[5] = CRC7(d, 5);
  210. // send message
  211. for (uint8_t k = 0; k < 6; k++) {
  212. spiSend(d[k]);
  213. }
  214. #else // USE_SD_CRC
  215. // send command
  216. spiSend(cmd | 0x40);
  217. // send argument
  218. for (int8_t i = 3; i >= 0; i--) {
  219. spiSend(pa[i]);
  220. }
  221. // send CRC - correct for CMD0 with arg zero or CMD8 with arg 0X1AA
  222. spiSend(cmd == CMD0 ? 0X95 : 0X87);
  223. #endif // USE_SD_CRC
  224. // skip stuff byte for stop read
  225. if (cmd == CMD12) {
  226. spiReceive();
  227. }
  228. // wait for response
  229. for (uint8_t i = 0; ((m_status = spiReceive()) & 0X80) && i != 0XFF; i++) {
  230. }
  231. return m_status;
  232. }
  233. //------------------------------------------------------------------------------
  234. uint32_t SdSpiCard::cardSize() {
  235. csd_t csd;
  236. if (!readCSD(&csd)) {
  237. return 0;
  238. }
  239. if (csd.v1.csd_ver == 0) {
  240. uint8_t read_bl_len = csd.v1.read_bl_len;
  241. uint16_t c_size = (csd.v1.c_size_high << 10)
  242. | (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;
  243. uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)
  244. | csd.v1.c_size_mult_low;
  245. return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);
  246. } else if (csd.v2.csd_ver == 1) {
  247. uint32_t c_size = 0X10000L * csd.v2.c_size_high + 0X100L
  248. * (uint32_t)csd.v2.c_size_mid + csd.v2.c_size_low;
  249. return (c_size + 1) << 10;
  250. } else {
  251. error(SD_CARD_ERROR_BAD_CSD);
  252. return 0;
  253. }
  254. }
  255. //------------------------------------------------------------------------------
  256. void SdSpiCard::spiYield() {
  257. #if ENABLE_SPI_TRANSACTION && ENABLE_SPI_YIELD && defined(SPI_HAS_TRANSACTION)
  258. chipSelectHigh();
  259. chipSelectLow();
  260. #endif // ENABLE_SPI_TRANSACTION && ENABLE_SPI_YIELD && SPI_HAS_TRANSACTION
  261. }
  262. //------------------------------------------------------------------------------
  263. void SdSpiCard::chipSelectHigh() {
  264. digitalWrite(m_chipSelectPin, HIGH);
  265. // insure MISO goes high impedance
  266. spiSend(0XFF);
  267. #if ENABLE_SPI_TRANSACTION && defined(SPI_HAS_TRANSACTION)
  268. if (useSpiTransactions()) {
  269. SPI.endTransaction();
  270. }
  271. #endif // ENABLE_SPI_TRANSACTION && defined(SPI_HAS_TRANSACTION)
  272. }
  273. //------------------------------------------------------------------------------
  274. void SdSpiCard::chipSelectLow() {
  275. #if ENABLE_SPI_TRANSACTION && defined(SPI_HAS_TRANSACTION)
  276. if (useSpiTransactions()) {
  277. SPI.beginTransaction(SPISettings());
  278. }
  279. #endif // ENABLE_SPI_TRANSACTION && defined(SPI_HAS_TRANSACTION)
  280. spiInit(m_sckDivisor);
  281. digitalWrite(m_chipSelectPin, LOW);
  282. }
  283. //------------------------------------------------------------------------------
  284. bool SdSpiCard::erase(uint32_t firstBlock, uint32_t lastBlock) {
  285. csd_t csd;
  286. if (!readCSD(&csd)) {
  287. goto fail;
  288. }
  289. // check for single block erase
  290. if (!csd.v1.erase_blk_en) {
  291. // erase size mask
  292. uint8_t m = (csd.v1.sector_size_high << 1) | csd.v1.sector_size_low;
  293. if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
  294. // error card can't erase specified area
  295. error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
  296. goto fail;
  297. }
  298. }
  299. if (m_type != SD_CARD_TYPE_SDHC) {
  300. firstBlock <<= 9;
  301. lastBlock <<= 9;
  302. }
  303. if (cardCommand(CMD32, firstBlock)
  304. || cardCommand(CMD33, lastBlock)
  305. || cardCommand(CMD38, 0)) {
  306. error(SD_CARD_ERROR_ERASE);
  307. goto fail;
  308. }
  309. if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
  310. error(SD_CARD_ERROR_ERASE_TIMEOUT);
  311. goto fail;
  312. }
  313. chipSelectHigh();
  314. return true;
  315. fail:
  316. chipSelectHigh();
  317. return false;
  318. }
  319. //------------------------------------------------------------------------------
  320. bool SdSpiCard::eraseSingleBlockEnable() {
  321. csd_t csd;
  322. return readCSD(&csd) ? csd.v1.erase_blk_en : false;
  323. }
  324. //------------------------------------------------------------------------------
  325. bool SdSpiCard::isBusy() {
  326. bool rtn;
  327. chipSelectLow();
  328. for (uint8_t i = 0; i < 8; i++) {
  329. rtn = spiReceive() != 0XFF;
  330. if (!rtn) {
  331. break;
  332. }
  333. }
  334. chipSelectHigh();
  335. return rtn;
  336. }
  337. //------------------------------------------------------------------------------
  338. bool SdSpiCard::readBlock(uint32_t blockNumber, uint8_t* dst) {
  339. SD_TRACE("RB", blockNumber);
  340. // use address if not SDHC card
  341. if (type() != SD_CARD_TYPE_SDHC) {
  342. blockNumber <<= 9;
  343. }
  344. if (cardCommand(CMD17, blockNumber)) {
  345. error(SD_CARD_ERROR_CMD17);
  346. goto fail;
  347. }
  348. return readData(dst, 512);
  349. fail:
  350. chipSelectHigh();
  351. return false;
  352. }
  353. //------------------------------------------------------------------------------
  354. bool SdSpiCard::readBlocks(uint32_t block, uint8_t* dst, size_t count) {
  355. if (!readStart(block)) {
  356. return false;
  357. }
  358. for (uint16_t b = 0; b < count; b++, dst += 512) {
  359. if (!readData(dst)) {
  360. return false;
  361. }
  362. }
  363. return readStop();
  364. }
  365. //------------------------------------------------------------------------------
  366. bool SdSpiCard::readData(uint8_t *dst) {
  367. chipSelectLow();
  368. return readData(dst, 512);
  369. }
  370. //------------------------------------------------------------------------------
  371. bool SdSpiCard::readData(uint8_t* dst, size_t count) {
  372. #if USE_SD_CRC
  373. uint16_t crc;
  374. #endif // USE_SD_CRC
  375. // wait for start block token
  376. uint16_t t0 = millis();
  377. while ((m_status = spiReceive()) == 0XFF) {
  378. if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
  379. error(SD_CARD_ERROR_READ_TIMEOUT);
  380. goto fail;
  381. }
  382. }
  383. if (m_status != DATA_START_BLOCK) {
  384. error(SD_CARD_ERROR_READ);
  385. goto fail;
  386. }
  387. // transfer data
  388. if ((m_status = spiReceive(dst, count))) {
  389. error(SD_CARD_ERROR_SPI_DMA);
  390. goto fail;
  391. }
  392. #if USE_SD_CRC
  393. // get crc
  394. crc = (spiReceive() << 8) | spiReceive();
  395. if (crc != CRC_CCITT(dst, count)) {
  396. error(SD_CARD_ERROR_READ_CRC);
  397. goto fail;
  398. }
  399. #else
  400. // discard crc
  401. spiReceive();
  402. spiReceive();
  403. #endif // USE_SD_CRC
  404. chipSelectHigh();
  405. return true;
  406. fail:
  407. chipSelectHigh();
  408. return false;
  409. }
  410. //------------------------------------------------------------------------------
  411. bool SdSpiCard::readOCR(uint32_t* ocr) {
  412. uint8_t *p = reinterpret_cast<uint8_t*>(ocr);
  413. if (cardCommand(CMD58, 0)) {
  414. error(SD_CARD_ERROR_CMD58);
  415. goto fail;
  416. }
  417. for (uint8_t i = 0; i < 4; i++) {
  418. p[3 - i] = spiReceive();
  419. }
  420. chipSelectHigh();
  421. return true;
  422. fail:
  423. chipSelectHigh();
  424. return false;
  425. }
  426. //------------------------------------------------------------------------------
  427. /** read CID or CSR register */
  428. bool SdSpiCard::readRegister(uint8_t cmd, void* buf) {
  429. uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
  430. if (cardCommand(cmd, 0)) {
  431. error(SD_CARD_ERROR_READ_REG);
  432. goto fail;
  433. }
  434. return readData(dst, 16);
  435. fail:
  436. chipSelectHigh();
  437. return false;
  438. }
  439. //------------------------------------------------------------------------------
  440. bool SdSpiCard::readStart(uint32_t blockNumber) {
  441. SD_TRACE("RS", blockNumber);
  442. if (type() != SD_CARD_TYPE_SDHC) {
  443. blockNumber <<= 9;
  444. }
  445. if (cardCommand(CMD18, blockNumber)) {
  446. error(SD_CARD_ERROR_CMD18);
  447. goto fail;
  448. }
  449. chipSelectHigh();
  450. return true;
  451. fail:
  452. chipSelectHigh();
  453. return false;
  454. }
  455. //------------------------------------------------------------------------------
  456. bool SdSpiCard::readStop() {
  457. if (cardCommand(CMD12, 0)) {
  458. error(SD_CARD_ERROR_CMD12);
  459. goto fail;
  460. }
  461. chipSelectHigh();
  462. return true;
  463. fail:
  464. chipSelectHigh();
  465. return false;
  466. }
  467. //------------------------------------------------------------------------------
  468. // wait for card to go not busy
  469. bool SdSpiCard::waitNotBusy(uint16_t timeoutMillis) {
  470. uint16_t t0 = millis();
  471. while (spiReceive() != 0XFF) {
  472. if (((uint16_t)millis() - t0) >= timeoutMillis) {
  473. goto fail;
  474. }
  475. spiYield();
  476. }
  477. return true;
  478. fail:
  479. return false;
  480. }
  481. //------------------------------------------------------------------------------
  482. bool SdSpiCard::writeBlock(uint32_t blockNumber, const uint8_t* src) {
  483. SD_TRACE("WB", blockNumber);
  484. // use address if not SDHC card
  485. if (type() != SD_CARD_TYPE_SDHC) {
  486. blockNumber <<= 9;
  487. }
  488. if (cardCommand(CMD24, blockNumber)) {
  489. error(SD_CARD_ERROR_CMD24);
  490. goto fail;
  491. }
  492. if (!writeData(DATA_START_BLOCK, src)) {
  493. goto fail;
  494. }
  495. #define CHECK_PROGRAMMING 0
  496. #if CHECK_PROGRAMMING
  497. // wait for flash programming to complete
  498. if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
  499. error(SD_CARD_ERROR_WRITE_TIMEOUT);
  500. goto fail;
  501. }
  502. // response is r2 so get and check two bytes for nonzero
  503. if (cardCommand(CMD13, 0) || spiReceive()) {
  504. error(SD_CARD_ERROR_WRITE_PROGRAMMING);
  505. goto fail;
  506. }
  507. #endif // CHECK_PROGRAMMING
  508. chipSelectHigh();
  509. return true;
  510. fail:
  511. chipSelectHigh();
  512. return false;
  513. }
  514. //------------------------------------------------------------------------------
  515. bool SdSpiCard::writeBlocks(uint32_t block, const uint8_t* src, size_t count) {
  516. if (!writeStart(block, count)) {
  517. return false;
  518. }
  519. for (size_t b = 0; b < count; b++, src += 512) {
  520. if (!writeData(src)) {
  521. return false;
  522. }
  523. }
  524. return writeStop();
  525. }
  526. //------------------------------------------------------------------------------
  527. bool SdSpiCard::writeData(const uint8_t* src) {
  528. chipSelectLow();
  529. // wait for previous write to finish
  530. if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
  531. goto fail;
  532. }
  533. if (!writeData(WRITE_MULTIPLE_TOKEN, src)) {
  534. goto fail;
  535. }
  536. chipSelectHigh();
  537. return true;
  538. fail:
  539. error(SD_CARD_ERROR_WRITE_MULTIPLE);
  540. chipSelectHigh();
  541. return false;
  542. }
  543. //------------------------------------------------------------------------------
  544. // send one block of data for write block or write multiple blocks
  545. bool SdSpiCard::writeData(uint8_t token, const uint8_t* src) {
  546. #if USE_SD_CRC
  547. uint16_t crc = CRC_CCITT(src, 512);
  548. #else // USE_SD_CRC
  549. uint16_t crc = 0XFFFF;
  550. #endif // USE_SD_CRC
  551. spiSend(token);
  552. spiSend(src, 512);
  553. spiSend(crc >> 8);
  554. spiSend(crc & 0XFF);
  555. m_status = spiReceive();
  556. if ((m_status & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
  557. error(SD_CARD_ERROR_WRITE);
  558. goto fail;
  559. }
  560. return true;
  561. fail:
  562. chipSelectHigh();
  563. return false;
  564. }
  565. //------------------------------------------------------------------------------
  566. bool SdSpiCard::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
  567. SD_TRACE("WS", blockNumber);
  568. // send pre-erase count
  569. if (cardAcmd(ACMD23, eraseCount)) {
  570. error(SD_CARD_ERROR_ACMD23);
  571. goto fail;
  572. }
  573. // use address if not SDHC card
  574. if (type() != SD_CARD_TYPE_SDHC) {
  575. blockNumber <<= 9;
  576. }
  577. if (cardCommand(CMD25, blockNumber)) {
  578. error(SD_CARD_ERROR_CMD25);
  579. goto fail;
  580. }
  581. chipSelectHigh();
  582. return true;
  583. fail:
  584. chipSelectHigh();
  585. return false;
  586. }
  587. //------------------------------------------------------------------------------
  588. bool SdSpiCard::writeStop() {
  589. chipSelectLow();
  590. if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
  591. goto fail;
  592. }
  593. spiSend(STOP_TRAN_TOKEN);
  594. if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
  595. goto fail;
  596. }
  597. chipSelectHigh();
  598. return true;
  599. fail:
  600. error(SD_CARD_ERROR_STOP_TRAN);
  601. chipSelectHigh();
  602. return false;
  603. }