Lines Matching +full:mmc +full:-
7 * SPDX-License-Identifier: GPL-2.0+
14 #include <dm/device-internal.h>
16 #include <mmc.h>
36 static struct mmc mmc_static;
37 struct mmc *find_mmc_device(int dev_num) in find_mmc_device()
44 struct mmc *m = &mmc_static; in mmc_do_preinit()
48 if (m->preinit) in mmc_do_preinit()
52 struct blk_desc *mmc_get_blk_desc(struct mmc *mmc) in mmc_get_blk_desc() argument
54 return &mmc->block_dev; in mmc_get_blk_desc()
59 __weak int board_mmc_getwp(struct mmc *mmc) in board_mmc_getwp() argument
61 return -1; in board_mmc_getwp()
64 int mmc_getwp(struct mmc *mmc) in mmc_getwp() argument
68 wp = board_mmc_getwp(mmc); in mmc_getwp()
71 if (mmc->cfg->ops->getwp) in mmc_getwp()
72 wp = mmc->cfg->ops->getwp(mmc); in mmc_getwp()
80 __weak int board_mmc_getcd(struct mmc *mmc) in board_mmc_getcd() argument
82 return -1; in board_mmc_getcd()
87 void mmmc_trace_before_send(struct mmc *mmc, struct mmc_cmd *cmd) in mmmc_trace_before_send() argument
89 printf("CMD_SEND:%d\n", cmd->cmdidx); in mmmc_trace_before_send()
90 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); in mmmc_trace_before_send()
93 void mmmc_trace_after_send(struct mmc *mmc, struct mmc_cmd *cmd, int ret) in mmmc_trace_after_send() argument
101 switch (cmd->resp_type) { in mmmc_trace_after_send()
107 cmd->response[0]); in mmmc_trace_after_send()
111 cmd->response[0]); in mmmc_trace_after_send()
115 cmd->response[0]); in mmmc_trace_after_send()
117 cmd->response[1]); in mmmc_trace_after_send()
119 cmd->response[2]); in mmmc_trace_after_send()
121 cmd->response[3]); in mmmc_trace_after_send()
126 printf("\t\t\t\t\t%03d - ", i*4); in mmmc_trace_after_send()
127 ptr = (u8 *)&cmd->response[i]; in mmmc_trace_after_send()
130 printf("%02X ", *ptr--); in mmmc_trace_after_send()
136 cmd->response[0]); in mmmc_trace_after_send()
139 printf("\t\tERROR MMC rsp not supported\n"); in mmmc_trace_after_send()
145 void mmc_trace_state(struct mmc *mmc, struct mmc_cmd *cmd) in mmc_trace_state() argument
149 status = (cmd->response[0] & MMC_STATUS_CURR_STATE) >> 9; in mmc_trace_state()
155 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) in mmc_send_cmd() argument
159 mmmc_trace_before_send(mmc, cmd); in mmc_send_cmd()
160 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); in mmc_send_cmd()
161 mmmc_trace_after_send(mmc, cmd, ret); in mmc_send_cmd()
167 int mmc_send_status(struct mmc *mmc, int timeout) in mmc_send_status() argument
174 if (!mmc_host_is_spi(mmc)) in mmc_send_status()
175 cmd.cmdarg = mmc->rca << 16; in mmc_send_status()
178 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_send_status()
189 return -ECOMM; in mmc_send_status()
191 } else if (--retries < 0) in mmc_send_status()
194 if (timeout-- <= 0) in mmc_send_status()
200 mmc_trace_state(mmc, &cmd); in mmc_send_status()
205 return -ETIMEDOUT; in mmc_send_status()
211 int mmc_set_blocklen(struct mmc *mmc, int len) in mmc_set_blocklen() argument
215 if (mmc_card_ddr(mmc)) in mmc_set_blocklen()
222 return mmc_send_cmd(mmc, &cmd, NULL); in mmc_set_blocklen()
225 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, in mmc_read_blocks() argument
236 if (mmc->high_capacity) in mmc_read_blocks()
239 cmd.cmdarg = start * mmc->read_bl_len; in mmc_read_blocks()
245 data.blocksize = mmc->read_bl_len; in mmc_read_blocks()
248 if (mmc_send_cmd(mmc, &cmd, &data)) in mmc_read_blocks()
255 if (mmc_send_cmd(mmc, &cmd, NULL)) { in mmc_read_blocks()
257 printf("mmc fail to send stop cmd\n"); in mmc_read_blocks()
267 static int mmc_read_blocks_prepare(struct mmc *mmc, void *dst, lbaint_t start, in mmc_read_blocks_prepare() argument
278 if (mmc->high_capacity) in mmc_read_blocks_prepare()
281 cmd.cmdarg = start * mmc->read_bl_len; in mmc_read_blocks_prepare()
287 data.blocksize = mmc->read_bl_len; in mmc_read_blocks_prepare()
290 if (mmc_send_cmd_prepare(mmc, &cmd, &data)) in mmc_read_blocks_prepare()
308 int dev_num = block_dev->devnum; in mmc_bread_prepare()
315 struct mmc *mmc = find_mmc_device(dev_num); in mmc_bread_prepare() local
317 if (!mmc) in mmc_bread_prepare()
321 err = mmc_switch_part(mmc, block_dev->hwpart); in mmc_bread_prepare()
323 err = blk_dselect_hwpart(block_dev, block_dev->hwpart); in mmc_bread_prepare()
328 if ((start + blkcnt) > block_dev->lba) { in mmc_bread_prepare()
330 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", in mmc_bread_prepare()
331 start + blkcnt, block_dev->lba); in mmc_bread_prepare()
336 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { in mmc_bread_prepare()
341 if (mmc_read_blocks_prepare(mmc, dst, start, blkcnt) != blkcnt) { in mmc_bread_prepare()
346 * Try re-init seven times. in mmc_bread_prepare()
349 printf("Re-init retry timeout\n"); in mmc_bread_prepare()
353 mmc->has_init = 0; in mmc_bread_prepare()
354 if (mmc_init(mmc)) in mmc_bread_prepare()
357 if (mmc_read_blocks_prepare(mmc, dst, start, blkcnt) != blkcnt) { in mmc_bread_prepare()
358 printf("%s: Re-init mmc_read_blocks_prepare error\n", in mmc_bread_prepare()
378 int dev_num = block_dev->devnum; in mmc_bread()
383 if (block_dev->op_flag == BLK_PRE_RW) in mmc_bread()
393 struct mmc *mmc = find_mmc_device(dev_num); in mmc_bread() local
394 if (!mmc) in mmc_bread()
398 err = mmc_switch_part(mmc, block_dev->hwpart); in mmc_bread()
400 err = blk_dselect_hwpart(block_dev, block_dev->hwpart); in mmc_bread()
405 if ((start + blkcnt) > block_dev->lba) { in mmc_bread()
407 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", in mmc_bread()
408 start + blkcnt, block_dev->lba); in mmc_bread()
413 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { in mmc_bread()
419 cur = (blocks_todo > mmc->cfg->b_max) ? in mmc_bread()
420 mmc->cfg->b_max : blocks_todo; in mmc_bread()
421 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { in mmc_bread()
427 * Try re-init seven times. in mmc_bread()
430 printf("Re-init retry timeout\n"); in mmc_bread()
434 mmc->has_init = 0; in mmc_bread()
435 if (mmc_init(mmc)) in mmc_bread()
438 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { in mmc_bread()
439 printf("%s: Re-init mmc_read_blocks error\n", in mmc_bread()
444 blocks_todo -= cur; in mmc_bread()
446 dst += cur * mmc->read_bl_len; in mmc_bread()
452 void mmc_set_clock(struct mmc *mmc, uint clock) in mmc_set_clock() argument
454 if (clock > mmc->cfg->f_max) in mmc_set_clock()
455 clock = mmc->cfg->f_max; in mmc_set_clock()
457 if (clock < mmc->cfg->f_min) in mmc_set_clock()
458 clock = mmc->cfg->f_min; in mmc_set_clock()
460 mmc->clock = clock; in mmc_set_clock()
462 mmc_set_ios(mmc); in mmc_set_clock()
465 static void mmc_set_bus_width(struct mmc *mmc, uint width) in mmc_set_bus_width() argument
467 mmc->bus_width = width; in mmc_set_bus_width()
469 mmc_set_ios(mmc); in mmc_set_bus_width()
472 static void mmc_set_timing(struct mmc *mmc, uint timing) in mmc_set_timing() argument
474 mmc->timing = timing; in mmc_set_timing()
475 mmc_set_ios(mmc); in mmc_set_timing()
478 static int mmc_go_idle(struct mmc *mmc) in mmc_go_idle() argument
489 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_go_idle()
500 static int sd_send_op_cond(struct mmc *mmc) in sd_send_op_cond() argument
511 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
526 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : in sd_send_op_cond()
527 (mmc->cfg->voltages & 0xff8000); in sd_send_op_cond()
529 if (mmc->version == SD_VERSION_2) in sd_send_op_cond()
532 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
540 if (timeout-- <= 0) in sd_send_op_cond()
541 return -EOPNOTSUPP; in sd_send_op_cond()
546 if (mmc->version != SD_VERSION_2) in sd_send_op_cond()
547 mmc->version = SD_VERSION_1_0; in sd_send_op_cond()
549 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ in sd_send_op_cond()
554 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
560 mmc->ocr = cmd.response[0]; in sd_send_op_cond()
562 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); in sd_send_op_cond()
563 mmc->rca = 0; in sd_send_op_cond()
569 static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) in mmc_send_op_cond_iter() argument
577 if (use_arg && !mmc_host_is_spi(mmc)) in mmc_send_op_cond_iter()
579 (mmc->cfg->voltages & in mmc_send_op_cond_iter()
580 (mmc->ocr & OCR_VOLTAGE_MASK)) | in mmc_send_op_cond_iter()
581 (mmc->ocr & OCR_ACCESS_MODE); in mmc_send_op_cond_iter()
583 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_send_op_cond_iter()
586 mmc->ocr = cmd.response[0]; in mmc_send_op_cond_iter()
591 static int mmc_send_op_cond(struct mmc *mmc) in mmc_send_op_cond() argument
596 mmc_go_idle(mmc); in mmc_send_op_cond()
600 err = mmc_send_op_cond_iter(mmc, i != 0); in mmc_send_op_cond()
605 if (mmc->ocr & OCR_BUSY) in mmc_send_op_cond()
608 mmc->op_cond_pending = 1; in mmc_send_op_cond()
612 static int mmc_complete_op_cond(struct mmc *mmc) in mmc_complete_op_cond() argument
619 mmc->op_cond_pending = 0; in mmc_complete_op_cond()
620 if (!(mmc->ocr & OCR_BUSY)) { in mmc_complete_op_cond()
622 mmc_go_idle(mmc); in mmc_complete_op_cond()
626 err = mmc_send_op_cond_iter(mmc, 1); in mmc_complete_op_cond()
629 if (mmc->ocr & OCR_BUSY) in mmc_complete_op_cond()
632 return -EOPNOTSUPP; in mmc_complete_op_cond()
637 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ in mmc_complete_op_cond()
642 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_complete_op_cond()
647 mmc->ocr = cmd.response[0]; in mmc_complete_op_cond()
650 mmc->version = MMC_VERSION_UNKNOWN; in mmc_complete_op_cond()
652 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); in mmc_complete_op_cond()
653 mmc->rca = 1; in mmc_complete_op_cond()
659 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) in mmc_send_ext_csd() argument
684 err = mmc_send_cmd(mmc, &cmd, &data); in mmc_send_ext_csd()
690 mmc_ecsd = dev_read_u32_default(mmc->dev, "mmc-ecsd", 0); in mmc_send_ext_csd()
700 static int mmc_poll_for_busy(struct mmc *mmc, u8 send_status) in mmc_poll_for_busy() argument
710 cmd.cmdarg = mmc->rca << 16; in mmc_poll_for_busy()
714 if (!send_status && !mmc_can_card_busy(mmc)) { in mmc_poll_for_busy()
721 busy = mmc_card_busy(mmc); in mmc_poll_for_busy()
723 ret = mmc_send_cmd(mmc, &cmd, NULL); in mmc_poll_for_busy()
729 return -EBADMSG; in mmc_poll_for_busy()
735 return -ETIMEDOUT; in mmc_poll_for_busy()
741 static int __mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value, in __mmc_switch() argument
755 ret = mmc_send_cmd(mmc, &cmd, NULL); in __mmc_switch()
758 return mmc_poll_for_busy(mmc, send_status); in __mmc_switch()
759 } while (--retries > 0 && ret); in __mmc_switch()
764 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) in mmc_switch() argument
766 return __mmc_switch(mmc, set, index, value, true); in mmc_switch()
769 static int mmc_select_bus_width(struct mmc *mmc) in mmc_select_bus_width() argument
784 if (mmc->version < MMC_VERSION_4 || in mmc_select_bus_width()
785 !(mmc->cfg->host_caps & (MMC_MODE_4BIT | MMC_MODE_8BIT))) in mmc_select_bus_width()
788 err = mmc_send_ext_csd(mmc, ext_csd); in mmc_select_bus_width()
793 idx = (mmc->cfg->host_caps & MMC_MODE_8BIT) ? 0 : 1; in mmc_select_bus_width()
796 * Unlike SD, MMC cards dont have a configuration register to notify in mmc_select_bus_width()
805 * mmc switch command returns error then switch to in mmc_select_bus_width()
809 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, in mmc_select_bus_width()
815 mmc_set_bus_width(mmc, bus_width); in mmc_select_bus_width()
817 err = mmc_send_ext_csd(mmc, test_csd); in mmc_select_bus_width()
835 err = -EBADMSG; in mmc_select_bus_width()
873 int mmc_send_tuning(struct mmc *mmc, u32 opcode) in mmc_send_tuning() argument
881 if (mmc->bus_width == MMC_BUS_WIDTH_8BIT) { in mmc_send_tuning()
884 } else if (mmc->bus_width == MMC_BUS_WIDTH_4BIT) { in mmc_send_tuning()
888 return -EINVAL; in mmc_send_tuning()
893 return -ENOMEM; in mmc_send_tuning()
904 err = mmc_send_cmd(mmc, &cmd, &data); in mmc_send_tuning()
909 err = -EIO; in mmc_send_tuning()
915 static int mmc_execute_tuning(struct mmc *mmc) argument
918 struct dm_mmc_ops *ops = mmc_get_ops(mmc->dev);
922 if (IS_SD(mmc))
928 if (mmc->cfg->ops->execute_tuning) {
929 return mmc->cfg->ops->execute_tuning(mmc, opcode);
931 if (ops->execute_tuning) {
932 return ops->execute_tuning(mmc->dev, opcode);
936 return -EIO;
940 static int mmc_hs200_tuning(struct mmc *mmc) argument
942 return mmc_execute_tuning(mmc);
946 int mmc_send_tuning(struct mmc *mmc, u32 opcode) { return 0; } argument
947 int mmc_execute_tuning(struct mmc *mmc) { return 0; } argument
948 static int mmc_hs200_tuning(struct mmc *mmc) { return 0; } argument
951 static int mmc_select_hs(struct mmc *mmc) argument
955 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
959 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
964 static int mmc_select_hs_ddr(struct mmc *mmc) argument
969 if (mmc->bus_width == MMC_BUS_WIDTH_1BIT)
972 ext_csd_bits = (mmc->bus_width == MMC_BUS_WIDTH_8BIT) ?
975 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
980 mmc_set_timing(mmc, MMC_TIMING_MMC_DDR52);
986 static int mmc_select_hs200(struct mmc *mmc) argument
994 ret = mmc_select_bus_width(mmc);
997 ret = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1004 mmc_set_timing(mmc, MMC_TIMING_MMC_HS200);
1010 static int mmc_switch_to_hs400(struct mmc *mmc) argument
1014 fixed_drv_type = mmc->cfg->fixed_drv_type;
1015 card_drv_type = mmc->raw_driver_strength | mmc_driver_type_mask(0);
1020 return __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, val, false);
1023 static int mmc_select_hs400(struct mmc *mmc) argument
1028 ret = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1034 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
1037 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1039 ret = mmc_send_status(mmc, 1000);
1044 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1051 ret = mmc_switch_to_hs400(mmc);
1056 mmc_set_timing(mmc, MMC_TIMING_MMC_HS400);
1061 static int mmc_select_hs400es(struct mmc *mmc) argument
1066 err = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1072 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
1074 err = mmc_send_status(mmc, 1000);
1078 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1080 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
1089 err = mmc_switch_to_hs400(mmc);
1094 mmc_set_timing(mmc, MMC_TIMING_MMC_HS400ES);
1096 return mmc_set_enhanced_strobe(mmc);
1099 static int mmc_select_hs200(struct mmc *mmc) { return 0; } argument
1100 static int mmc_select_hs400(struct mmc *mmc) { return 0; } argument
1101 static int mmc_select_hs400es(struct mmc *mmc) { return 0; } argument
1104 static u32 mmc_select_card_type(struct mmc *mmc, u8 *ext_csd) argument
1110 host_caps = mmc->cfg->host_caps;
1121 * For the moment, u-boot doesn't support signal voltage
1155 static void mmc_set_bus_speed(struct mmc *mmc, u8 avail_type) argument
1159 if (mmc_card_hs(mmc))
1162 else if (mmc_card_hs200(mmc) ||
1163 mmc_card_hs400(mmc) ||
1164 mmc_card_hs400es(mmc))
1167 mmc_set_clock(mmc, clock);
1170 static int mmc_change_freq(struct mmc *mmc) argument
1176 mmc->card_caps = 0;
1178 if (mmc_host_is_spi(mmc))
1181 /* Only version 4 supports high-speed */
1182 if (mmc->version < MMC_VERSION_4)
1185 mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT;
1187 err = mmc_send_ext_csd(mmc, ext_csd);
1192 avail_type = mmc_select_card_type(mmc, ext_csd);
1195 err = mmc_select_bus_width(mmc);
1196 if (err > 0 && mmc->bus_width == MMC_BUS_WIDTH_8BIT) {
1197 err = mmc_select_hs400es(mmc);
1198 mmc_set_bus_speed(mmc, avail_type);
1205 err = mmc_select_hs200(mmc);
1207 err = mmc_select_hs(mmc);
1209 err = -EINVAL;
1214 mmc_set_bus_speed(mmc, avail_type);
1216 if (mmc_card_hs200(mmc)) {
1217 err = mmc_hs200_tuning(mmc);
1219 mmc->bus_width == MMC_BUS_WIDTH_8BIT) {
1220 err = mmc_select_hs400(mmc);
1221 mmc_set_bus_speed(mmc, avail_type);
1223 } else if (!mmc_card_hs400es(mmc)) {
1224 err = mmc_select_bus_width(mmc) > 0 ? 0 : err;
1226 err = mmc_select_hs_ddr(mmc);
1232 static int mmc_set_capacity(struct mmc *mmc, int part_num) argument
1236 mmc->capacity = mmc->capacity_user;
1240 mmc->capacity = mmc->capacity_boot;
1243 mmc->capacity = mmc->capacity_rpmb;
1249 mmc->capacity = mmc->capacity_gp[part_num - 4];
1252 return -1;
1255 mmc_get_blk_desc(mmc)->lba = lldiv(mmc->capacity, mmc->read_bl_len);
1260 int mmc_switch_part(struct mmc *mmc, unsigned int part_num) argument
1264 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1265 (mmc->part_config & ~PART_ACCESS_MASK)
1272 if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) {
1273 ret = mmc_set_capacity(mmc, part_num);
1274 mmc_get_blk_desc(mmc)->hwpart = part_num;
1280 int mmc_hwpart_config(struct mmc *mmc, argument
1295 return -EINVAL;
1297 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) {
1299 return -EMEDIUMTYPE;
1302 if (!(mmc->part_support & PART_SUPPORT)) {
1304 return -EMEDIUMTYPE;
1307 if (!mmc->hc_wp_grp_size) {
1309 return -EMEDIUMTYPE;
1313 if (conf->user.enh_size) {
1314 if (conf->user.enh_size % mmc->hc_wp_grp_size ||
1315 conf->user.enh_start % mmc->hc_wp_grp_size) {
1318 return -EINVAL;
1321 enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size;
1322 if (mmc->high_capacity) {
1323 enh_start_addr = conf->user.enh_start;
1325 enh_start_addr = (conf->user.enh_start << 9);
1334 if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) {
1337 return -EINVAL;
1339 gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size;
1340 if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) {
1346 if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) {
1348 return -EMEDIUMTYPE;
1351 err = mmc_send_ext_csd(mmc, ext_csd);
1362 return -EMEDIUMTYPE;
1370 if (conf->user.wr_rel_change) {
1371 if (conf->user.wr_rel_set)
1377 if (conf->gp_part[pidx].wr_rel_change) {
1378 if (conf->gp_part[pidx].wr_rel_set)
1389 return -EMEDIUMTYPE;
1395 return -EPERM;
1401 /* Partitioning requires high-capacity size definitions */
1403 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1411 /* update erase group size to be high-capacity */
1412 mmc->erase_grp_size =
1419 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1426 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1434 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1441 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1449 /* The WR_REL_SET is a write-once register but shall be
1451 * write-once we can only write it when completing the
1454 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1463 * in the mmc struct. */
1465 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1475 int mmc_getcd(struct mmc *mmc) argument
1479 cd = board_mmc_getcd(mmc);
1482 if (mmc->cfg->ops->getcd)
1483 cd = mmc->cfg->ops->getcd(mmc);
1492 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) argument
1509 return mmc_send_cmd(mmc, &cmd, &data);
1513 static int sd_change_freq(struct mmc *mmc) argument
1522 mmc->card_caps = 0;
1524 if (mmc_host_is_spi(mmc))
1530 cmd.cmdarg = mmc->rca << 16;
1532 err = mmc_send_cmd(mmc, &cmd, NULL);
1549 err = mmc_send_cmd(mmc, &cmd, &data);
1552 if (timeout--)
1558 mmc->scr[0] = __be32_to_cpu(scr[0]);
1559 mmc->scr[1] = __be32_to_cpu(scr[1]);
1561 switch ((mmc->scr[0] >> 24) & 0xf) {
1563 mmc->version = SD_VERSION_1_0;
1566 mmc->version = SD_VERSION_1_10;
1569 mmc->version = SD_VERSION_2;
1570 if ((mmc->scr[0] >> 15) & 0x1)
1571 mmc->version = SD_VERSION_3;
1574 mmc->version = SD_VERSION_1_0;
1578 if (mmc->scr[0] & SD_DATA_4BIT)
1579 mmc->card_caps |= MMC_MODE_4BIT;
1582 if (mmc->version == SD_VERSION_1_0)
1586 while (timeout--) {
1587 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
1593 /* The high-speed function is busy. Try again */
1598 /* If high-speed isn't supported, we return */
1608 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) &&
1609 (mmc->cfg->host_caps & MMC_MODE_HS)))
1612 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
1618 mmc->card_caps |= MMC_MODE_HS;
1623 static int sd_read_ssr(struct mmc *mmc) argument
1634 cmd.cmdarg = mmc->rca << 16;
1636 err = mmc_send_cmd(mmc, &cmd, NULL);
1650 err = mmc_send_cmd(mmc, &cmd, &data);
1652 if (timeout--)
1662 if ((au <= 9) || (mmc->version == SD_VERSION_3)) {
1663 mmc->ssr.au = sd_au_size[au];
1669 mmc->ssr.erase_timeout = (et * 1000) / es;
1670 mmc->ssr.erase_offset = eo * 1000;
1711 static void mmc_set_ios(struct mmc *mmc) argument
1713 if (mmc->cfg->ops->set_ios)
1714 mmc->cfg->ops->set_ios(mmc);
1717 static bool mmc_card_busy(struct mmc *mmc) argument
1719 if (!mmc->cfg->ops->card_busy)
1720 return -ENOSYS;
1722 return mmc->cfg->ops->card_busy(mmc);
1725 static bool mmc_can_card_busy(struct mmc *) argument
1727 return !!mmc->cfg->ops->card_busy;
1731 static int mmc_startup(struct mmc *mmc) argument
1743 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
1747 err = mmc_send_cmd(mmc, &cmd, NULL);
1755 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
1760 err = mmc_send_cmd(mmc, &cmd, NULL);
1765 memcpy(mmc->cid, cmd.response, 16);
1768 * For MMC cards, set the Relative Address.
1772 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1774 cmd.cmdarg = mmc->rca << 16;
1777 err = mmc_send_cmd(mmc, &cmd, NULL);
1782 if (IS_SD(mmc))
1783 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
1786 /* Get the Card-Specific Data */
1789 cmd.cmdarg = mmc->rca << 16;
1791 err = mmc_send_cmd(mmc, &cmd, NULL);
1796 mmc->csd[0] = cmd.response[0];
1797 mmc->csd[1] = cmd.response[1];
1798 mmc->csd[2] = cmd.response[2];
1799 mmc->csd[3] = cmd.response[3];
1801 if (mmc->version == MMC_VERSION_UNKNOWN) {
1806 mmc->version = MMC_VERSION_1_2;
1809 mmc->version = MMC_VERSION_1_4;
1812 mmc->version = MMC_VERSION_2_2;
1815 mmc->version = MMC_VERSION_3;
1818 mmc->version = MMC_VERSION_4;
1821 mmc->version = MMC_VERSION_1_2;
1832 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
1833 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
1835 if (IS_SD(mmc))
1836 mmc->write_bl_len = mmc->read_bl_len;
1838 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
1840 if (mmc->high_capacity) {
1841 csize = (mmc->csd[1] & 0x3f) << 16
1842 | (mmc->csd[2] & 0xffff0000) >> 16;
1845 csize = (mmc->csd[1] & 0x3ff) << 2
1846 | (mmc->csd[2] & 0xc0000000) >> 30;
1847 cmult = (mmc->csd[2] & 0x00038000) >> 15;
1850 mmc->capacity_user = (csize + 1) << (cmult + 2);
1851 mmc->capacity_user *= mmc->read_bl_len;
1852 mmc->capacity_boot = 0;
1853 mmc->capacity_rpmb = 0;
1855 mmc->capacity_gp[i] = 0;
1857 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
1858 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1860 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
1861 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1863 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
1865 cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
1867 if (mmc_send_cmd(mmc, &cmd, NULL))
1868 printf("MMC: SET_DSR failed\n");
1872 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1875 cmd.cmdarg = mmc->rca << 16;
1876 err = mmc_send_cmd(mmc, &cmd, NULL);
1885 mmc->erase_grp_size = 1;
1886 mmc->part_config = MMCPART_NOAVAILABLE;
1887 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1889 mmc_select_hs(mmc);
1890 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1893 err = mmc_send_ext_csd(mmc, ext_csd);
1908 mmc->capacity_user = capacity;
1913 mmc->version = MMC_VERSION_4_1;
1916 mmc->version = MMC_VERSION_4_2;
1919 mmc->version = MMC_VERSION_4_3;
1922 mmc->version = MMC_VERSION_4_41;
1925 mmc->version = MMC_VERSION_4_5;
1928 mmc->version = MMC_VERSION_5_0;
1931 mmc->version = MMC_VERSION_5_1;
1935 /* The partition data may be non-zero but it is only
1938 * except for enabling the high-capacity group size
1944 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT];
1947 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1950 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE];
1952 mmc->esr.mmc_can_trim = 1;
1954 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1956 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1966 mmc->capacity_gp[i] = mult;
1967 mmc->capacity_gp[i] *=
1969 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1970 mmc->capacity_gp[i] <<= 19;
1974 mmc->enh_user_size =
1978 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1979 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1980 mmc->enh_user_size <<= 19;
1981 mmc->enh_user_start =
1986 if (mmc->high_capacity)
1987 mmc->enh_user_start <<= 9;
2001 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
2012 mmc->erase_grp_size =
2017 * JEDEC Standard JESD84-B45, 6.2.4
2019 if (mmc->high_capacity && part_completed) {
2025 mmc->capacity_user = capacity;
2030 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
2031 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
2032 mmc->erase_grp_size = (erase_gsz + 1)
2036 mmc->hc_wp_grp_size = 1024
2040 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
2042 mmc->raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
2045 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart);
2049 if (IS_SD(mmc))
2050 err = sd_change_freq(mmc);
2052 err = mmc_change_freq(mmc);
2058 mmc->card_caps &= mmc->cfg->host_caps;
2060 if (IS_SD(mmc)) {
2061 if (mmc->card_caps & MMC_MODE_4BIT) {
2064 cmd.cmdarg = mmc->rca << 16;
2066 err = mmc_send_cmd(mmc, &cmd, NULL);
2073 err = mmc_send_cmd(mmc, &cmd, NULL);
2077 mmc_set_bus_width(mmc, 4);
2080 err = sd_read_ssr(mmc);
2084 if (mmc->card_caps & MMC_MODE_HS)
2089 mmc_set_clock(mmc, tran_speed);
2093 if (mmc_card_ddr(mmc)) {
2094 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
2095 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
2099 bdesc = mmc_get_blk_desc(mmc);
2100 bdesc->lun = 0;
2101 bdesc->hwpart = 0;
2102 bdesc->type = 0;
2103 bdesc->blksz = mmc->read_bl_len;
2104 bdesc->log2blksz = LOG2(bdesc->blksz);
2105 bdesc->lba = lldiv(mmc->capacity, mmc->read_bl_len);
2109 sprintf(bdesc->vendor, "Man %06x Snr %04x%04x",
2110 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
2111 (mmc->cid[3] >> 16) & 0xffff);
2112 sprintf(bdesc->product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
2113 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
2114 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
2115 (mmc->cid[2] >> 24) & 0xff);
2116 sprintf(bdesc->revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
2117 (mmc->cid[2] >> 16) & 0xf);
2119 bdesc->vendor[0] = 0;
2120 bdesc->product[0] = 0;
2121 bdesc->revision[0] = 0;
2131 static int mmc_send_if_cond(struct mmc *mmc) argument
2138 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
2141 err = mmc_send_cmd(mmc, &cmd, NULL);
2147 return -EOPNOTSUPP;
2149 mmc->version = SD_VERSION_2;
2156 /* board-specific MMC power initializations. */
2163 static int mmc_power_init(struct mmc *mmc) argument
2170 ret = device_get_supply_regulator(mmc->dev, "vmmc-supply",
2173 debug("%s: No vmmc supply\n", mmc->dev->name);
2194 static int mmc_select_card(struct mmc *mmc, int n) argument
2200 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
2201 mmc->rca = n;
2204 cmd.cmdarg = mmc->rca << 16;
2205 err = mmc_send_cmd(mmc, &cmd, NULL);
2211 int mmc_start_init(struct mmc *mmc) argument
2214 * We use the MMC config set by the bootrom.
2217 mmc_set_bus_width(mmc, 8);
2218 mmc_set_clock(mmc, 1);
2219 mmc_set_timing(mmc, MMC_TIMING_LEGACY);
2220 /* Send cmd7 to return stand-by state*/
2221 mmc_select_card(mmc, 0);
2222 mmc->version = MMC_VERSION_UNKNOWN;
2223 mmc->high_capacity = 1;
2229 mmc->rca = 2;
2231 mmc->rca = 1;
2236 int mmc_start_init(struct mmc *mmc) argument
2242 no_card = mmc_getcd(mmc) == 0;
2244 no_card = no_card || (mmc->cfg->ops->init == NULL);
2247 mmc->has_init = 0;
2249 printf("MMC: no card present\n");
2251 return -ENOMEDIUM;
2254 if (mmc->has_init)
2260 err = mmc_power_init(mmc);
2268 err = mmc->cfg->ops->init(mmc);
2272 mmc_set_bus_width(mmc, 1);
2273 mmc_set_clock(mmc, 1);
2274 mmc_set_timing(mmc, MMC_TIMING_LEGACY);
2277 err = mmc_go_idle(mmc);
2283 mmc_get_blk_desc(mmc)->hwpart = 0;
2286 err = mmc_send_if_cond(mmc);
2289 err = sd_send_op_cond(mmc);
2291 /* If the command timed out, we check for an MMC card */
2292 if (err == -ETIMEDOUT) {
2293 err = mmc_send_op_cond(mmc);
2299 return -EOPNOTSUPP;
2304 mmc->init_in_progress = 1;
2310 static int mmc_complete_init(struct mmc *mmc) argument
2314 mmc->init_in_progress = 0;
2315 if (mmc->op_cond_pending)
2316 err = mmc_complete_op_cond(mmc);
2319 err = mmc_startup(mmc);
2321 mmc->has_init = 0;
2323 mmc->has_init = 1;
2327 int mmc_init(struct mmc *mmc) argument
2332 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev);
2334 upriv->mmc = mmc;
2336 if (mmc->has_init)
2341 if (!mmc->init_in_progress)
2342 err = mmc_start_init(mmc);
2345 err = mmc_complete_init(mmc);
2352 int mmc_set_dsr(struct mmc *mmc, u16 val) argument
2354 mmc->dsr = val;
2358 /* CPU-specific MMC initializations */
2361 return -1;
2364 /* board-specific MMC initializations. */
2367 return -1;
2370 void mmc_set_preinit(struct mmc *mmc, int preinit) argument
2372 mmc->preinit = preinit;
2393 * should allow holes, but the current MMC list does not allow that.
2398 if (ret == -ENODEV)
2404 printf("%s - probe failed: %d\n", dev->name, ret);
2423 if (initialized) /* Avoid initializing mmc multiple times */
2445 int mmc_set_bkops_enable(struct mmc *mmc) argument
2450 err = mmc_send_ext_csd(mmc, ext_csd);
2458 return -EMEDIUMTYPE;
2466 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BKOPS_EN, 1);