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 * 2011-07-25 weety first version 9 */ 10 11 #include <drivers/mmcsd_core.h> 12 #include <drivers/sd.h> 13 14 #define DBG_ENABLE 15 #define DBG_SECTION_NAME "SDIO" 16 #ifdef RT_SDIO_DEBUG 17 #define DBG_LEVEL DBG_LOG 18 #else 19 #define DBG_LEVEL DBG_INFO 20 #endif /* RT_SDIO_DEBUG */ 21 #define DBG_COLOR 22 #include <rtdbg.h> 23 24 static const rt_uint32_t tran_unit[] = 25 { 26 10000, 100000, 1000000, 10000000, 27 0, 0, 0, 0 28 }; 29 30 static const rt_uint8_t tran_value[] = 31 { 32 0, 10, 12, 13, 15, 20, 25, 30, 33 35, 40, 45, 50, 55, 60, 70, 80, 34 }; 35 36 static const rt_uint32_t tacc_uint[] = 37 { 38 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 39 }; 40 41 static const rt_uint8_t tacc_value[] = 42 { 43 0, 10, 12, 13, 15, 20, 25, 30, 44 35, 40, 45, 50, 55, 60, 70, 80, 45 }; 46 47 rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp, 48 rt_uint32_t start, 49 rt_uint32_t size) 50 { 51 const rt_int32_t __size = size; 52 const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; 53 const rt_int32_t __off = 3 - ((start) / 32); 54 const rt_int32_t __shft = (start) & 31; 55 rt_uint32_t __res; 56 57 __res = resp[__off] >> __shft; 58 if (__size + __shft > 32) 59 __res |= resp[__off-1] << ((32 - __shft) % 32); 60 61 return __res & __mask; 62 } 63 64 static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card) 65 { 66 struct rt_mmcsd_csd *csd = &card->csd; 67 rt_uint32_t *resp = card->resp_csd; 68 69 csd->csd_structure = GET_BITS(resp, 126, 2); 70 71 switch (csd->csd_structure) 72 { 73 case 0: 74 csd->taac = GET_BITS(resp, 112, 8); 75 csd->nsac = GET_BITS(resp, 104, 8); 76 csd->tran_speed = GET_BITS(resp, 96, 8); 77 csd->card_cmd_class = GET_BITS(resp, 84, 12); 78 csd->rd_blk_len = GET_BITS(resp, 80, 4); 79 csd->rd_blk_part = GET_BITS(resp, 79, 1); 80 csd->wr_blk_misalign = GET_BITS(resp, 78, 1); 81 csd->rd_blk_misalign = GET_BITS(resp, 77, 1); 82 csd->dsr_imp = GET_BITS(resp, 76, 1); 83 csd->c_size = GET_BITS(resp, 62, 12); 84 csd->c_size_mult = GET_BITS(resp, 47, 3); 85 csd->r2w_factor = GET_BITS(resp, 26, 3); 86 csd->wr_blk_len = GET_BITS(resp, 22, 4); 87 csd->wr_blk_partial = GET_BITS(resp, 21, 1); 88 csd->csd_crc = GET_BITS(resp, 1, 7); 89 90 card->card_blksize = 1 << csd->rd_blk_len; 91 card->card_capacity = (csd->c_size + 1) << (csd->c_size_mult + 2); 92 card->card_capacity *= card->card_blksize; 93 card->card_capacity >>= 10; /* unit:KB */ 94 card->tacc_clks = csd->nsac * 100; 95 card->tacc_ns = (tacc_uint[csd->taac&0x07] * tacc_value[(csd->taac&0x78)>>3] + 9) / 10; 96 card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3]; 97 98 #if 0 99 val = GET_BITS(resp, 115, 4); 100 unit = GET_BITS(resp, 112, 3); 101 csd->tacc_ns = (tacc_uint[unit] * tacc_value[val] + 9) / 10; 102 csd->tacc_clks = GET_BITS(resp, 104, 8) * 100; 103 104 val = GET_BITS(resp, 99, 4); 105 unit = GET_BITS(resp, 96, 3); 106 csd->max_data_rate = tran_unit[unit] * tran_value[val]; 107 csd->ccc = GET_BITS(resp, 84, 12); 108 109 unit = GET_BITS(resp, 47, 3); 110 val = GET_BITS(resp, 62, 12); 111 csd->device_size = (1 + val) << (unit + 2); 112 113 csd->read_bl_len = GET_BITS(resp, 80, 4); 114 csd->write_bl_len = GET_BITS(resp, 22, 4); 115 csd->r2w_factor = GET_BITS(resp, 26, 3); 116 #endif 117 break; 118 case 1: 119 card->flags |= CARD_FLAG_SDHC; 120 121 /*This field is fixed to 0Eh, which indicates 1 ms. 122 The host should not use TAAC, NSAC, and R2W_FACTOR 123 to calculate timeout and should uses fixed timeout 124 values for read and write operations*/ 125 csd->taac = GET_BITS(resp, 112, 8); 126 csd->nsac = GET_BITS(resp, 104, 8); 127 csd->tran_speed = GET_BITS(resp, 96, 8); 128 csd->card_cmd_class = GET_BITS(resp, 84, 12); 129 csd->rd_blk_len = GET_BITS(resp, 80, 4); 130 csd->rd_blk_part = GET_BITS(resp, 79, 1); 131 csd->wr_blk_misalign = GET_BITS(resp, 78, 1); 132 csd->rd_blk_misalign = GET_BITS(resp, 77, 1); 133 csd->dsr_imp = GET_BITS(resp, 76, 1); 134 csd->c_size = GET_BITS(resp, 48, 22); 135 136 csd->r2w_factor = GET_BITS(resp, 26, 3); 137 csd->wr_blk_len = GET_BITS(resp, 22, 4); 138 csd->wr_blk_partial = GET_BITS(resp, 21, 1); 139 csd->csd_crc = GET_BITS(resp, 1, 7); 140 141 card->card_blksize = 512; 142 card->card_capacity = (csd->c_size + 1) * 512; /* unit:KB */ 143 card->tacc_clks = 0; 144 card->tacc_ns = 0; 145 card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3]; 146 147 #if 0 148 csd->tacc_ns = 0; 149 csd->tacc_clks = 0; 150 151 val = GET_BITS(resp, 99, 4); 152 unit = GET_BITS(resp, 96, 3); 153 csd->max_data_rate = tran_unit[unit] * tran_value[val]; 154 csd->ccc = GET_BITS(resp, 84, 12); 155 156 val = GET_BITS(resp, 48, 22); 157 csd->device_size = (1 + val) << 10; 158 159 csd->read_bl_len = 9; 160 csd->write_bl_len = 9; 161 /* host should not use this factor and should use 250ms for write timeout */ 162 csd->r2w_factor = 2; 163 #endif 164 break; 165 default: 166 LOG_E("unrecognised CSD structure version %d!", csd->csd_structure); 167 168 return -RT_ERROR; 169 } 170 LOG_I("SD card capacity %d KB.", card->card_capacity); 171 172 return 0; 173 } 174 175 static rt_int32_t mmcsd_parse_scr(struct rt_mmcsd_card *card) 176 { 177 struct rt_sd_scr *scr = &card->scr; 178 rt_uint32_t resp[4]; 179 180 resp[3] = card->resp_scr[1]; 181 resp[2] = card->resp_scr[0]; 182 scr->sd_version = GET_BITS(resp, 56, 4); 183 scr->sd_bus_widths = GET_BITS(resp, 48, 4); 184 185 return 0; 186 } 187 188 static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) 189 { 190 rt_int32_t err; 191 struct rt_mmcsd_host *host = card->host; 192 struct rt_mmcsd_req req; 193 struct rt_mmcsd_cmd cmd; 194 struct rt_mmcsd_data data; 195 rt_uint8_t *buf; 196 197 buf = (rt_uint8_t*)rt_malloc(64); 198 if (!buf) 199 { 200 LOG_E("alloc memory failed!"); 201 202 return -RT_ENOMEM; 203 } 204 205 if (card->card_type != CARD_TYPE_SD) 206 goto err; 207 if (card->scr.sd_version < SCR_SPEC_VER_1) 208 goto err; 209 210 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 211 212 cmd.cmd_code = SD_SWITCH; 213 cmd.arg = 0x00FFFFF1; 214 cmd.flags = RESP_R1 | CMD_ADTC; 215 216 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data)); 217 218 mmcsd_set_data_timeout(&data, card); 219 220 data.blksize = 64; 221 data.blks = 1; 222 data.flags = DATA_DIR_READ; 223 data.buf = (rt_uint32_t *)buf; 224 225 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 226 227 req.cmd = &cmd; 228 req.data = &data; 229 230 mmcsd_send_request(host, &req); 231 232 if (cmd.err || data.err) 233 { 234 goto err1; 235 } 236 237 if (buf[13] & 0x02) 238 card->hs_max_data_rate = 50000000; 239 240 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 241 242 cmd.cmd_code = SD_SWITCH; 243 cmd.arg = 0x80FFFFF1; 244 cmd.flags = RESP_R1 | CMD_ADTC; 245 246 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data)); 247 248 mmcsd_set_data_timeout(&data, card); 249 250 data.blksize = 64; 251 data.blks = 1; 252 data.flags = DATA_DIR_READ; 253 data.buf = (rt_uint32_t *)buf; 254 255 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 256 257 req.cmd = &cmd; 258 req.data = &data; 259 260 mmcsd_send_request(host, &req); 261 262 if (cmd.err || data.err) 263 { 264 goto err1; 265 } 266 267 if ((buf[16] & 0xF) != 1) 268 { 269 LOG_E("switching card to high speed failed!"); 270 goto err; 271 } 272 273 card->flags |= CARD_FLAG_HIGHSPEED; 274 275 err: 276 rt_free(buf); 277 return 0; 278 279 err1: 280 if (cmd.err) 281 err = cmd.err; 282 if (data.err) 283 err = data.err; 284 285 return err; 286 } 287 288 static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host, 289 struct rt_mmcsd_card *card) 290 { 291 rt_err_t err; 292 struct rt_mmcsd_cmd cmd = {0}; 293 294 cmd.cmd_code = APP_CMD; 295 296 if (card) 297 { 298 cmd.arg = card->rca << 16; 299 cmd.flags = RESP_R1 | CMD_AC; 300 } 301 else 302 { 303 cmd.arg = 0; 304 cmd.flags = RESP_R1 | CMD_BCR; 305 } 306 307 err = mmcsd_send_cmd(host, &cmd, 0); 308 if (err) 309 return err; 310 311 /* Check that card supported application commands */ 312 if (!controller_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD)) 313 return -RT_ERROR; 314 315 return RT_EOK; 316 } 317 318 319 rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host, 320 struct rt_mmcsd_card *card, 321 struct rt_mmcsd_cmd *cmd, 322 int retry) 323 { 324 struct rt_mmcsd_req req; 325 326 rt_uint32_t i; 327 rt_err_t err; 328 329 err = -RT_ERROR; 330 331 /* 332 * We have to resend MMC_APP_CMD for each attempt so 333 * we cannot use the retries field in mmc_command. 334 */ 335 for (i = 0;i <= retry;i++) 336 { 337 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 338 339 err = mmcsd_app_cmd(host, card); 340 if (err) 341 { 342 /* no point in retrying; no APP commands allowed */ 343 if (controller_is_spi(host)) 344 { 345 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 346 break; 347 } 348 continue; 349 } 350 351 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 352 353 rt_memset(cmd->resp, 0, sizeof(cmd->resp)); 354 355 req.cmd = cmd; 356 //cmd->data = NULL; 357 358 mmcsd_send_request(host, &req); 359 360 err = cmd->err; 361 if (!cmd->err) 362 break; 363 364 /* no point in retrying illegal APP commands */ 365 if (controller_is_spi(host)) 366 { 367 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 368 break; 369 } 370 } 371 372 return err; 373 } 374 375 rt_err_t mmcsd_app_set_bus_width(struct rt_mmcsd_card *card, rt_int32_t width) 376 { 377 rt_err_t err; 378 struct rt_mmcsd_cmd cmd; 379 380 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 381 382 cmd.cmd_code = SD_APP_SET_BUS_WIDTH; 383 cmd.flags = RESP_R1 | CMD_AC; 384 385 switch (width) 386 { 387 case MMCSD_BUS_WIDTH_1: 388 cmd.arg = MMCSD_BUS_WIDTH_1; 389 break; 390 case MMCSD_BUS_WIDTH_4: 391 cmd.arg = MMCSD_BUS_WIDTH_4; 392 break; 393 default: 394 return -RT_ERROR; 395 } 396 397 err = mmcsd_send_app_cmd(card->host, card, &cmd, 3); 398 if (err) 399 return err; 400 401 return RT_EOK; 402 } 403 404 rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host, 405 rt_uint32_t ocr, 406 rt_uint32_t *rocr) 407 { 408 struct rt_mmcsd_cmd cmd; 409 rt_uint32_t i; 410 rt_err_t err = RT_EOK; 411 412 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 413 414 cmd.cmd_code = SD_APP_OP_COND; 415 if (controller_is_spi(host)) 416 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ 417 else 418 cmd.arg = ocr; 419 cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR; 420 421 for (i = 100; i; i--) 422 { 423 err = mmcsd_send_app_cmd(host, RT_NULL, &cmd, 3); 424 if (err) 425 break; 426 427 /* if we're just probing, do a single pass */ 428 if (ocr == 0) 429 break; 430 431 /* otherwise wait until reset completes */ 432 if (controller_is_spi(host)) 433 { 434 if (!(cmd.resp[0] & R1_SPI_IDLE)) 435 break; 436 } 437 else 438 { 439 if (cmd.resp[0] & CARD_BUSY) 440 break; 441 } 442 443 err = -RT_ETIMEOUT; 444 445 mmcsd_delay_ms(10); //delay 10ms 446 } 447 448 if (rocr && !controller_is_spi(host)) 449 *rocr = cmd.resp[0]; 450 451 return err; 452 } 453 454 /* 455 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND 456 * before SD_APP_OP_COND. This command will harmlessly fail for 457 * SD 1.0 cards. 458 */ 459 rt_err_t mmcsd_send_if_cond(struct rt_mmcsd_host *host, rt_uint32_t ocr) 460 { 461 struct rt_mmcsd_cmd cmd; 462 rt_err_t err; 463 rt_uint8_t pattern; 464 465 cmd.cmd_code = SD_SEND_IF_COND; 466 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | 0xAA; 467 cmd.flags = RESP_SPI_R7 | RESP_R7 | CMD_BCR; 468 469 err = mmcsd_send_cmd(host, &cmd, 0); 470 if (err) 471 return err; 472 473 if (controller_is_spi(host)) 474 pattern = cmd.resp[1] & 0xFF; 475 else 476 pattern = cmd.resp[0] & 0xFF; 477 478 if (pattern != 0xAA) 479 return -RT_ERROR; 480 481 return RT_EOK; 482 } 483 484 rt_err_t mmcsd_get_card_addr(struct rt_mmcsd_host *host, rt_uint32_t *rca) 485 { 486 rt_err_t err; 487 struct rt_mmcsd_cmd cmd; 488 489 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 490 491 cmd.cmd_code = SD_SEND_RELATIVE_ADDR; 492 cmd.arg = 0; 493 cmd.flags = RESP_R6 | CMD_BCR; 494 495 err = mmcsd_send_cmd(host, &cmd, 3); 496 if (err) 497 return err; 498 499 *rca = cmd.resp[0] >> 16; 500 501 return RT_EOK; 502 } 503 504 #define be32_to_cpu(x) ((rt_uint32_t)( \ 505 (((rt_uint32_t)(x) & (rt_uint32_t)0x000000ffUL) << 24) | \ 506 (((rt_uint32_t)(x) & (rt_uint32_t)0x0000ff00UL) << 8) | \ 507 (((rt_uint32_t)(x) & (rt_uint32_t)0x00ff0000UL) >> 8) | \ 508 (((rt_uint32_t)(x) & (rt_uint32_t)0xff000000UL) >> 24))) 509 510 rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr) 511 { 512 rt_int32_t err; 513 struct rt_mmcsd_req req; 514 struct rt_mmcsd_cmd cmd; 515 struct rt_mmcsd_data data; 516 517 err = mmcsd_app_cmd(card->host, card); 518 if (err) 519 return err; 520 521 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); 522 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); 523 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data)); 524 525 req.cmd = &cmd; 526 req.data = &data; 527 528 cmd.cmd_code = SD_APP_SEND_SCR; 529 cmd.arg = 0; 530 cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC; 531 532 data.blksize = 8; 533 data.blks = 1; 534 data.flags = DATA_DIR_READ; 535 data.buf = scr; 536 537 mmcsd_set_data_timeout(&data, card); 538 539 mmcsd_send_request(card->host, &req); 540 541 if (cmd.err) 542 return cmd.err; 543 if (data.err) 544 return data.err; 545 546 scr[0] = be32_to_cpu(scr[0]); 547 scr[1] = be32_to_cpu(scr[1]); 548 549 return 0; 550 } 551 552 553 static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, 554 rt_uint32_t ocr) 555 { 556 struct rt_mmcsd_card *card; 557 rt_int32_t err; 558 rt_uint32_t resp[4]; 559 rt_uint32_t max_data_rate; 560 561 mmcsd_go_idle(host); 562 563 /* 564 * If SD_SEND_IF_COND indicates an SD 2.0 565 * compliant card and we should set bit 30 566 * of the ocr to indicate that we can handle 567 * block-addressed SDHC cards. 568 */ 569 err = mmcsd_send_if_cond(host, ocr); 570 if (!err) 571 ocr |= 1 << 30; 572 573 err = mmcsd_send_app_op_cond(host, ocr, RT_NULL); 574 if (err) 575 goto err; 576 577 if (controller_is_spi(host)) 578 err = mmcsd_get_cid(host, resp); 579 else 580 err = mmcsd_all_get_cid(host, resp); 581 if (err) 582 goto err; 583 584 card = rt_malloc(sizeof(struct rt_mmcsd_card)); 585 if (!card) 586 { 587 LOG_E("malloc card failed!"); 588 err = -RT_ENOMEM; 589 goto err; 590 } 591 rt_memset(card, 0, sizeof(struct rt_mmcsd_card)); 592 593 card->card_type = CARD_TYPE_SD; 594 card->host = host; 595 rt_memcpy(card->resp_cid, resp, sizeof(card->resp_cid)); 596 597 /* 598 * For native busses: get card RCA and quit open drain mode. 599 */ 600 if (!controller_is_spi(host)) 601 { 602 err = mmcsd_get_card_addr(host, &card->rca); 603 if (err) 604 goto err1; 605 606 mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL); 607 } 608 609 err = mmcsd_get_csd(card, card->resp_csd); 610 if (err) 611 goto err1; 612 613 err = mmcsd_parse_csd(card); 614 if (err) 615 goto err1; 616 617 if (!controller_is_spi(host)) 618 { 619 err = mmcsd_select_card(card); 620 if (err) 621 goto err1; 622 } 623 624 err = mmcsd_get_scr(card, card->resp_scr); 625 if (err) 626 goto err1; 627 628 mmcsd_parse_scr(card); 629 630 if (controller_is_spi(host)) 631 { 632 err = mmcsd_spi_use_crc(host, 1); 633 if (err) 634 goto err1; 635 } 636 637 /* 638 * change SD card to high-speed, only SD2.0 spec 639 */ 640 err = mmcsd_switch(card); 641 if (err) 642 goto err1; 643 644 /* set bus speed */ 645 max_data_rate = (unsigned int)-1; 646 647 if (card->flags & CARD_FLAG_HIGHSPEED) 648 { 649 if (max_data_rate > card->hs_max_data_rate) 650 max_data_rate = card->hs_max_data_rate; 651 } 652 else if (max_data_rate > card->max_data_rate) 653 { 654 max_data_rate = card->max_data_rate; 655 } 656 657 mmcsd_set_clock(host, max_data_rate); 658 659 /*switch bus width*/ 660 if ((host->flags & MMCSD_BUSWIDTH_4) && 661 (card->scr.sd_bus_widths & SD_SCR_BUS_WIDTH_4)) 662 { 663 err = mmcsd_app_set_bus_width(card, MMCSD_BUS_WIDTH_4); 664 if (err) 665 goto err1; 666 667 mmcsd_set_bus_width(host, MMCSD_BUS_WIDTH_4); 668 } 669 670 host->card = card; 671 672 return 0; 673 674 err1: 675 rt_free(card); 676 err: 677 678 return err; 679 } 680 681 /* 682 * Starting point for SD card init. 683 */ 684 rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr) 685 { 686 rt_int32_t err; 687 rt_uint32_t current_ocr; 688 /* 689 * We need to get OCR a different way for SPI. 690 */ 691 if (controller_is_spi(host)) 692 { 693 mmcsd_go_idle(host); 694 695 err = mmcsd_spi_read_ocr(host, 0, &ocr); 696 if (err) 697 goto err; 698 } 699 700 if (ocr & VDD_165_195) 701 { 702 LOG_I(" SD card claims to support the " 703 "incompletely defined 'low voltage range'. This " 704 "will be ignored."); 705 ocr &= ~VDD_165_195; 706 } 707 708 current_ocr = mmcsd_select_voltage(host, ocr); 709 710 /* 711 * Can we support the voltage(s) of the card(s)? 712 */ 713 if (!current_ocr) 714 { 715 err = -RT_ERROR; 716 goto err; 717 } 718 719 /* 720 * Detect and init the card. 721 */ 722 err = mmcsd_sd_init_card(host, current_ocr); 723 if (err) 724 goto err; 725 726 mmcsd_host_unlock(host); 727 728 err = rt_mmcsd_blk_probe(host->card); 729 if (err) 730 goto remove_card; 731 mmcsd_host_lock(host); 732 733 return 0; 734 735 remove_card: 736 mmcsd_host_lock(host); 737 rt_mmcsd_blk_remove(host->card); 738 rt_free(host->card); 739 host->card = RT_NULL; 740 err: 741 742 LOG_D("init SD card failed!"); 743 744 return err; 745 } 746