1 /* 2 * Copyright (c) 2006-2018, RT-Thread Development Team 3 * 4 * SPDX-License-Identifier: Apache-2.0 5 * 6 * Change Logs: 7 * Date Author Notes 8 * 2009-04-17 Bernard first version. 9 * 2010-07-15 aozima Modify read/write according new block driver interface. 10 * 2012-02-01 aozima use new RT-Thread SPI drivers. 11 * 2012-04-11 aozima get max. data transfer rate from CSD[TRAN_SPEED]. 12 * 2012-05-21 aozima update MMC card support. 13 * 2018-03-09 aozima fixed CSD Version 2.0 sector count calc. 14 */ 15 16 #include <string.h> 17 #include "spi_msd.h" 18 19 //#define MSD_TRACE 20 21 #ifdef MSD_TRACE 22 #define MSD_DEBUG(...) rt_kprintf("[MSD] %d ", rt_tick_get()); rt_kprintf(__VA_ARGS__); 23 #else 24 #define MSD_DEBUG(...) 25 #endif /* #ifdef MSD_TRACE */ 26 27 #define DUMMY 0xFF 28 29 #define CARD_NCR_MAX 9 30 31 #define CARD_NRC 1 32 #define CARD_NCR 1 33 34 static struct msd_device _msd_device; 35 36 /* function define */ 37 static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long); 38 39 static rt_err_t MSD_take_owner(struct rt_spi_device *spi_device); 40 41 static rt_err_t _wait_token(struct rt_spi_device *device, uint8_t token); 42 static rt_err_t _wait_ready(struct rt_spi_device *device); 43 static rt_err_t rt_msd_init(rt_device_t dev); 44 static rt_err_t rt_msd_open(rt_device_t dev, rt_uint16_t oflag); 45 static rt_err_t rt_msd_close(rt_device_t dev); 46 static rt_size_t rt_msd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size); 47 static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size); 48 static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size); 49 static rt_size_t rt_msd_sdhc_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size); 50 static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args); 51 52 static rt_err_t MSD_take_owner(struct rt_spi_device *spi_device) 53 { 54 rt_err_t result; 55 56 result = rt_mutex_take(&(spi_device->bus->lock), RT_WAITING_FOREVER); 57 if (result == RT_EOK) 58 { 59 if (spi_device->bus->owner != spi_device) 60 { 61 /* not the same owner as current, re-configure SPI bus */ 62 result = spi_device->bus->ops->configure(spi_device, &spi_device->config); 63 if (result == RT_EOK) 64 { 65 /* set SPI bus owner */ 66 spi_device->bus->owner = spi_device; 67 } 68 } 69 } 70 71 return result; 72 } 73 74 static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long) 75 { 76 rt_tick_t tick_end = tick_start + tick_long; 77 rt_tick_t tick_now = rt_tick_get(); 78 rt_bool_t result = RT_FALSE; 79 80 if (tick_end >= tick_start) 81 { 82 if (tick_now >= tick_end) 83 { 84 result = RT_TRUE; 85 } 86 else 87 { 88 result = RT_FALSE; 89 } 90 } 91 else 92 { 93 if ((tick_now < tick_start) && (tick_now >= tick_end)) 94 { 95 result = RT_TRUE; 96 } 97 else 98 { 99 result = RT_FALSE; 100 } 101 } 102 103 return result; 104 } 105 106 static uint8_t crc7(const uint8_t *buf, int len) 107 { 108 unsigned char i, j, crc, ch, ch2, ch3; 109 110 crc = 0; 111 112 for (i = 0; i < len; i ++) 113 { 114 ch = buf[i]; 115 116 for (j = 0; j < 8; j ++, ch <<= 1) 117 { 118 ch2 = (crc & 0x40) ? 1 : 0; 119 ch3 = (ch & 0x80) ? 1 : 0; 120 121 if (ch2 ^ ch3) 122 { 123 crc ^= 0x04; 124 crc <<= 1; 125 crc |= 0x01; 126 } 127 else 128 { 129 crc <<= 1; 130 } 131 } 132 } 133 134 return crc; 135 } 136 137 static rt_err_t _send_cmd( 138 struct rt_spi_device *device, 139 uint8_t cmd, 140 uint32_t arg, 141 uint8_t crc, 142 response_type type, 143 uint8_t *response 144 ) 145 { 146 struct rt_spi_message message; 147 uint8_t cmd_buffer[8]; 148 uint8_t recv_buffer[sizeof(cmd_buffer)]; 149 uint32_t i; 150 151 cmd_buffer[0] = DUMMY; 152 cmd_buffer[1] = (cmd | 0x40); 153 cmd_buffer[2] = (uint8_t)(arg >> 24); 154 cmd_buffer[3] = (uint8_t)(arg >> 16); 155 cmd_buffer[4] = (uint8_t)(arg >> 8); 156 cmd_buffer[5] = (uint8_t)(arg); 157 158 if (crc == 0x00) 159 { 160 crc = crc7(&cmd_buffer[1], 5); 161 crc = (crc << 1) | 0x01; 162 } 163 cmd_buffer[6] = (crc); 164 165 cmd_buffer[7] = DUMMY; 166 167 /* initial message */ 168 message.send_buf = cmd_buffer; 169 message.recv_buf = recv_buffer; 170 message.length = sizeof(cmd_buffer); 171 message.cs_take = message.cs_release = 0; 172 173 _wait_ready(device); 174 175 /* transfer message */ 176 device->bus->ops->xfer(device, &message); 177 178 for (i = CARD_NCR; i < (CARD_NCR_MAX + 1); i++) 179 { 180 uint8_t send = DUMMY; 181 182 /* initial message */ 183 message.send_buf = &send; 184 message.recv_buf = response; 185 message.length = 1; 186 message.cs_take = message.cs_release = 0; 187 188 /* transfer message */ 189 device->bus->ops->xfer(device, &message); 190 191 if (0 == (response[0] & 0x80)) 192 { 193 break; 194 } 195 } /* wait response */ 196 197 if ((CARD_NCR_MAX + 1) == i) 198 { 199 return RT_ERROR;//fail 200 } 201 202 //recieve other byte 203 if (type == response_r1) 204 { 205 return RT_EOK; 206 } 207 else if (type == response_r1b) 208 { 209 rt_tick_t tick_start = rt_tick_get(); 210 uint8_t recv; 211 212 while (1) 213 { 214 /* initial message */ 215 message.send_buf = RT_NULL; 216 message.recv_buf = &recv; 217 message.length = 1; 218 message.cs_take = message.cs_release = 0; 219 220 /* transfer message */ 221 device->bus->ops->xfer(device, &message); 222 223 if (recv == DUMMY) 224 { 225 return RT_EOK; 226 } 227 228 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(2000))) 229 { 230 return RT_ETIMEOUT; 231 } 232 } 233 } 234 else if (type == response_r2) 235 { 236 /* initial message */ 237 message.send_buf = RT_NULL; 238 message.recv_buf = response + 1; 239 message.length = 1; 240 message.cs_take = message.cs_release = 0; 241 242 /* transfer message */ 243 device->bus->ops->xfer(device, &message); 244 } 245 else if ((type == response_r3) || (type == response_r7)) 246 { 247 /* initial message */ 248 message.send_buf = RT_NULL; 249 message.recv_buf = response + 1; 250 message.length = 4; 251 message.cs_take = message.cs_release = 0; 252 253 /* transfer message */ 254 device->bus->ops->xfer(device, &message); 255 } 256 else 257 { 258 return RT_ERROR; // unknow type? 259 } 260 261 return RT_EOK; 262 } 263 264 static rt_err_t _wait_token(struct rt_spi_device *device, uint8_t token) 265 { 266 struct rt_spi_message message; 267 rt_tick_t tick_start; 268 uint8_t send, recv; 269 270 tick_start = rt_tick_get(); 271 272 /* wati token */ 273 /* initial message */ 274 send = DUMMY; 275 message.send_buf = &send; 276 message.recv_buf = &recv; 277 message.length = 1; 278 message.cs_take = message.cs_release = 0; 279 280 while (1) 281 { 282 /* transfer message */ 283 device->bus->ops->xfer(device, &message); 284 285 if (recv == token) 286 { 287 return RT_EOK; 288 } 289 290 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_WAIT_TOKEN_TIMES))) 291 { 292 MSD_DEBUG("[err] wait data start token timeout!\r\n"); 293 return RT_ETIMEOUT; 294 } 295 } /* wati token */ 296 } 297 298 static rt_err_t _wait_ready(struct rt_spi_device *device) 299 { 300 struct rt_spi_message message; 301 rt_tick_t tick_start; 302 uint8_t send, recv; 303 304 tick_start = rt_tick_get(); 305 306 send = DUMMY; 307 /* initial message */ 308 message.send_buf = &send; 309 message.recv_buf = &recv; 310 message.length = 1; 311 message.cs_take = message.cs_release = 0; 312 313 while (1) 314 { 315 /* transfer message */ 316 device->bus->ops->xfer(device, &message); 317 318 if (recv == DUMMY) 319 { 320 return RT_EOK; 321 } 322 323 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(1000))) 324 { 325 MSD_DEBUG("[err] wait ready timeout!\r\n"); 326 return RT_ETIMEOUT; 327 } 328 } 329 } 330 331 static rt_err_t _read_block(struct rt_spi_device *device, void *buffer, uint32_t block_size) 332 { 333 struct rt_spi_message message; 334 rt_err_t result; 335 336 /* wati token */ 337 result = _wait_token(device, MSD_TOKEN_READ_START); 338 if (result != RT_EOK) 339 { 340 return result; 341 } 342 343 /* read data */ 344 { 345 /* initial message */ 346 message.send_buf = RT_NULL; 347 message.recv_buf = buffer; 348 message.length = block_size; 349 message.cs_take = message.cs_release = 0; 350 351 /* transfer message */ 352 device->bus->ops->xfer(device, &message); 353 } /* read data */ 354 355 /* get crc */ 356 { 357 uint8_t recv_buffer[2]; 358 359 /* initial message */ 360 message.send_buf = RT_NULL; 361 message.recv_buf = recv_buffer; 362 message.length = 2; 363 message.cs_take = message.cs_release = 0; 364 365 /* transfer message */ 366 device->bus->ops->xfer(device, &message); 367 } /* get crc */ 368 369 return RT_EOK; 370 } 371 372 static rt_err_t _write_block(struct rt_spi_device *device, const void *buffer, uint32_t block_size, uint8_t token) 373 { 374 struct rt_spi_message message; 375 uint8_t send_buffer[16]; 376 377 rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); 378 send_buffer[sizeof(send_buffer) - 1] = token; 379 380 /* send start block token */ 381 { 382 /* initial message */ 383 message.send_buf = send_buffer; 384 message.recv_buf = RT_NULL; 385 message.length = sizeof(send_buffer); 386 message.cs_take = message.cs_release = 0; 387 388 /* transfer message */ 389 device->bus->ops->xfer(device, &message); 390 } 391 392 /* send data */ 393 { 394 /* initial message */ 395 message.send_buf = buffer; 396 message.recv_buf = RT_NULL; 397 message.length = block_size; 398 message.cs_take = message.cs_release = 0; 399 400 /* transfer message */ 401 device->bus->ops->xfer(device, &message); 402 } 403 404 /* put crc and get data response */ 405 { 406 uint8_t recv_buffer[3]; 407 uint8_t response; 408 409 /* initial message */ 410 message.send_buf = send_buffer; 411 message.recv_buf = recv_buffer; 412 message.length = sizeof(recv_buffer); 413 message.cs_take = message.cs_release = 0; 414 415 /* transfer message */ 416 device->bus->ops->xfer(device, &message); 417 418 // response = 0x0E & recv_buffer[2]; 419 response = MSD_GET_DATA_RESPONSE(recv_buffer[2]); 420 if (response != MSD_DATA_OK) 421 { 422 MSD_DEBUG("[err] write block fail! data response : 0x%02X\r\n", response); 423 return RT_ERROR; 424 } 425 } 426 427 /* wati ready */ 428 return _wait_ready(device); 429 } 430 431 #ifdef RT_USING_DEVICE_OPS 432 const static struct rt_device_ops msd_ops = 433 { 434 rt_msd_init, 435 rt_msd_open, 436 rt_msd_close, 437 rt_msd_read, 438 rt_msd_write, 439 rt_msd_control 440 }; 441 442 const static struct rt_device_ops msd_sdhc_ops = 443 { 444 rt_msd_init, 445 rt_msd_open, 446 rt_msd_close, 447 rt_msd_sdhc_read, 448 rt_msd_sdhc_write, 449 rt_msd_control 450 }; 451 #endif 452 453 /* RT-Thread Device Driver Interface */ 454 static rt_err_t rt_msd_init(rt_device_t dev) 455 { 456 struct msd_device *msd = (struct msd_device *)dev; 457 uint8_t response[MSD_RESPONSE_MAX_LEN]; 458 rt_err_t result = RT_EOK; 459 rt_tick_t tick_start; 460 uint32_t OCR; 461 462 if (msd->spi_device == RT_NULL) 463 { 464 MSD_DEBUG("[err] the SPI SD device has no SPI!\r\n"); 465 return RT_EIO; 466 } 467 468 /* config spi */ 469 { 470 struct rt_spi_configuration cfg; 471 cfg.data_width = 8; 472 cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ 473 cfg.max_hz = 1000 * 400; /* 400kbit/s */ 474 rt_spi_configure(msd->spi_device, &cfg); 475 } /* config spi */ 476 477 /* init SD card */ 478 { 479 struct rt_spi_message message; 480 481 result = MSD_take_owner(msd->spi_device); 482 483 if (result != RT_EOK) 484 { 485 goto _exit; 486 } 487 488 rt_spi_release(msd->spi_device); 489 490 /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and 491 start to supply at least 74 SD clocks to the SD card with keeping CMD line to high. 492 In case of SPI mode, CS shall be held to high during 74 clock cycles. */ 493 { 494 uint8_t send_buffer[100]; /* 100byte > 74 clock */ 495 496 /* initial message */ 497 memset(send_buffer, DUMMY, sizeof(send_buffer)); 498 message.send_buf = send_buffer; 499 message.recv_buf = RT_NULL; 500 message.length = sizeof(send_buffer); 501 message.cs_take = message.cs_release = 0; 502 503 /* transfer message */ 504 msd->spi_device->bus->ops->xfer(msd->spi_device, &message); 505 } /* send 74 clock */ 506 507 /* Send CMD0 (GO_IDLE_STATE) to put MSD in SPI mode */ 508 { 509 tick_start = rt_tick_get(); 510 511 while (1) 512 { 513 rt_spi_take(msd->spi_device); 514 result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response); 515 rt_spi_release(msd->spi_device); 516 517 if ((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE)) 518 { 519 break; 520 } 521 522 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) 523 { 524 MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); 525 result = RT_ETIMEOUT; 526 goto _exit; 527 } 528 } 529 530 MSD_DEBUG("[info] SD card goto IDLE mode OK!\r\n"); 531 } /* Send CMD0 (GO_IDLE_STATE) to put MSD in SPI mode */ 532 533 /* CMD8 */ 534 { 535 tick_start = rt_tick_get(); 536 537 do 538 { 539 rt_spi_take(msd->spi_device); 540 result = _send_cmd(msd->spi_device, SEND_IF_COND, 0x01AA, 0x87, response_r7, response); 541 rt_spi_release(msd->spi_device); 542 543 if (result == RT_EOK) 544 { 545 MSD_DEBUG("[info] CMD8 response : 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n", 546 response[0], response[1], response[2], response[3], response[4]); 547 548 if (response[0] & (1 << 2)) 549 { 550 /* illegal command, SD V1.x or MMC card */ 551 MSD_DEBUG("[info] CMD8 is illegal command.\r\n"); 552 MSD_DEBUG("[info] maybe Ver1.X SD Memory Card or MMC card!\r\n"); 553 msd->card_type = MSD_CARD_TYPE_SD_V1_X; 554 break; 555 } 556 else 557 { 558 /* SD V2.0 or later or SDHC or SDXC memory card! */ 559 MSD_DEBUG("[info] Ver2.00 or later or SDHC or SDXC memory card!\r\n"); 560 msd->card_type = MSD_CARD_TYPE_SD_V2_X; 561 } 562 563 if ((0xAA == response[4]) && (0x00 == response[3])) 564 { 565 /* SD2.0 not support current voltage */ 566 MSD_DEBUG("[err] VCA = 0, SD2.0 not surpport current operation voltage range\r\n"); 567 result = RT_ERROR; 568 goto _exit; 569 } 570 } 571 else 572 { 573 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(200))) 574 { 575 MSD_DEBUG("[err] CMD8 SEND_IF_COND timeout!\r\n"); 576 result = RT_ETIMEOUT; 577 goto _exit; 578 } 579 } 580 } 581 while (0xAA != response[4]); 582 } /* CMD8 */ 583 584 /* Ver1.X SD Memory Card or MMC card */ 585 if (msd->card_type == MSD_CARD_TYPE_SD_V1_X) 586 { 587 rt_bool_t is_sd_v1_x = RT_FALSE; 588 rt_tick_t tick_start; 589 590 /* try SD Ver1.x */ 591 while (1) 592 { 593 rt_spi_take(msd->spi_device); 594 595 result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); 596 if (result != RT_EOK) 597 { 598 rt_spi_release(msd->spi_device); 599 MSD_DEBUG("[info] It maybe SD1.x or MMC But it is Not response to CMD58!\r\n"); 600 goto _exit; 601 } 602 603 if (0 != (response[0] & 0xFE)) 604 { 605 rt_spi_release(msd->spi_device); 606 MSD_DEBUG("[info] It look CMD58 as illegal command so it is not SD card!\r\n"); 607 break; 608 } 609 rt_spi_release(msd->spi_device); 610 611 OCR = response[1]; 612 OCR = (OCR << 8) + response[2]; 613 OCR = (OCR << 8) + response[3]; 614 OCR = (OCR << 8) + response[4]; 615 MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR); 616 617 if (0 == (OCR & (0x1 << 15))) 618 { 619 MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n")); 620 result = RT_ERROR; 621 goto _exit; 622 } 623 624 /* --Send ACMD41 to make card ready */ 625 tick_start = rt_tick_get(); 626 627 /* try CMD55 + ACMD41 */ 628 while (1) 629 { 630 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41))) 631 { 632 rt_spi_release(msd->spi_device); 633 MSD_DEBUG("[info] try CMD55 + ACMD41 timeout! mabey MMC card!\r\n"); 634 break; 635 } 636 637 rt_spi_take(msd->spi_device); 638 639 /* CMD55 APP_CMD */ 640 result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); 641 if (result != RT_EOK) 642 { 643 rt_spi_release(msd->spi_device); 644 continue; 645 } 646 647 if (0 != (response[0] & 0xFE)) 648 { 649 rt_spi_release(msd->spi_device); 650 MSD_DEBUG("[info] Not SD card2 , may be MMC\r\n"); 651 break; 652 } 653 654 /* ACMD41 SD_SEND_OP_COND */ 655 result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x00, 0x00, response_r1, response); 656 if (result != RT_EOK) 657 { 658 rt_spi_release(msd->spi_device); 659 continue; 660 } 661 662 if (0 != (response[0] & 0xFE)) 663 { 664 rt_spi_release(msd->spi_device); 665 MSD_DEBUG("[info] Not SD card4 , may be MMC\r\n"); 666 break; 667 } 668 669 if (0 == (response[0] & 0xFF)) 670 { 671 rt_spi_release(msd->spi_device); 672 is_sd_v1_x = RT_TRUE; 673 MSD_DEBUG("[info] It is Ver1.X SD Memory Card!!!\r\n"); 674 break; 675 } 676 } /* try CMD55 + ACMD41 */ 677 678 break; 679 } /* try SD Ver1.x */ 680 681 /* try MMC */ 682 if (is_sd_v1_x != RT_TRUE) 683 { 684 uint32_t i; 685 686 MSD_DEBUG("[info] try MMC card!\r\n"); 687 rt_spi_release(msd->spi_device); 688 689 /* send dummy clock */ 690 { 691 uint8_t send_buffer[100]; 692 693 /* initial message */ 694 memset(send_buffer, DUMMY, sizeof(send_buffer)); 695 message.send_buf = send_buffer; 696 message.recv_buf = RT_NULL; 697 message.length = sizeof(send_buffer); 698 message.cs_take = message.cs_release = 0; 699 700 for (i = 0; i < 10; i++) 701 { 702 /* transfer message */ 703 msd->spi_device->bus->ops->xfer(msd->spi_device, &message); 704 } 705 } /* send dummy clock */ 706 707 /* send CMD0 goto IDLE state */ 708 tick_start = rt_tick_get(); 709 while (1) 710 { 711 rt_spi_take(msd->spi_device); 712 result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response); 713 rt_spi_release(msd->spi_device); 714 715 if ((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE)) 716 { 717 break; 718 } 719 720 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) 721 { 722 MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); 723 result = RT_ETIMEOUT; 724 goto _exit; 725 } 726 } /* send CMD0 goto IDLE stat */ 727 728 /* send CMD1 */ 729 tick_start = rt_tick_get(); 730 while (1) 731 { 732 rt_spi_take(msd->spi_device); 733 result = _send_cmd(msd->spi_device, SEND_OP_COND, 0x00, 0x00, response_r1, response); 734 rt_spi_release(msd->spi_device); 735 736 if ((result == RT_EOK) && (response[0] == MSD_RESPONSE_NO_ERROR)) 737 { 738 MSD_DEBUG("[info] It is MMC card!!!\r\n"); 739 msd->card_type = MSD_CARD_TYPE_MMC; 740 break; 741 } 742 743 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) 744 { 745 MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); 746 result = RT_ETIMEOUT; 747 goto _exit; 748 } 749 } /* send CMD1 */ 750 } /* try MMC */ 751 } 752 else if (msd->card_type == MSD_CARD_TYPE_SD_V2_X) 753 { 754 rt_spi_take(msd->spi_device); 755 756 result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); 757 if (result != RT_EOK) 758 { 759 rt_spi_release(msd->spi_device); 760 MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to CMD58!\r\n"); 761 goto _exit; 762 } 763 764 if ((response[0] & 0xFE) != 0) 765 { 766 rt_spi_release(msd->spi_device); 767 MSD_DEBUG("[err] It look CMD58 as illegal command so it is not SD card!\r\n"); 768 result = RT_ERROR; 769 goto _exit; 770 } 771 772 rt_spi_release(msd->spi_device); 773 774 OCR = response[1]; 775 OCR = (OCR << 8) + response[2]; 776 OCR = (OCR << 8) + response[3]; 777 OCR = (OCR << 8) + response[4]; 778 MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR); 779 780 if (0 == (OCR & (0x1 << 15))) 781 { 782 MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n")); 783 result = RT_ERROR; 784 goto _exit; 785 } 786 787 /* --Send ACMD41 to make card ready */ 788 tick_start = rt_tick_get(); 789 790 /* try CMD55 + ACMD41 */ 791 do 792 { 793 rt_spi_take(msd->spi_device); 794 if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41))) 795 { 796 rt_spi_release(msd->spi_device); 797 MSD_DEBUG("[err] SD Ver2.x or later try CMD55 + ACMD41 timeout!\r\n"); 798 result = RT_ERROR; 799 goto _exit; 800 } 801 802 /* CMD55 APP_CMD */ 803 result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x65, response_r1, response); 804 // if((result != RT_EOK) || (response[0] == 0x01)) 805 if (result != RT_EOK) 806 { 807 rt_spi_release(msd->spi_device); 808 continue; 809 } 810 811 if ((response[0] & 0xFE) != 0) 812 { 813 rt_spi_release(msd->spi_device); 814 MSD_DEBUG("[err] Not SD ready!\r\n"); 815 result = RT_ERROR; 816 goto _exit; 817 } 818 819 /* ACMD41 SD_SEND_OP_COND */ 820 result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x40000000, 0x77, response_r1, response); 821 if (result != RT_EOK) 822 { 823 rt_spi_release(msd->spi_device); 824 MSD_DEBUG("[err] ACMD41 fail!\r\n"); 825 result = RT_ERROR; 826 goto _exit; 827 } 828 829 if ((response[0] & 0xFE) != 0) 830 { 831 rt_spi_release(msd->spi_device); 832 MSD_DEBUG("[info] Not SD card4 , response : 0x%02X\r\n", response[0]); 833 // break; 834 } 835 } 836 while (response[0] != MSD_RESPONSE_NO_ERROR); 837 rt_spi_release(msd->spi_device); 838 /* try CMD55 + ACMD41 */ 839 840 /* --Read OCR again */ 841 rt_spi_take(msd->spi_device); 842 result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); 843 if (result != RT_EOK) 844 { 845 rt_spi_release(msd->spi_device); 846 MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to 2nd CMD58!\r\n"); 847 goto _exit; 848 } 849 850 if ((response[0] & 0xFE) != 0) 851 { 852 rt_spi_release(msd->spi_device); 853 MSD_DEBUG("[err] It look 2nd CMD58 as illegal command so it is not SD card!\r\n"); 854 result = RT_ERROR; 855 goto _exit; 856 } 857 rt_spi_release(msd->spi_device); 858 859 OCR = response[1]; 860 OCR = (OCR << 8) + response[2]; 861 OCR = (OCR << 8) + response[3]; 862 OCR = (OCR << 8) + response[4]; 863 MSD_DEBUG("[info] OCR 2nd read is 0x%08X\r\n", OCR); 864 865 if ((OCR & 0x40000000) != 0) 866 { 867 MSD_DEBUG("[info] It is SD2.0 SDHC Card!!!\r\n"); 868 msd->card_type = MSD_CARD_TYPE_SD_SDHC; 869 } 870 else 871 { 872 MSD_DEBUG("[info] It is SD2.0 standard capacity Card!!!\r\n"); 873 } 874 } /* MSD_CARD_TYPE_SD_V2_X */ 875 else 876 { 877 MSD_DEBUG("[err] SD card type unkonw!\r\n"); 878 result = RT_ERROR; 879 goto _exit; 880 } 881 } /* init SD card */ 882 883 if (msd->card_type == MSD_CARD_TYPE_SD_SDHC) 884 { 885 #ifdef RT_USING_DEVICE_OPS 886 dev->ops = &msd_sdhc_ops; 887 #else 888 dev->read = rt_msd_sdhc_read; 889 dev->write = rt_msd_sdhc_write; 890 #endif 891 } 892 else 893 { 894 #ifdef RT_USING_DEVICE_OPS 895 dev->ops = &msd_ops; 896 #else 897 dev->read = rt_msd_read; 898 dev->write = rt_msd_write; 899 #endif 900 } 901 902 /* set CRC */ 903 { 904 rt_spi_release(msd->spi_device); 905 rt_spi_take(msd->spi_device); 906 #ifdef MSD_USE_CRC 907 result = _send_cmd(msd->spi_device, CRC_ON_OFF, 0x01, 0x83, response_r1, response); 908 #else 909 result = _send_cmd(msd->spi_device, CRC_ON_OFF, 0x00, 0x91, response_r1, response); 910 #endif 911 rt_spi_release(msd->spi_device); 912 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 913 { 914 MSD_DEBUG("[err] CMD59 CRC_ON_OFF fail! response : 0x%02X\r\n", response[0]); 915 result = RT_ERROR; 916 goto _exit; 917 } 918 } /* set CRC */ 919 920 /* CMD16 SET_BLOCKLEN */ 921 { 922 rt_spi_release(msd->spi_device); 923 rt_spi_take(msd->spi_device); 924 result = _send_cmd(msd->spi_device, SET_BLOCKLEN, SECTOR_SIZE, 0x00, response_r1, response); 925 rt_spi_release(msd->spi_device); 926 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 927 { 928 MSD_DEBUG("[err] CMD16 SET_BLOCKLEN fail! response : 0x%02X\r\n", response[0]); 929 result = RT_ERROR; 930 goto _exit; 931 } 932 msd->geometry.block_size = SECTOR_SIZE; 933 msd->geometry.bytes_per_sector = SECTOR_SIZE; 934 } 935 936 /* read CSD */ 937 { 938 uint8_t CSD_buffer[MSD_CSD_LEN]; 939 940 rt_spi_take(msd->spi_device); 941 // result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0xAF, response_r1, response); 942 result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0x00, response_r1, response); 943 944 if (result != RT_EOK) 945 { 946 rt_spi_release(msd->spi_device); 947 MSD_DEBUG("[err] CMD9 SEND_CSD timeout!\r\n"); 948 goto _exit; 949 } 950 951 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 952 { 953 rt_spi_release(msd->spi_device); 954 MSD_DEBUG("[err] CMD9 SEND_CSD fail! response : 0x%02X\r\n", response[0]); 955 result = RT_ERROR; 956 goto _exit; 957 } 958 959 result = _read_block(msd->spi_device, CSD_buffer, MSD_CSD_LEN); 960 rt_spi_release(msd->spi_device); 961 if (result != RT_EOK) 962 { 963 MSD_DEBUG("[err] read CSD fail!\r\n"); 964 goto _exit; 965 } 966 967 /* Analyze CSD */ 968 { 969 uint8_t CSD_STRUCTURE; 970 uint32_t C_SIZE; 971 uint32_t card_capacity; 972 973 uint8_t tmp8; 974 uint16_t tmp16; 975 uint32_t tmp32; 976 977 /* get CSD_STRUCTURE */ 978 tmp8 = CSD_buffer[0] & 0xC0; /* 0b11000000 */ 979 CSD_STRUCTURE = tmp8 >> 6; 980 981 /* MMC CSD Analyze. */ 982 if (msd->card_type == MSD_CARD_TYPE_MMC) 983 { 984 uint8_t C_SIZE_MULT; 985 uint8_t READ_BL_LEN; 986 987 if (CSD_STRUCTURE > 2) 988 { 989 MSD_DEBUG("[err] bad CSD Version : %d\r\n", CSD_STRUCTURE); 990 result = RT_ERROR; 991 goto _exit; 992 } 993 994 if (CSD_STRUCTURE == 0) 995 { 996 MSD_DEBUG("[info] CSD version No. 1.0\r\n"); 997 } 998 else if (CSD_STRUCTURE == 1) 999 { 1000 MSD_DEBUG("[info] CSD version No. 1.1\r\n"); 1001 } 1002 else if (CSD_STRUCTURE == 2) 1003 { 1004 MSD_DEBUG("[info] CSD version No. 1.2\r\n"); 1005 } 1006 1007 /* get TRAN_SPEED 8bit [103:96] */ 1008 tmp8 = CSD_buffer[3]; 1009 tmp8 &= 0x03; /* [2:0] transfer rate unit.*/ 1010 if (tmp8 == 0) 1011 { 1012 msd->max_clock = 100 * 1000; /* 0=100kbit/s. */ 1013 } 1014 else if (tmp8 == 1) 1015 { 1016 msd->max_clock = 1 * 1000 * 1000; /* 1=1Mbit/s. */ 1017 } 1018 else if (tmp8 == 2) 1019 { 1020 msd->max_clock = 10 * 1000 * 1000; /* 2=10Mbit/s. */ 1021 } 1022 else if (tmp8 == 3) 1023 { 1024 msd->max_clock = 100 * 1000 * 1000; /* 3=100Mbit/s. */ 1025 } 1026 if (tmp8 == 0) 1027 { 1028 MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dkbit/s.\r\n", tmp8, msd->max_clock / 1000); 1029 } 1030 else 1031 { 1032 MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000); 1033 } 1034 1035 /* get READ_BL_LEN 4bit [83:80] */ 1036 tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */ 1037 READ_BL_LEN = tmp8; /* 4 bit */ 1038 MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN)); 1039 1040 /* get C_SIZE 12bit [73:62] */ 1041 tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */ 1042 tmp16 = tmp16 << 8; 1043 tmp16 += CSD_buffer[7]; /* get [71:64] */ 1044 tmp16 = tmp16 << 2; 1045 tmp8 = CSD_buffer[8] & 0xC0; /* get [63:62] 0b11000000 */ 1046 tmp8 = tmp8 >> 6; 1047 tmp16 = tmp16 + tmp8; 1048 C_SIZE = tmp16; //12 bit 1049 MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); 1050 1051 /* get C_SIZE_MULT 3bit [49:47] */ 1052 tmp8 = CSD_buffer[9] & 0x03;//0b00000011; 1053 tmp8 = tmp8 << 1; 1054 tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/) >> 7); 1055 C_SIZE_MULT = tmp8; // 3 bit 1056 MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT); 1057 1058 /* memory capacity = BLOCKNR * BLOCK_LEN */ 1059 /* BLOCKNR = (C_SIZE+1) * MULT */ 1060 /* MULT = 2^(C_SIZE_MULT+2) */ 1061 /* BLOCK_LEN = 2^READ_BL_LEN */ 1062 card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT + 2))); 1063 msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector; 1064 MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity / (1024 * 1024)); 1065 } 1066 else /* SD CSD Analyze. */ 1067 { 1068 if (CSD_STRUCTURE == 0) 1069 { 1070 uint8_t C_SIZE_MULT; 1071 uint8_t READ_BL_LEN; 1072 1073 MSD_DEBUG("[info] CSD Version 1.0\r\n"); 1074 1075 /* get TRAN_SPEED 8bit [103:96] */ 1076 tmp8 = CSD_buffer[3]; 1077 if (tmp8 == 0x32) 1078 { 1079 msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */ 1080 } 1081 else if (tmp8 == 0x5A) 1082 { 1083 msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */ 1084 } 1085 else 1086 { 1087 msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */ 1088 } 1089 MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000); 1090 1091 /* get READ_BL_LEN 4bit [83:80] */ 1092 tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */ 1093 READ_BL_LEN = tmp8; /* 4 bit */ 1094 MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN)); 1095 1096 /* get C_SIZE 12bit [73:62] */ 1097 tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */ 1098 tmp16 = tmp16 << 8; 1099 tmp16 += CSD_buffer[7]; /* get [71:64] */ 1100 tmp16 = tmp16 << 2; 1101 tmp8 = CSD_buffer[8] & 0xC0; /* get [63:62] 0b11000000 */ 1102 tmp8 = tmp8 >> 6; 1103 tmp16 = tmp16 + tmp8; 1104 C_SIZE = tmp16; //12 bit 1105 MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); 1106 1107 /* get C_SIZE_MULT 3bit [49:47] */ 1108 tmp8 = CSD_buffer[9] & 0x03;//0b00000011; 1109 tmp8 = tmp8 << 1; 1110 tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/) >> 7); 1111 C_SIZE_MULT = tmp8; // 3 bit 1112 MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT); 1113 1114 /* memory capacity = BLOCKNR * BLOCK_LEN */ 1115 /* BLOCKNR = (C_SIZE+1) * MULT */ 1116 /* MULT = 2^(C_SIZE_MULT+2) */ 1117 /* BLOCK_LEN = 2^READ_BL_LEN */ 1118 card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT + 2))); 1119 msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector; 1120 MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity / (1024 * 1024)); 1121 } 1122 else if (CSD_STRUCTURE == 1) 1123 { 1124 MSD_DEBUG("[info] CSD Version 2.0\r\n"); 1125 1126 /* get TRAN_SPEED 8bit [103:96] */ 1127 tmp8 = CSD_buffer[3]; 1128 if (tmp8 == 0x32) 1129 { 1130 msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */ 1131 } 1132 else if (tmp8 == 0x5A) 1133 { 1134 msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */ 1135 } 1136 else if (tmp8 == 0x0B) 1137 { 1138 msd->max_clock = 1000 * 1000 * 100; /* 100Mbit/s. */ 1139 /* UHS50 Card sets TRAN_SPEED to 0Bh (100Mbit/sec), */ 1140 /* for both SDR50 and DDR50 modes. */ 1141 } 1142 else if (tmp8 == 0x2B) 1143 { 1144 msd->max_clock = 1000 * 1000 * 200; /* 200Mbit/s. */ 1145 /* UHS104 Card sets TRAN_SPEED to 2Bh (200Mbit/sec). */ 1146 } 1147 else 1148 { 1149 msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */ 1150 } 1151 MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000); 1152 1153 /* get C_SIZE 22bit [69:48] */ 1154 tmp32 = CSD_buffer[7] & 0x3F; /* 0b00111111 */ 1155 tmp32 = tmp32 << 8; 1156 tmp32 += CSD_buffer[8]; 1157 tmp32 = tmp32 << 8; 1158 tmp32 += CSD_buffer[9]; 1159 C_SIZE = tmp32; 1160 MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); 1161 1162 /* memory capacity = (C_SIZE+1) * 512K byte */ 1163 card_capacity = (C_SIZE + 1) / 2; /* unit : Mbyte */ 1164 msd->geometry.sector_count = (C_SIZE + 1) * 1024; /* 512KB = 1024sector */ 1165 MSD_DEBUG("[info] card capacity : %d.%d Gbyte\r\n", card_capacity / 1024, (card_capacity % 1024) * 100 / 1024); 1166 MSD_DEBUG("[info] sector_count : %d\r\n", msd->geometry.sector_count); 1167 } 1168 else 1169 { 1170 MSD_DEBUG("[err] bad CSD Version : %d\r\n", CSD_STRUCTURE); 1171 result = RT_ERROR; 1172 goto _exit; 1173 } 1174 } /* SD CSD Analyze. */ 1175 } /* Analyze CSD */ 1176 1177 } /* read CSD */ 1178 1179 /* config spi to high speed */ 1180 { 1181 struct rt_spi_configuration cfg; 1182 cfg.data_width = 8; 1183 cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ 1184 cfg.max_hz = msd->max_clock; 1185 rt_spi_configure(msd->spi_device, &cfg); 1186 } /* config spi */ 1187 1188 _exit: 1189 rt_spi_release(msd->spi_device); 1190 rt_mutex_release(&(msd->spi_device->bus->lock)); 1191 return result; 1192 } 1193 1194 static rt_err_t rt_msd_open(rt_device_t dev, rt_uint16_t oflag) 1195 { 1196 // struct msd_device * msd = (struct msd_device *)dev; 1197 return RT_EOK; 1198 } 1199 1200 static rt_err_t rt_msd_close(rt_device_t dev) 1201 { 1202 // struct msd_device * msd = (struct msd_device *)dev; 1203 return RT_EOK; 1204 } 1205 1206 static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) 1207 { 1208 struct msd_device *msd = (struct msd_device *)dev; 1209 uint8_t response[MSD_RESPONSE_MAX_LEN]; 1210 rt_err_t result = RT_EOK; 1211 1212 result = MSD_take_owner(msd->spi_device); 1213 1214 if (result != RT_EOK) 1215 { 1216 goto _exit; 1217 } 1218 1219 /* SINGLE_BLOCK? */ 1220 if (size == 1) 1221 { 1222 rt_spi_take(msd->spi_device); 1223 1224 result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); 1225 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1226 { 1227 MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); 1228 size = 0; 1229 goto _exit; 1230 } 1231 1232 result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector); 1233 if (result != RT_EOK) 1234 { 1235 MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); 1236 size = 0; 1237 } 1238 } 1239 else if (size > 1) 1240 { 1241 uint32_t i; 1242 1243 rt_spi_take(msd->spi_device); 1244 1245 result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); 1246 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1247 { 1248 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); 1249 size = 0; 1250 goto _exit; 1251 } 1252 1253 for (i = 0; i < size; i++) 1254 { 1255 result = _read_block(msd->spi_device, 1256 (uint8_t *)buffer + msd->geometry.bytes_per_sector * i, 1257 msd->geometry.bytes_per_sector); 1258 if (result != RT_EOK) 1259 { 1260 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); 1261 size = i; 1262 break; 1263 } 1264 } 1265 1266 /* send CMD12 stop transfer */ 1267 result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response); 1268 if (result != RT_EOK) 1269 { 1270 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n"); 1271 } 1272 } /* READ_MULTIPLE_BLOCK */ 1273 1274 _exit: 1275 /* release and exit */ 1276 rt_spi_release(msd->spi_device); 1277 rt_mutex_release(&(msd->spi_device->bus->lock)); 1278 1279 return size; 1280 } 1281 1282 static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) 1283 { 1284 struct msd_device *msd = (struct msd_device *)dev; 1285 uint8_t response[MSD_RESPONSE_MAX_LEN]; 1286 rt_err_t result = RT_EOK; 1287 1288 result = MSD_take_owner(msd->spi_device); 1289 1290 if (result != RT_EOK) 1291 { 1292 goto _exit; 1293 } 1294 1295 /* SINGLE_BLOCK? */ 1296 if (size == 1) 1297 { 1298 rt_spi_take(msd->spi_device); 1299 1300 result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos, 0x00, response_r1, response); 1301 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1302 { 1303 MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); 1304 size = 0; 1305 goto _exit; 1306 } 1307 1308 result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector); 1309 if (result != RT_EOK) 1310 { 1311 MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); 1312 size = 0; 1313 } 1314 } 1315 else if (size > 1) 1316 { 1317 uint32_t i; 1318 1319 rt_spi_take(msd->spi_device); 1320 1321 result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos, 0x00, response_r1, response); 1322 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1323 { 1324 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); 1325 size = 0; 1326 goto _exit; 1327 } 1328 1329 for (i = 0; i < size; i++) 1330 { 1331 result = _read_block(msd->spi_device, 1332 (uint8_t *)buffer + msd->geometry.bytes_per_sector * i, 1333 msd->geometry.bytes_per_sector); 1334 if (result != RT_EOK) 1335 { 1336 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); 1337 size = i; 1338 break; 1339 } 1340 } 1341 1342 /* send CMD12 stop transfer */ 1343 result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response); 1344 if (result != RT_EOK) 1345 { 1346 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n"); 1347 } 1348 } /* READ_MULTIPLE_BLOCK */ 1349 1350 _exit: 1351 /* release and exit */ 1352 rt_spi_release(msd->spi_device); 1353 rt_mutex_release(&(msd->spi_device->bus->lock)); 1354 1355 return size; 1356 } 1357 1358 static rt_size_t rt_msd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) 1359 { 1360 struct msd_device *msd = (struct msd_device *)dev; 1361 uint8_t response[MSD_RESPONSE_MAX_LEN]; 1362 rt_err_t result; 1363 1364 result = MSD_take_owner(msd->spi_device); 1365 1366 if (result != RT_EOK) 1367 { 1368 MSD_DEBUG("[err] get SPI owner fail!\r\n"); 1369 goto _exit; 1370 } 1371 1372 1373 /* SINGLE_BLOCK? */ 1374 if (size == 1) 1375 { 1376 rt_spi_take(msd->spi_device); 1377 result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); 1378 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1379 { 1380 MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n"); 1381 size = 0; 1382 goto _exit; 1383 } 1384 1385 result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START); 1386 if (result != RT_EOK) 1387 { 1388 MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); 1389 size = 0; 1390 } 1391 } 1392 else if (size > 1) 1393 { 1394 struct rt_spi_message message; 1395 uint32_t i; 1396 1397 rt_spi_take(msd->spi_device); 1398 1399 #ifdef MSD_USE_PRE_ERASED 1400 if (msd->card_type != MSD_CARD_TYPE_MMC) 1401 { 1402 /* CMD55 APP_CMD */ 1403 result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); 1404 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1405 { 1406 MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n"); 1407 size = 0; 1408 goto _exit; 1409 } 1410 1411 /* ACMD23 Pre-erased */ 1412 result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response); 1413 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1414 { 1415 MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n"); 1416 size = 0; 1417 goto _exit; 1418 } 1419 } 1420 #endif 1421 1422 result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); 1423 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1424 { 1425 MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n"); 1426 size = 0; 1427 goto _exit; 1428 } 1429 1430 /* write all block */ 1431 for (i = 0; i < size; i++) 1432 { 1433 result = _write_block(msd->spi_device, 1434 (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i, 1435 msd->geometry.bytes_per_sector, 1436 MSD_TOKEN_WRITE_MULTIPLE_START); 1437 if (result != RT_EOK) 1438 { 1439 MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); 1440 size = i; 1441 break; 1442 } 1443 } /* write all block */ 1444 1445 /* send stop token */ 1446 { 1447 uint8_t send_buffer[18]; 1448 1449 rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); 1450 send_buffer[sizeof(send_buffer) - 1] = MSD_TOKEN_WRITE_MULTIPLE_STOP; 1451 1452 /* initial message */ 1453 message.send_buf = send_buffer; 1454 message.recv_buf = RT_NULL; 1455 message.length = sizeof(send_buffer); 1456 message.cs_take = message.cs_release = 0; 1457 1458 /* transfer message */ 1459 msd->spi_device->bus->ops->xfer(msd->spi_device, &message); 1460 } 1461 1462 /* wait ready */ 1463 result = _wait_ready(msd->spi_device); 1464 if (result != RT_EOK) 1465 { 1466 MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n"); 1467 } 1468 } /* size > 1 */ 1469 1470 _exit: 1471 /* release and exit */ 1472 rt_spi_release(msd->spi_device); 1473 rt_mutex_release(&(msd->spi_device->bus->lock)); 1474 1475 return size; 1476 } 1477 1478 static rt_size_t rt_msd_sdhc_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) 1479 { 1480 struct msd_device *msd = (struct msd_device *)dev; 1481 uint8_t response[MSD_RESPONSE_MAX_LEN]; 1482 rt_err_t result; 1483 1484 result = MSD_take_owner(msd->spi_device); 1485 1486 if (result != RT_EOK) 1487 { 1488 goto _exit; 1489 } 1490 1491 /* SINGLE_BLOCK? */ 1492 if (size == 1) 1493 { 1494 rt_spi_take(msd->spi_device); 1495 result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos, 0x00, response_r1, response); 1496 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1497 { 1498 MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n"); 1499 size = 0; 1500 goto _exit; 1501 } 1502 1503 result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START); 1504 if (result != RT_EOK) 1505 { 1506 MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); 1507 size = 0; 1508 } 1509 } 1510 else if (size > 1) 1511 { 1512 struct rt_spi_message message; 1513 uint32_t i; 1514 1515 rt_spi_take(msd->spi_device); 1516 1517 #ifdef MSD_USE_PRE_ERASED 1518 /* CMD55 APP_CMD */ 1519 result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); 1520 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1521 { 1522 MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n"); 1523 size = 0; 1524 goto _exit; 1525 } 1526 1527 /* ACMD23 Pre-erased */ 1528 result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response); 1529 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1530 { 1531 MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n"); 1532 size = 0; 1533 goto _exit; 1534 } 1535 #endif 1536 1537 result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos, 0x00, response_r1, response); 1538 if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) 1539 { 1540 MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n"); 1541 size = 0; 1542 goto _exit; 1543 } 1544 1545 /* write all block */ 1546 for (i = 0; i < size; i++) 1547 { 1548 result = _write_block(msd->spi_device, 1549 (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i, 1550 msd->geometry.bytes_per_sector, 1551 MSD_TOKEN_WRITE_MULTIPLE_START); 1552 if (result != RT_EOK) 1553 { 1554 MSD_DEBUG("[err] write MULTIPLE_BLOCK #%d fail!\r\n", pos); 1555 size = i; 1556 break; 1557 } 1558 } /* write all block */ 1559 1560 /* send stop token */ 1561 { 1562 uint8_t send_buffer[18]; 1563 1564 rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); 1565 send_buffer[sizeof(send_buffer) - 1] = MSD_TOKEN_WRITE_MULTIPLE_STOP; 1566 1567 /* initial message */ 1568 message.send_buf = send_buffer; 1569 message.recv_buf = RT_NULL; 1570 message.length = sizeof(send_buffer); 1571 message.cs_take = message.cs_release = 0; 1572 1573 /* transfer message */ 1574 msd->spi_device->bus->ops->xfer(msd->spi_device, &message); 1575 } 1576 1577 result = _wait_ready(msd->spi_device); 1578 if (result != RT_EOK) 1579 { 1580 MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n"); 1581 } 1582 } /* size > 1 */ 1583 1584 _exit: 1585 /* release and exit */ 1586 rt_spi_release(msd->spi_device); 1587 rt_mutex_release(&(msd->spi_device->bus->lock)); 1588 1589 return size; 1590 } 1591 1592 static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args) 1593 { 1594 struct msd_device *msd = (struct msd_device *)dev; 1595 1596 RT_ASSERT(dev != RT_NULL); 1597 1598 if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME) 1599 { 1600 struct rt_device_blk_geometry *geometry; 1601 1602 geometry = (struct rt_device_blk_geometry *)args; 1603 if (geometry == RT_NULL) return -RT_ERROR; 1604 1605 geometry->bytes_per_sector = msd->geometry.bytes_per_sector; 1606 geometry->block_size = msd->geometry.block_size; 1607 geometry->sector_count = msd->geometry.sector_count; 1608 } 1609 1610 return RT_EOK; 1611 } 1612 1613 rt_err_t msd_init(const char *sd_device_name, const char *spi_device_name) 1614 { 1615 rt_err_t result = RT_EOK; 1616 struct rt_spi_device *spi_device; 1617 1618 spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name); 1619 if (spi_device == RT_NULL) 1620 { 1621 MSD_DEBUG("spi device %s not found!\r\n", spi_device_name); 1622 return -RT_ENOSYS; 1623 } 1624 rt_memset(&_msd_device, 0, sizeof(_msd_device)); 1625 _msd_device.spi_device = spi_device; 1626 1627 /* register sdcard device */ 1628 _msd_device.parent.type = RT_Device_Class_Block; 1629 1630 _msd_device.geometry.bytes_per_sector = 0; 1631 _msd_device.geometry.sector_count = 0; 1632 _msd_device.geometry.block_size = 0; 1633 1634 #ifdef RT_USING_DEVICE_OPS 1635 _msd_device.parent.ops = &msd_ops; 1636 #else 1637 _msd_device.parent.init = rt_msd_init; 1638 _msd_device.parent.open = rt_msd_open; 1639 _msd_device.parent.close = rt_msd_close; 1640 _msd_device.parent.read = RT_NULL; 1641 _msd_device.parent.write = RT_NULL; 1642 _msd_device.parent.control = rt_msd_control; 1643 #endif 1644 1645 /* no private, no callback */ 1646 _msd_device.parent.user_data = RT_NULL; 1647 _msd_device.parent.rx_indicate = RT_NULL; 1648 _msd_device.parent.tx_complete = RT_NULL; 1649 1650 result = rt_device_register(&_msd_device.parent, sd_device_name, 1651 RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); 1652 1653 return result; 1654 } 1655