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