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
GET_BITS(rt_uint32_t * resp,rt_uint32_t start,rt_uint32_t size)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
mmcsd_parse_csd(struct rt_mmcsd_card * card)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
mmcsd_parse_scr(struct rt_mmcsd_card * card)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
mmcsd_switch(struct rt_mmcsd_card * card)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
mmcsd_app_cmd(struct rt_mmcsd_host * host,struct rt_mmcsd_card * card)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
mmcsd_send_app_cmd(struct rt_mmcsd_host * host,struct rt_mmcsd_card * card,struct rt_mmcsd_cmd * cmd,int retry)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
mmcsd_app_set_bus_width(struct rt_mmcsd_card * card,rt_int32_t width)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
mmcsd_send_app_op_cond(struct rt_mmcsd_host * host,rt_uint32_t ocr,rt_uint32_t * rocr)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 */
mmcsd_send_if_cond(struct rt_mmcsd_host * host,rt_uint32_t ocr)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
mmcsd_get_card_addr(struct rt_mmcsd_host * host,rt_uint32_t * rca)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
mmcsd_get_scr(struct rt_mmcsd_card * card,rt_uint32_t * scr)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
mmcsd_sd_init_card(struct rt_mmcsd_host * host,rt_uint32_t ocr)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 */
init_sd(struct rt_mmcsd_host * host,rt_uint32_t ocr)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