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 * 2015-06-15 hichard first version
9 * 2024-05-25 HPMicro add HS400 support
10 */
11
12 #include <drivers/dev_mmcsd_core.h>
13 #include <drivers/dev_mmc.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
63 /*
64 * Given a 128-bit response, decode to our card CSD structure.
65 */
mmcsd_parse_csd(struct rt_mmcsd_card * card)66 static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
67 {
68 rt_uint32_t a, b;
69 struct rt_mmcsd_csd *csd = &card->csd;
70 rt_uint32_t *resp = card->resp_csd;
71
72 /*
73 * We only understand CSD structure v1.1 and v1.2.
74 * v1.2 has extra information in bits 15, 11 and 10.
75 * We also support eMMC v4.4 & v4.41.
76 */
77 csd->csd_structure = GET_BITS(resp, 126, 2);
78 if (csd->csd_structure == 0)
79 {
80 LOG_E("unrecognised CSD structure version %d!", csd->csd_structure);
81
82 return -RT_ERROR;
83 }
84
85 csd->taac = GET_BITS(resp, 112, 8);
86 csd->nsac = GET_BITS(resp, 104, 8);
87 csd->tran_speed = GET_BITS(resp, 96, 8);
88 csd->card_cmd_class = GET_BITS(resp, 84, 12);
89 csd->rd_blk_len = GET_BITS(resp, 80, 4);
90 csd->rd_blk_part = GET_BITS(resp, 79, 1);
91 csd->wr_blk_misalign = GET_BITS(resp, 78, 1);
92 csd->rd_blk_misalign = GET_BITS(resp, 77, 1);
93 csd->dsr_imp = GET_BITS(resp, 76, 1);
94 csd->c_size = GET_BITS(resp, 62, 12);
95 csd->c_size_mult = GET_BITS(resp, 47, 3);
96 csd->r2w_factor = GET_BITS(resp, 26, 3);
97 csd->wr_blk_len = GET_BITS(resp, 22, 4);
98 csd->wr_blk_partial = GET_BITS(resp, 21, 1);
99 csd->csd_crc = GET_BITS(resp, 1, 7);
100
101 card->card_blksize = 1 << csd->rd_blk_len;
102 card->tacc_clks = csd->nsac * 100;
103 card->tacc_ns = (tacc_uint[csd->taac & 0x07] * tacc_value[(csd->taac & 0x78) >> 3] + 9) / 10;
104 card->max_data_rate = tran_unit[csd->tran_speed & 0x07] * tran_value[(csd->tran_speed & 0x78) >> 3];
105 if (csd->wr_blk_len >= 9)
106 {
107 a = GET_BITS(resp, 42, 5);
108 b = GET_BITS(resp, 37, 5);
109 card->erase_size = (a + 1) * (b + 1);
110 card->erase_size <<= csd->wr_blk_len - 9;
111 }
112
113 return 0;
114 }
115
116 /*
117 * Read extended CSD.
118 */
mmc_get_ext_csd(struct rt_mmcsd_card * card,rt_uint8_t ** new_ext_csd)119 static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
120 {
121 void *ext_csd;
122 struct rt_mmcsd_req req;
123 struct rt_mmcsd_cmd cmd;
124 struct rt_mmcsd_data data;
125
126 *new_ext_csd = RT_NULL;
127 if (GET_BITS(card->resp_csd, 122, 4) < 4)
128 return 0;
129
130 /*
131 * As the ext_csd is so large and mostly unused, we don't store the
132 * raw block in mmc_card.
133 */
134 ext_csd = rt_malloc(512);
135 if (!ext_csd)
136 {
137 LOG_E("alloc memory failed when get ext csd!");
138 return -RT_ENOMEM;
139 }
140
141 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
142 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
143 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
144
145 req.cmd = &cmd;
146 req.data = &data;
147
148 cmd.cmd_code = SEND_EXT_CSD;
149 cmd.arg = 0;
150
151 /* NOTE HACK: the RESP_SPI_R1 is always correct here, but we
152 * rely on callers to never use this with "native" calls for reading
153 * CSD or CID. Native versions of those commands use the R2 type,
154 * not R1 plus a data block.
155 */
156 cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
157
158 data.blksize = 512;
159 data.blks = 1;
160 data.flags = DATA_DIR_READ;
161 data.buf = ext_csd;
162
163 /*
164 * Some cards require longer data read timeout than indicated in CSD.
165 * Address this by setting the read timeout to a "reasonably high"
166 * value. For the cards tested, 300ms has proven enough. If necessary,
167 * this value can be increased if other problematic cards require this.
168 */
169 data.timeout_ns = 300000000;
170 data.timeout_clks = 0;
171
172 mmcsd_send_request(card->host, &req);
173
174 if (cmd.err)
175 return cmd.err;
176 if (data.err)
177 return data.err;
178
179 *new_ext_csd = ext_csd;
180 return 0;
181 }
182
183 /*
184 * Decode extended CSD.
185 */
mmc_parse_ext_csd(struct rt_mmcsd_card * card,rt_uint8_t * ext_csd)186 static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
187 {
188 rt_uint64_t card_capacity = 0;
189 struct rt_mmcsd_host *host;
190 if (card == RT_NULL || ext_csd == RT_NULL)
191 {
192 LOG_E("emmc parse ext csd fail, invaild args");
193 return -1;
194 }
195
196 host = card->host;
197
198 uint8_t device_type = ext_csd[EXT_CSD_CARD_TYPE];
199 if ((host->flags & MMCSD_SUP_HS400) && (device_type & EXT_CSD_CARD_TYPE_HS400))
200 {
201 card->flags |= CARD_FLAG_HS400;
202 card->max_data_rate = 200000000;
203 }
204 else if ((host->flags & MMCSD_SUP_HS200) && (device_type & EXT_CSD_CARD_TYPE_HS200))
205 {
206 card->flags |= CARD_FLAG_HS200;
207 card->max_data_rate = 200000000;
208 }
209 else if ((host->flags & MMCSD_SUP_HIGHSPEED_DDR) && (device_type & EXT_CSD_CARD_TYPE_DDR_52))
210 {
211 card->flags |= CARD_FLAG_HIGHSPEED_DDR;
212 card->hs_max_data_rate = 52000000;
213 }
214 else
215 {
216 card->flags |= CARD_FLAG_HIGHSPEED;
217 card->hs_max_data_rate = 52000000;
218 }
219
220 if (ext_csd[EXT_CSD_STROBE_SUPPORT] != 0)
221 {
222 card->ext_csd.enhanced_data_strobe = 1;
223 }
224
225 card->ext_csd.cache_size =
226 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
227 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
228 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
229 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
230
231 card_capacity = *((rt_uint32_t *)&ext_csd[EXT_CSD_SEC_CNT]);
232 card->card_sec_cnt = card_capacity;
233 card_capacity *= card->card_blksize;
234 card_capacity >>= 10; /* unit:KB */
235 card->card_capacity = card_capacity;
236 LOG_I("emmc card capacity %d KB, card sec count:%d.", card->card_capacity, card->card_sec_cnt);
237
238 return 0;
239 }
240
241 /**
242 * mmc_switch - modify EXT_CSD register
243 * @card: the MMC card associated with the data transfer
244 * @set: cmd set values
245 * @index: EXT_CSD register index
246 * @value: value to program into EXT_CSD register
247 *
248 * Modifies the EXT_CSD register for selected card.
249 */
mmc_switch(struct rt_mmcsd_card * card,rt_uint8_t set,rt_uint8_t index,rt_uint8_t value)250 static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set,
251 rt_uint8_t index, rt_uint8_t value)
252 {
253 int err;
254 struct rt_mmcsd_host *host = card->host;
255 struct rt_mmcsd_cmd cmd = {0};
256
257 cmd.cmd_code = SWITCH;
258 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
259 (index << 16) | (value << 8) | set;
260 cmd.flags = RESP_R1B | CMD_AC;
261
262 err = mmcsd_send_cmd(host, &cmd, 3);
263 if (err)
264 return err;
265
266 return 0;
267 }
268
mmc_compare_ext_csds(struct rt_mmcsd_card * card,rt_uint8_t * ext_csd,rt_uint32_t bus_width)269 static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
270 rt_uint8_t *ext_csd, rt_uint32_t bus_width)
271 {
272 rt_uint8_t *bw_ext_csd;
273 int err;
274
275 if (bus_width == MMCSD_BUS_WIDTH_1)
276 return 0;
277
278 err = mmc_get_ext_csd(card, &bw_ext_csd);
279
280 if (err || bw_ext_csd == RT_NULL)
281 {
282 err = -RT_ERROR;
283 goto out;
284 }
285
286 /* only compare read only fields */
287 err = !((ext_csd[EXT_CSD_PARTITION_SUPPORT] == bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
288 (ext_csd[EXT_CSD_ERASED_MEM_CONT] == bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
289 (ext_csd[EXT_CSD_REV] == bw_ext_csd[EXT_CSD_REV]) &&
290 (ext_csd[EXT_CSD_STRUCTURE] == bw_ext_csd[EXT_CSD_STRUCTURE]) &&
291 (ext_csd[EXT_CSD_CARD_TYPE] == bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
292 (ext_csd[EXT_CSD_S_A_TIMEOUT] == bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
293 (ext_csd[EXT_CSD_HC_WP_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
294 (ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT] == bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
295 (ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
296 (ext_csd[EXT_CSD_SEC_TRIM_MULT] == bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
297 (ext_csd[EXT_CSD_SEC_ERASE_MULT] == bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
298 (ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT] == bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
299 (ext_csd[EXT_CSD_TRIM_MULT] == bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
300 (ext_csd[EXT_CSD_SEC_CNT + 0] == bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
301 (ext_csd[EXT_CSD_SEC_CNT + 1] == bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
302 (ext_csd[EXT_CSD_SEC_CNT + 2] == bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
303 (ext_csd[EXT_CSD_SEC_CNT + 3] == bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
304 (ext_csd[EXT_CSD_PWR_CL_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
305 (ext_csd[EXT_CSD_PWR_CL_26_195] == bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
306 (ext_csd[EXT_CSD_PWR_CL_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
307 (ext_csd[EXT_CSD_PWR_CL_26_360] == bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
308 (ext_csd[EXT_CSD_PWR_CL_200_195] == bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
309 (ext_csd[EXT_CSD_PWR_CL_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
310 (ext_csd[EXT_CSD_PWR_CL_DDR_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
311 (ext_csd[EXT_CSD_PWR_CL_DDR_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
312 (ext_csd[EXT_CSD_PWR_CL_DDR_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
313
314 if (err)
315 err = -RT_ERROR;
316
317 out:
318 rt_free(bw_ext_csd);
319 return err;
320 }
321
322 /*
323 * Select the bus width among 4-bit and 8-bit(SDR).
324 * If the bus width is changed successfully, return the selected width value.
325 * Zero is returned instead of error value if the wide width is not supported.
326 */
mmc_select_bus_width(struct rt_mmcsd_card * card,rt_uint8_t * ext_csd)327 static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
328 {
329 rt_uint32_t ext_csd_bits[][2] =
330 {
331 {EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8},
332 {EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4},
333 {EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1},
334 };
335 rt_uint32_t bus_widths[] =
336 {
337 MMCSD_BUS_WIDTH_8,
338 MMCSD_BUS_WIDTH_4,
339 MMCSD_BUS_WIDTH_1
340 };
341 struct rt_mmcsd_host *host = card->host;
342 unsigned idx, bus_width = 0;
343 int err = 0, ddr = 0;
344
345 if (GET_BITS(card->resp_csd, 122, 4) < 4)
346 return 0;
347
348 if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
349 {
350 ddr = 2;
351 }
352 /*
353 * Unlike SD, MMC cards don't have a configuration register to notify
354 * supported bus width. So bus test command should be run to identify
355 * the supported bus width or compare the EXT_CSD values of current
356 * bus width and EXT_CSD values of 1 bit mode read earlier.
357 */
358 for (idx = 0; idx < sizeof(bus_widths) / sizeof(rt_uint32_t); idx++)
359 {
360 /*
361 * Determine BUS WIDTH mode according to the capability of host
362 */
363 if (((ext_csd_bits[idx][0] == EXT_CSD_BUS_WIDTH_8) && ((host->flags & MMCSD_BUSWIDTH_8) == 0)) ||
364 ((ext_csd_bits[idx][0] == EXT_CSD_BUS_WIDTH_4) && ((host->flags & MMCSD_BUSWIDTH_4) == 0)))
365 {
366 continue;
367 }
368 bus_width = bus_widths[idx];
369 if (bus_width == MMCSD_BUS_WIDTH_1)
370 {
371 ddr = 0;
372 }
373
374 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
375 EXT_CSD_BUS_WIDTH,
376 ext_csd_bits[idx][0]);
377
378 if (err)
379 continue;
380
381 mmcsd_set_bus_width(host, bus_width);
382 err = mmc_compare_ext_csds(card, ext_csd, bus_width);
383 if (!err)
384 {
385 break;
386 }
387 else
388 {
389 switch (ext_csd_bits[idx][0])
390 {
391 case 0:
392 LOG_E("switch to bus width 1 bit failed!");
393 break;
394 case 1:
395 LOG_E("switch to bus width 4 bit failed!");
396 break;
397 case 2:
398 LOG_E("switch to bus width 8 bit failed!");
399 break;
400 default:
401 break;
402 }
403 }
404 }
405
406 if (!err && ddr)
407 {
408 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
409 EXT_CSD_BUS_WIDTH,
410 ext_csd_bits[idx][1]);
411 }
412
413 if (!err)
414 {
415 if (card->flags & (CARD_FLAG_HIGHSPEED | CARD_FLAG_HIGHSPEED_DDR))
416 {
417
418 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
419 EXT_CSD_HS_TIMING,
420 1);
421 }
422 }
423
424 return err;
425 }
426
mmc_send_op_cond(struct rt_mmcsd_host * host,rt_uint32_t ocr,rt_uint32_t * rocr)427 rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
428 rt_uint32_t ocr, rt_uint32_t *rocr)
429 {
430 struct rt_mmcsd_cmd cmd;
431 rt_uint32_t i;
432 rt_err_t err = RT_EOK;
433
434 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
435
436 cmd.cmd_code = SEND_OP_COND;
437 cmd.arg = controller_is_spi(host) ? 0 : ocr;
438 cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
439
440 for (i = 100; i; i--)
441 {
442 err = mmcsd_send_cmd(host, &cmd, 3);
443 if (err)
444 break;
445
446 /* if we're just probing, do a single pass */
447 if (ocr == 0)
448 break;
449
450 /* otherwise wait until reset completes */
451 if (controller_is_spi(host))
452 {
453 if (!(cmd.resp[0] & R1_SPI_IDLE))
454 break;
455 }
456 else
457 {
458 if (cmd.resp[0] & CARD_BUSY)
459 break;
460 }
461
462 err = -RT_ETIMEOUT;
463
464 rt_thread_mdelay(10); //delay 10ms
465 }
466
467 if (rocr && !controller_is_spi(host))
468 *rocr = cmd.resp[0];
469
470 return err;
471 }
472
mmc_set_card_addr(struct rt_mmcsd_host * host,rt_uint32_t rca)473 static rt_err_t mmc_set_card_addr(struct rt_mmcsd_host *host, rt_uint32_t rca)
474 {
475 rt_err_t err;
476 struct rt_mmcsd_cmd cmd;
477
478 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
479
480 cmd.cmd_code = SET_RELATIVE_ADDR;
481 cmd.arg = rca << 16;
482 cmd.flags = RESP_R1 | CMD_AC;
483
484 err = mmcsd_send_cmd(host, &cmd, 3);
485 if (err)
486 return err;
487
488 return 0;
489 }
490
mmc_select_hs200(struct rt_mmcsd_card * card)491 static int mmc_select_hs200(struct rt_mmcsd_card *card)
492 {
493 int ret;
494
495 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
496 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200);
497 if (ret)
498 return ret;
499
500 mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS200);
501 mmcsd_set_clock(card->host, card->max_data_rate);
502
503 ret = mmcsd_excute_tuning(card);
504
505 return ret;
506 }
507
mmc_switch_to_hs400(struct rt_mmcsd_card * card)508 static int mmc_switch_to_hs400(struct rt_mmcsd_card *card)
509 {
510 struct rt_mmcsd_host *host = card->host;
511 int err;
512 rt_uint8_t ext_csd_bus_width;
513 rt_uint32_t hs_timing;
514
515 /* Switch to HS_TIMING to 0x01 (High Speed) */
516 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
517 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS);
518 if (err != RT_EOK)
519 {
520 return err;
521 }
522 mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS);
523 /* Host changes frequency to <= 52MHz */
524 mmcsd_set_clock(card->host, 52000000);
525
526 rt_bool_t support_enhanced_ds = ((card->ext_csd.enhanced_data_strobe != 0) &&
527 ((host->flags & MMCSD_SUP_ENH_DS) != 0));
528
529 /* Set the bus width to:
530 * 0x86 if enhanced data strobe is supported, or
531 * 0x06 if enhanced data strobe is not supported
532 */
533 ext_csd_bus_width = support_enhanced_ds ?
534 EXT_CSD_DDR_BUS_WIDTH_8_EH_DS :
535 EXT_CSD_DDR_BUS_WIDTH_8;
536
537 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
538 EXT_CSD_BUS_WIDTH,
539 ext_csd_bus_width);
540 if (err != RT_EOK)
541 {
542 return err;
543 }
544
545 /* Set HS_TIMING to 0x03 (HS400) */
546 err = mmc_switch(card,
547 EXT_CSD_CMD_SET_NORMAL,
548 EXT_CSD_HS_TIMING,
549 EXT_CSD_TIMING_HS400);
550 if (err != RT_EOK)
551 {
552 return err;
553 }
554
555 /* Change the Host timing accordingly */
556 hs_timing = support_enhanced_ds ?
557 MMCSD_TIMING_MMC_HS400_ENH_DS :
558 MMCSD_TIMING_MMC_HS400;
559 mmcsd_set_timing(host, hs_timing);
560
561 /* Host may changes frequency to <= 200MHz */
562 mmcsd_set_clock(card->host, card->max_data_rate);
563
564 return RT_EOK;
565 }
566
mmc_select_hs400(struct rt_mmcsd_card * card)567 static int mmc_select_hs400(struct rt_mmcsd_card *card)
568 {
569 int ret;
570 struct rt_mmcsd_host *host = card->host;
571 /* if the card or host doesn't support enhanced data strobe, switch to HS200 and perform tuning process first */
572 if ((card->ext_csd.enhanced_data_strobe == 0) || ((host->flags & MMCSD_SUP_ENH_DS) == 0))
573 {
574 ret = mmc_select_hs200(card);
575 if (ret != RT_EOK)
576 {
577 return ret;
578 }
579 }
580 return mmc_switch_to_hs400(card);
581 }
582
mmc_select_timing(struct rt_mmcsd_card * card)583 static int mmc_select_timing(struct rt_mmcsd_card *card)
584 {
585 int ret = 0;
586
587 if (card->flags & CARD_FLAG_HS400)
588 {
589 LOG_I("emmc: switch to HS400 mode\n");
590 ret = mmc_select_hs400(card);
591 }
592 else if (card->flags & CARD_FLAG_HS200)
593 {
594 LOG_I("emmc: switch to HS200 mode\n");
595 ret = mmc_select_hs200(card);
596 }
597 else if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
598 {
599 LOG_I("emmc: switch to HIGH Speed DDR mode\n");
600 mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_DDR52);
601 mmcsd_set_clock(card->host, card->hs_max_data_rate);
602 }
603 else
604 {
605 LOG_I("emmc: switch to HIGH Speed mode\n");
606 mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS);
607 mmcsd_set_clock(card->host, card->hs_max_data_rate);
608 }
609
610 return ret;
611 }
612
mmcsd_mmc_init_card(struct rt_mmcsd_host * host,rt_uint32_t ocr)613 static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
614 rt_uint32_t ocr)
615 {
616 rt_int32_t err;
617 rt_uint32_t resp[4];
618 rt_uint32_t rocr = 0;
619 rt_uint8_t *ext_csd = RT_NULL;
620 struct rt_mmcsd_card *card = RT_NULL;
621
622 mmcsd_go_idle(host);
623
624 /* The extra bit indicates that we support high capacity */
625 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
626 if (err)
627 goto err;
628
629 if (controller_is_spi(host))
630 {
631 err = mmcsd_spi_use_crc(host, 1);
632 if (err)
633 goto err1;
634 }
635
636 if (controller_is_spi(host))
637 err = mmcsd_get_cid(host, resp);
638 else
639 err = mmcsd_all_get_cid(host, resp);
640 if (err)
641 goto err;
642
643 card = rt_malloc(sizeof(struct rt_mmcsd_card));
644 if (!card)
645 {
646 LOG_E("malloc card failed!");
647 err = -RT_ENOMEM;
648 goto err;
649 }
650 rt_memset(card, 0, sizeof(struct rt_mmcsd_card));
651
652 card->card_type = CARD_TYPE_MMC;
653 card->host = host;
654 card->rca = 1;
655 rt_memcpy(card->resp_cid, resp, sizeof(card->resp_cid));
656
657 /*
658 * For native busses: get card RCA and quit open drain mode.
659 */
660 if (!controller_is_spi(host))
661 {
662 err = mmc_set_card_addr(host, card->rca);
663 if (err)
664 goto err1;
665
666 mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL);
667 }
668
669 err = mmcsd_get_csd(card, card->resp_csd);
670 if (err)
671 goto err1;
672
673 err = mmcsd_parse_csd(card);
674 if (err)
675 goto err1;
676
677 if (!controller_is_spi(host))
678 {
679 err = mmcsd_select_card(card);
680 if (err)
681 goto err1;
682 }
683
684 /*
685 * Fetch and process extended CSD.
686 */
687
688 err = mmc_get_ext_csd(card, &ext_csd);
689 if (err)
690 goto err1;
691 err = mmc_parse_ext_csd(card, ext_csd);
692 if (err)
693 goto err1;
694
695 /* If doing byte addressing, check if required to do sector
696 * addressing. Handle the case of <2GB cards needing sector
697 * addressing. See section 8.1 JEDEC Standard JED84-A441;
698 * ocr register has bit 30 set for sector addressing.
699 */
700 if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1 << 30)))
701 card->flags |= CARD_FLAG_SDHC;
702
703 /*switch bus width and bus mode*/
704 err = mmc_select_bus_width(card, ext_csd);
705 if (err)
706 {
707 LOG_E("mmc select buswidth fail");
708 goto err0;
709 }
710
711 err = mmc_select_timing(card);
712 if (err)
713 {
714 LOG_E("mmc select timing fail");
715 goto err0;
716 }
717
718 if (card->ext_csd.cache_size > 0)
719 {
720 mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
721 EXT_CSD_CACHE_CTRL, 1);
722 }
723
724 host->card = card;
725
726 rt_free(ext_csd);
727 return 0;
728
729 err0:
730 rt_free(ext_csd);
731 err1:
732 rt_free(card);
733 err:
734
735 return err;
736 }
737
738 /*
739 * Starting point for mmc card init.
740 */
init_mmc(struct rt_mmcsd_host * host,rt_uint32_t ocr)741 rt_int32_t init_mmc(struct rt_mmcsd_host *host, rt_uint32_t ocr)
742 {
743 rt_int32_t err;
744 rt_uint32_t current_ocr;
745 /*
746 * We need to get OCR a different way for SPI.
747 */
748 if (controller_is_spi(host))
749 {
750 err = mmcsd_spi_read_ocr(host, 0, &ocr);
751 if (err)
752 goto err;
753 }
754
755 current_ocr = mmcsd_select_voltage(host, ocr);
756
757 /*
758 * Can we support the voltage(s) of the card(s)?
759 */
760 if (!current_ocr)
761 {
762 err = -RT_ERROR;
763 goto err;
764 }
765
766 /*
767 * Detect and init the card.
768 */
769 err = mmcsd_mmc_init_card(host, current_ocr);
770 if (err)
771 goto err;
772
773 mmcsd_host_unlock(host);
774
775 err = rt_mmcsd_blk_probe(host->card);
776 if (err)
777 goto remove_card;
778 mmcsd_host_lock(host);
779
780 return 0;
781
782 remove_card:
783 mmcsd_host_lock(host);
784 rt_mmcsd_blk_remove(host->card);
785 rt_free(host->card);
786 host->card = RT_NULL;
787 err:
788
789 LOG_E("init MMC card failed!");
790
791 return err;
792 }
793