Lines Matching refs:mmc
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()
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
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
87 void mmmc_trace_before_send(struct mmc *mmc, struct mmc_cmd *cmd) in mmmc_trace_before_send() argument
93 void mmmc_trace_after_send(struct mmc *mmc, struct mmc_cmd *cmd, int ret) in mmmc_trace_after_send() argument
145 void mmc_trace_state(struct mmc *mmc, struct mmc_cmd *cmd) in mmc_trace_state() argument
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()
200 mmc_trace_state(mmc, &cmd); 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 int mmc_set_blockcount(struct mmc *mmc, unsigned int blkcnt, bool is_rel_write) in mmc_set_blockcount() argument
235 return mmc_send_cmd(mmc, &cmd, NULL); in mmc_set_blockcount()
238 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, in mmc_read_blocks() argument
249 if (mmc->high_capacity) in mmc_read_blocks()
252 cmd.cmdarg = start * mmc->read_bl_len; in mmc_read_blocks()
258 data.blocksize = mmc->read_bl_len; in mmc_read_blocks()
261 if (mmc_send_cmd(mmc, &cmd, &data)) in mmc_read_blocks()
268 if (mmc_send_cmd(mmc, &cmd, NULL)) { in mmc_read_blocks()
280 static int mmc_read_blocks_prepare(struct mmc *mmc, void *dst, lbaint_t start, in mmc_read_blocks_prepare() argument
287 mmc_set_blockcount(mmc, blkcnt, false); in mmc_read_blocks_prepare()
293 if (mmc->high_capacity) in mmc_read_blocks_prepare()
296 cmd.cmdarg = start * mmc->read_bl_len; in mmc_read_blocks_prepare()
302 data.blocksize = mmc->read_bl_len; in mmc_read_blocks_prepare()
305 if (mmc_send_cmd_prepare(mmc, &cmd, &data)) in mmc_read_blocks_prepare()
330 struct mmc *mmc = find_mmc_device(dev_num); in mmc_bread_prepare() local
332 if (!mmc) in mmc_bread_prepare()
336 err = mmc_switch_part(mmc, block_dev->hwpart); in mmc_bread_prepare()
351 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { in mmc_bread_prepare()
356 if (mmc_read_blocks_prepare(mmc, dst, start, blkcnt) != blkcnt) { in mmc_bread_prepare()
368 mmc->has_init = 0; in mmc_bread_prepare()
369 if (mmc_init(mmc)) in mmc_bread_prepare()
372 if (mmc_read_blocks_prepare(mmc, dst, start, blkcnt) != blkcnt) { in mmc_bread_prepare()
408 struct mmc *mmc = find_mmc_device(dev_num); in mmc_bread() local
409 if (!mmc) in mmc_bread()
413 err = mmc_switch_part(mmc, block_dev->hwpart); in mmc_bread()
428 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { in mmc_bread()
434 cur = (blocks_todo > mmc->cfg->b_max) ? in mmc_bread()
435 mmc->cfg->b_max : blocks_todo; in mmc_bread()
436 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { in mmc_bread()
449 mmc->has_init = 0; in mmc_bread()
450 if (mmc_init(mmc)) in mmc_bread()
453 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { in mmc_bread()
461 dst += cur * mmc->read_bl_len; in mmc_bread()
467 void mmc_set_clock(struct mmc *mmc, uint clock) in mmc_set_clock() argument
469 if (clock > mmc->cfg->f_max) in mmc_set_clock()
470 clock = mmc->cfg->f_max; in mmc_set_clock()
472 if (clock < mmc->cfg->f_min) in mmc_set_clock()
473 clock = mmc->cfg->f_min; in mmc_set_clock()
475 mmc->clock = clock; in mmc_set_clock()
477 mmc_set_ios(mmc); in mmc_set_clock()
480 static void mmc_set_bus_width(struct mmc *mmc, uint width) in mmc_set_bus_width() argument
482 mmc->bus_width = width; in mmc_set_bus_width()
484 mmc_set_ios(mmc); in mmc_set_bus_width()
487 static void mmc_set_timing(struct mmc *mmc, uint timing) in mmc_set_timing() argument
489 mmc->timing = timing; in mmc_set_timing()
490 mmc_set_ios(mmc); in mmc_set_timing()
493 static int mmc_go_idle(struct mmc *mmc) in mmc_go_idle() argument
504 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_go_idle()
515 static int sd_send_op_cond(struct mmc *mmc) in sd_send_op_cond() argument
526 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
541 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : in sd_send_op_cond()
542 (mmc->cfg->voltages & 0xff8000); in sd_send_op_cond()
544 if (mmc->version == SD_VERSION_2) in sd_send_op_cond()
547 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
561 if (mmc->version != SD_VERSION_2) in sd_send_op_cond()
562 mmc->version = SD_VERSION_1_0; in sd_send_op_cond()
564 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ in sd_send_op_cond()
569 err = mmc_send_cmd(mmc, &cmd, NULL); in sd_send_op_cond()
575 mmc->ocr = cmd.response[0]; in sd_send_op_cond()
577 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); in sd_send_op_cond()
578 mmc->rca = 0; in sd_send_op_cond()
584 static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) in mmc_send_op_cond_iter() argument
592 if (use_arg && !mmc_host_is_spi(mmc)) in mmc_send_op_cond_iter()
594 (mmc->cfg->voltages & in mmc_send_op_cond_iter()
595 (mmc->ocr & OCR_VOLTAGE_MASK)) | in mmc_send_op_cond_iter()
596 (mmc->ocr & OCR_ACCESS_MODE); in mmc_send_op_cond_iter()
598 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_send_op_cond_iter()
601 mmc->ocr = cmd.response[0]; in mmc_send_op_cond_iter()
606 static int mmc_send_op_cond(struct mmc *mmc) in mmc_send_op_cond() argument
611 mmc_go_idle(mmc); in mmc_send_op_cond()
615 err = mmc_send_op_cond_iter(mmc, i != 0); in mmc_send_op_cond()
620 if (mmc->ocr & OCR_BUSY) in mmc_send_op_cond()
623 mmc->op_cond_pending = 1; in mmc_send_op_cond()
627 static int mmc_complete_op_cond(struct mmc *mmc) in mmc_complete_op_cond() argument
634 mmc->op_cond_pending = 0; in mmc_complete_op_cond()
635 if (!(mmc->ocr & OCR_BUSY)) { in mmc_complete_op_cond()
637 mmc_go_idle(mmc); in mmc_complete_op_cond()
641 err = mmc_send_op_cond_iter(mmc, 1); in mmc_complete_op_cond()
644 if (mmc->ocr & OCR_BUSY) in mmc_complete_op_cond()
652 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ in mmc_complete_op_cond()
657 err = mmc_send_cmd(mmc, &cmd, NULL); in mmc_complete_op_cond()
662 mmc->ocr = cmd.response[0]; in mmc_complete_op_cond()
665 mmc->version = MMC_VERSION_UNKNOWN; in mmc_complete_op_cond()
667 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); in mmc_complete_op_cond()
668 mmc->rca = 1; in mmc_complete_op_cond()
674 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) in mmc_send_ext_csd() argument
699 err = mmc_send_cmd(mmc, &cmd, &data); in mmc_send_ext_csd()
705 mmc_ecsd = dev_read_u32_default(mmc->dev, "mmc-ecsd", 0); in mmc_send_ext_csd()
715 static int mmc_poll_for_busy(struct mmc *mmc, u8 send_status) in mmc_poll_for_busy() argument
725 cmd.cmdarg = mmc->rca << 16; in mmc_poll_for_busy()
729 if (!send_status && !mmc_can_card_busy(mmc)) { in mmc_poll_for_busy()
736 busy = mmc_card_busy(mmc); in mmc_poll_for_busy()
738 ret = mmc_send_cmd(mmc, &cmd, NULL); in mmc_poll_for_busy()
756 static int __mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value, in __mmc_switch() argument
770 ret = mmc_send_cmd(mmc, &cmd, NULL); in __mmc_switch()
773 return mmc_poll_for_busy(mmc, send_status); in __mmc_switch()
779 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) in mmc_switch() argument
781 return __mmc_switch(mmc, set, index, value, true); in mmc_switch()
784 static int mmc_select_bus_width(struct mmc *mmc) in mmc_select_bus_width() argument
799 if (mmc->version < MMC_VERSION_4 || in mmc_select_bus_width()
800 !(mmc->cfg->host_caps & (MMC_MODE_4BIT | MMC_MODE_8BIT))) in mmc_select_bus_width()
803 err = mmc_send_ext_csd(mmc, ext_csd); in mmc_select_bus_width()
808 idx = (mmc->cfg->host_caps & MMC_MODE_8BIT) ? 0 : 1; in mmc_select_bus_width()
824 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, in mmc_select_bus_width()
830 mmc_set_bus_width(mmc, bus_width); in mmc_select_bus_width()
832 err = mmc_send_ext_csd(mmc, test_csd); in mmc_select_bus_width()
888 int mmc_send_tuning(struct mmc *mmc, u32 opcode) in mmc_send_tuning() argument
896 if (mmc->bus_width == MMC_BUS_WIDTH_8BIT) { in mmc_send_tuning()
899 } else if (mmc->bus_width == MMC_BUS_WIDTH_4BIT) { in mmc_send_tuning()
919 err = mmc_send_cmd(mmc, &cmd, &data); in mmc_send_tuning()
924 mmc_send_cmd(mmc, &cmd, NULL); in mmc_send_tuning()
934 static int mmc_execute_tuning(struct mmc *mmc) argument
937 struct dm_mmc_ops *ops = mmc_get_ops(mmc->dev);
941 if (IS_SD(mmc))
947 if (mmc->cfg->ops->execute_tuning) {
948 return mmc->cfg->ops->execute_tuning(mmc, opcode);
951 return ops->execute_tuning(mmc->dev, opcode);
959 static int mmc_hs200_tuning(struct mmc *mmc) argument
961 return mmc_execute_tuning(mmc);
965 int mmc_send_tuning(struct mmc *mmc, u32 opcode) { return 0; } argument
966 int mmc_execute_tuning(struct mmc *mmc) { return 0; } argument
967 static int mmc_hs200_tuning(struct mmc *mmc) { return 0; } argument
970 static int mmc_select_hs(struct mmc *mmc) argument
974 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
978 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
983 static int mmc_select_hs_ddr(struct mmc *mmc) argument
988 if (mmc->bus_width == MMC_BUS_WIDTH_1BIT)
991 ext_csd_bits = (mmc->bus_width == MMC_BUS_WIDTH_8BIT) ?
994 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
999 mmc_set_timing(mmc, MMC_TIMING_MMC_DDR52);
1005 static int mmc_select_hs200(struct mmc *mmc) argument
1013 ret = mmc_select_bus_width(mmc);
1016 ret = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1023 mmc_set_timing(mmc, MMC_TIMING_MMC_HS200);
1029 static int mmc_switch_to_hs400(struct mmc *mmc) argument
1033 fixed_drv_type = mmc->cfg->fixed_drv_type;
1034 card_drv_type = mmc->raw_driver_strength | mmc_driver_type_mask(0);
1039 return __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, val, false);
1042 static int mmc_select_hs400(struct mmc *mmc) argument
1047 ret = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1053 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
1056 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1058 ret = mmc_send_status(mmc, 1000);
1063 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1070 ret = mmc_switch_to_hs400(mmc);
1075 mmc_set_timing(mmc, MMC_TIMING_MMC_HS400);
1080 static int mmc_select_hs400es(struct mmc *mmc) argument
1085 err = __mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1091 mmc_set_timing(mmc, MMC_TIMING_MMC_HS);
1093 err = mmc_send_status(mmc, 1000);
1097 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1099 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
1108 err = mmc_switch_to_hs400(mmc);
1113 mmc_set_timing(mmc, MMC_TIMING_MMC_HS400ES);
1115 return mmc_set_enhanced_strobe(mmc);
1118 static int mmc_select_hs200(struct mmc *mmc) { return 0; } argument
1119 static int mmc_select_hs400(struct mmc *mmc) { return 0; } argument
1120 static int mmc_select_hs400es(struct mmc *mmc) { return 0; } argument
1123 static u32 mmc_select_card_type(struct mmc *mmc, u8 *ext_csd) argument
1129 host_caps = mmc->cfg->host_caps;
1174 static void mmc_set_bus_speed(struct mmc *mmc, u8 avail_type) argument
1178 if (mmc_card_hs(mmc))
1181 else if (mmc_card_hs200(mmc) ||
1182 mmc_card_hs400(mmc) ||
1183 mmc_card_hs400es(mmc))
1186 mmc_set_clock(mmc, clock);
1189 static int mmc_change_freq(struct mmc *mmc) argument
1195 mmc->card_caps = 0;
1197 if (mmc_host_is_spi(mmc))
1201 if (mmc->version < MMC_VERSION_4)
1204 mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT;
1206 err = mmc_send_ext_csd(mmc, ext_csd);
1211 avail_type = mmc_select_card_type(mmc, ext_csd);
1214 err = mmc_select_bus_width(mmc);
1215 if (err > 0 && mmc->bus_width == MMC_BUS_WIDTH_8BIT) {
1216 err = mmc_select_hs400es(mmc);
1217 mmc_set_bus_speed(mmc, avail_type);
1224 err = mmc_select_hs200(mmc);
1226 err = mmc_select_hs(mmc);
1233 mmc_set_bus_speed(mmc, avail_type);
1235 if (mmc_card_hs200(mmc)) {
1236 err = mmc_hs200_tuning(mmc);
1238 mmc->bus_width == MMC_BUS_WIDTH_8BIT) {
1239 err = mmc_select_hs400(mmc);
1240 mmc_set_bus_speed(mmc, avail_type);
1242 } else if (!mmc_card_hs400es(mmc)) {
1243 err = mmc_select_bus_width(mmc) > 0 ? 0 : err;
1245 err = mmc_select_hs_ddr(mmc);
1251 static int mmc_set_capacity(struct mmc *mmc, int part_num) argument
1255 mmc->capacity = mmc->capacity_user;
1259 mmc->capacity = mmc->capacity_boot;
1262 mmc->capacity = mmc->capacity_rpmb;
1268 mmc->capacity = mmc->capacity_gp[part_num - 4];
1274 mmc_get_blk_desc(mmc)->lba = lldiv(mmc->capacity, mmc->read_bl_len);
1279 int mmc_switch_part(struct mmc *mmc, unsigned int part_num) argument
1283 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1284 (mmc->part_config & ~PART_ACCESS_MASK)
1292 ret = mmc_set_capacity(mmc, part_num);
1293 mmc_get_blk_desc(mmc)->hwpart = part_num;
1299 int mmc_hwpart_config(struct mmc *mmc, argument
1316 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) {
1321 if (!(mmc->part_support & PART_SUPPORT)) {
1326 if (!mmc->hc_wp_grp_size) {
1333 if (conf->user.enh_size % mmc->hc_wp_grp_size ||
1334 conf->user.enh_start % mmc->hc_wp_grp_size) {
1340 enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size;
1341 if (mmc->high_capacity) {
1353 if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) {
1358 gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size;
1365 if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) {
1370 err = mmc_send_ext_csd(mmc, ext_csd);
1422 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1431 mmc->erase_grp_size =
1438 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1445 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1453 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1460 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1473 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1484 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1494 int mmc_getcd(struct mmc *mmc) argument
1498 cd = board_mmc_getcd(mmc);
1501 if (mmc->cfg->ops->getcd)
1502 cd = mmc->cfg->ops->getcd(mmc);
1511 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) argument
1528 return mmc_send_cmd(mmc, &cmd, &data);
1532 static int sd_change_freq(struct mmc *mmc) argument
1541 mmc->card_caps = 0;
1543 if (mmc_host_is_spi(mmc))
1549 cmd.cmdarg = mmc->rca << 16;
1551 err = mmc_send_cmd(mmc, &cmd, NULL);
1568 err = mmc_send_cmd(mmc, &cmd, &data);
1577 mmc->scr[0] = __be32_to_cpu(scr[0]);
1578 mmc->scr[1] = __be32_to_cpu(scr[1]);
1580 switch ((mmc->scr[0] >> 24) & 0xf) {
1582 mmc->version = SD_VERSION_1_0;
1585 mmc->version = SD_VERSION_1_10;
1588 mmc->version = SD_VERSION_2;
1589 if ((mmc->scr[0] >> 15) & 0x1)
1590 mmc->version = SD_VERSION_3;
1593 mmc->version = SD_VERSION_1_0;
1597 if (mmc->scr[0] & SD_DATA_4BIT)
1598 mmc->card_caps |= MMC_MODE_4BIT;
1601 if (mmc->version == SD_VERSION_1_0)
1606 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
1627 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) &&
1628 (mmc->cfg->host_caps & MMC_MODE_HS)))
1631 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
1637 mmc->card_caps |= MMC_MODE_HS;
1642 static int sd_read_ssr(struct mmc *mmc) argument
1653 cmd.cmdarg = mmc->rca << 16;
1655 err = mmc_send_cmd(mmc, &cmd, NULL);
1669 err = mmc_send_cmd(mmc, &cmd, &data);
1681 if ((au <= 9) || (mmc->version == SD_VERSION_3)) {
1682 mmc->ssr.au = sd_au_size[au];
1688 mmc->ssr.erase_timeout = (et * 1000) / es;
1689 mmc->ssr.erase_offset = eo * 1000;
1730 static void mmc_set_ios(struct mmc *mmc) argument
1732 if (mmc->cfg->ops->set_ios)
1733 mmc->cfg->ops->set_ios(mmc);
1736 static bool mmc_card_busy(struct mmc *mmc) argument
1738 if (!mmc->cfg->ops->card_busy)
1741 return mmc->cfg->ops->card_busy(mmc);
1744 static bool mmc_can_card_busy(struct mmc *) argument
1746 return !!mmc->cfg->ops->card_busy;
1750 static int mmc_startup(struct mmc *mmc) argument
1762 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
1766 err = mmc_send_cmd(mmc, &cmd, NULL);
1774 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
1779 err = mmc_send_cmd(mmc, &cmd, NULL);
1784 memcpy(mmc->cid, cmd.response, 16);
1791 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1793 cmd.cmdarg = mmc->rca << 16;
1796 err = mmc_send_cmd(mmc, &cmd, NULL);
1801 if (IS_SD(mmc))
1802 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
1808 cmd.cmdarg = mmc->rca << 16;
1810 err = mmc_send_cmd(mmc, &cmd, NULL);
1815 mmc->csd[0] = cmd.response[0];
1816 mmc->csd[1] = cmd.response[1];
1817 mmc->csd[2] = cmd.response[2];
1818 mmc->csd[3] = cmd.response[3];
1820 if (mmc->version == MMC_VERSION_UNKNOWN) {
1825 mmc->version = MMC_VERSION_1_2;
1828 mmc->version = MMC_VERSION_1_4;
1831 mmc->version = MMC_VERSION_2_2;
1834 mmc->version = MMC_VERSION_3;
1837 mmc->version = MMC_VERSION_4;
1840 mmc->version = MMC_VERSION_1_2;
1851 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
1852 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
1854 if (IS_SD(mmc))
1855 mmc->write_bl_len = mmc->read_bl_len;
1857 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
1859 if (mmc->high_capacity) {
1860 csize = (mmc->csd[1] & 0x3f) << 16
1861 | (mmc->csd[2] & 0xffff0000) >> 16;
1864 csize = (mmc->csd[1] & 0x3ff) << 2
1865 | (mmc->csd[2] & 0xc0000000) >> 30;
1866 cmult = (mmc->csd[2] & 0x00038000) >> 15;
1869 mmc->capacity_user = (csize + 1) << (cmult + 2);
1870 mmc->capacity_user *= mmc->read_bl_len;
1871 mmc->capacity_boot = 0;
1872 mmc->capacity_rpmb = 0;
1874 mmc->capacity_gp[i] = 0;
1876 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
1877 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1879 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
1880 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1882 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
1884 cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
1886 if (mmc_send_cmd(mmc, &cmd, NULL))
1891 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1894 cmd.cmdarg = mmc->rca << 16;
1895 err = mmc_send_cmd(mmc, &cmd, NULL);
1904 mmc->erase_grp_size = 1;
1905 mmc->part_config = MMCPART_NOAVAILABLE;
1906 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1908 mmc_select_hs(mmc);
1909 mmc_set_clock(mmc, MMC_HIGH_52_MAX_DTR);
1912 err = mmc_send_ext_csd(mmc, ext_csd);
1927 mmc->capacity_user = capacity;
1932 mmc->version = MMC_VERSION_4_1;
1935 mmc->version = MMC_VERSION_4_2;
1938 mmc->version = MMC_VERSION_4_3;
1941 mmc->version = MMC_VERSION_4_41;
1944 mmc->version = MMC_VERSION_4_5;
1947 mmc->version = MMC_VERSION_5_0;
1950 mmc->version = MMC_VERSION_5_1;
1963 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT];
1966 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1969 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE];
1971 mmc->esr.mmc_can_trim = 1;
1973 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1975 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1985 mmc->capacity_gp[i] = mult;
1986 mmc->capacity_gp[i] *=
1988 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1989 mmc->capacity_gp[i] <<= 19;
1993 mmc->enh_user_size =
1997 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1998 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1999 mmc->enh_user_size <<= 19;
2000 mmc->enh_user_start =
2005 if (mmc->high_capacity)
2006 mmc->enh_user_start <<= 9;
2020 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
2031 mmc->erase_grp_size =
2038 if (mmc->high_capacity && part_completed) {
2044 mmc->capacity_user = capacity;
2049 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
2050 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
2051 mmc->erase_grp_size = (erase_gsz + 1)
2055 mmc->hc_wp_grp_size = 1024
2059 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
2061 mmc->raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
2064 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart);
2068 if (IS_SD(mmc))
2069 err = sd_change_freq(mmc);
2071 err = mmc_change_freq(mmc);
2077 mmc->card_caps &= mmc->cfg->host_caps;
2079 if (IS_SD(mmc)) {
2080 if (mmc->card_caps & MMC_MODE_4BIT) {
2083 cmd.cmdarg = mmc->rca << 16;
2085 err = mmc_send_cmd(mmc, &cmd, NULL);
2092 err = mmc_send_cmd(mmc, &cmd, NULL);
2096 mmc_set_bus_width(mmc, 4);
2099 err = sd_read_ssr(mmc);
2103 if (mmc->card_caps & MMC_MODE_HS)
2108 mmc_set_clock(mmc, tran_speed);
2112 if (mmc_card_ddr(mmc)) {
2113 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
2114 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
2118 bdesc = mmc_get_blk_desc(mmc);
2122 bdesc->blksz = mmc->read_bl_len;
2124 bdesc->lba = lldiv(mmc->capacity, mmc->read_bl_len);
2129 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
2130 (mmc->cid[3] >> 16) & 0xffff);
2131 sprintf(bdesc->product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
2132 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
2133 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
2134 (mmc->cid[2] >> 24) & 0xff);
2135 sprintf(bdesc->revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
2136 (mmc->cid[2] >> 16) & 0xf);
2150 static int mmc_send_if_cond(struct mmc *mmc) argument
2157 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
2160 err = mmc_send_cmd(mmc, &cmd, NULL);
2168 mmc->version = SD_VERSION_2;
2182 static int mmc_power_init(struct mmc *mmc) argument
2189 ret = device_get_supply_regulator(mmc->dev, "vmmc-supply",
2192 debug("%s: No vmmc supply\n", mmc->dev->name);
2213 static int mmc_select_card(struct mmc *mmc, int n) argument
2219 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
2220 mmc->rca = n;
2223 cmd.cmdarg = mmc->rca << 16;
2224 err = mmc_send_cmd(mmc, &cmd, NULL);
2230 int mmc_start_init(struct mmc *mmc) argument
2237 if (mmc->cfg->host_caps & MMC_MODE_8BIT)
2239 else if (mmc->cfg->host_caps & MMC_MODE_4BIT)
2241 mmc_set_bus_width(mmc, bus_width);
2243 mmc_set_clock(mmc, 1);
2244 mmc_set_timing(mmc, MMC_TIMING_LEGACY);
2246 mmc_select_card(mmc, 0);
2247 mmc->version = MMC_VERSION_UNKNOWN;
2248 mmc->high_capacity = 1;
2254 mmc->rca = 2;
2256 mmc->rca = 1;
2261 int mmc_start_init(struct mmc *mmc) argument
2267 no_card = mmc_getcd(mmc) == 0;
2269 no_card = no_card || (mmc->cfg->ops->init == NULL);
2272 mmc->has_init = 0;
2279 if (mmc->has_init)
2285 err = mmc_power_init(mmc);
2293 err = mmc->cfg->ops->init(mmc);
2297 mmc_set_bus_width(mmc, 1);
2298 mmc_set_clock(mmc, 1);
2299 mmc_set_timing(mmc, MMC_TIMING_LEGACY);
2302 err = mmc_go_idle(mmc);
2308 mmc_get_blk_desc(mmc)->hwpart = 0;
2311 err = mmc_send_if_cond(mmc);
2314 err = sd_send_op_cond(mmc);
2318 err = mmc_send_op_cond(mmc);
2329 mmc->init_in_progress = 1;
2335 static int mmc_complete_init(struct mmc *mmc) argument
2339 mmc->init_in_progress = 0;
2340 if (mmc->op_cond_pending)
2341 err = mmc_complete_op_cond(mmc);
2344 err = mmc_startup(mmc);
2346 mmc->has_init = 0;
2348 mmc->has_init = 1;
2352 int mmc_init(struct mmc *mmc) argument
2357 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev);
2359 upriv->mmc = mmc;
2361 if (mmc->has_init)
2366 if (!mmc->init_in_progress)
2367 err = mmc_start_init(mmc);
2370 err = mmc_complete_init(mmc);
2377 int mmc_set_dsr(struct mmc *mmc, u16 val) argument
2379 mmc->dsr = val;
2395 void mmc_set_preinit(struct mmc *mmc, int preinit) argument
2397 mmc->preinit = preinit;
2470 int mmc_set_bkops_enable(struct mmc *mmc) argument
2475 err = mmc_send_ext_csd(mmc, ext_csd);
2491 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BKOPS_EN, 1);