2358 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * linux/drivers/mmc/core/mmc.c4 *5 * Copyright (C) 2003-2004 Russell King, All Rights Reserved.6 * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.7 * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.8 */9 10#include <linux/err.h>11#include <linux/of.h>12#include <linux/slab.h>13#include <linux/stat.h>14#include <linux/pm_runtime.h>15#include <linux/random.h>16#include <linux/sysfs.h>17 18#include <linux/mmc/host.h>19#include <linux/mmc/card.h>20#include <linux/mmc/mmc.h>21 22#include "core.h"23#include "card.h"24#include "host.h"25#include "bus.h"26#include "mmc_ops.h"27#include "quirks.h"28#include "sd_ops.h"29#include "pwrseq.h"30 31#define DEFAULT_CMD6_TIMEOUT_MS 50032#define MIN_CACHE_EN_TIMEOUT_MS 160033#define CACHE_FLUSH_TIMEOUT_MS 30000 /* 30s */34 35static const unsigned int tran_exp[] = {36 10000, 100000, 1000000, 10000000,37 0, 0, 0, 038};39 40static const unsigned char tran_mant[] = {41 0, 10, 12, 13, 15, 20, 25, 30,42 35, 40, 45, 50, 55, 60, 70, 80,43};44 45static const unsigned int taac_exp[] = {46 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,47};48 49static const unsigned int taac_mant[] = {50 0, 10, 12, 13, 15, 20, 25, 30,51 35, 40, 45, 50, 55, 60, 70, 80,52};53 54/*55 * Given the decoded CSD structure, decode the raw CID to our CID structure.56 */57static int mmc_decode_cid(struct mmc_card *card)58{59 u32 *resp = card->raw_cid;60 61 /*62 * Add the raw card ID (cid) data to the entropy pool. It doesn't63 * matter that not all of it is unique, it's just bonus entropy.64 */65 add_device_randomness(&card->raw_cid, sizeof(card->raw_cid));66 67 /*68 * The selection of the format here is based upon published69 * specs from sandisk and from what people have reported.70 */71 switch (card->csd.mmca_vsn) {72 case 0: /* MMC v1.0 - v1.2 */73 case 1: /* MMC v1.4 */74 card->cid.manfid = unstuff_bits(resp, 104, 24);75 card->cid.prod_name[0] = unstuff_bits(resp, 96, 8);76 card->cid.prod_name[1] = unstuff_bits(resp, 88, 8);77 card->cid.prod_name[2] = unstuff_bits(resp, 80, 8);78 card->cid.prod_name[3] = unstuff_bits(resp, 72, 8);79 card->cid.prod_name[4] = unstuff_bits(resp, 64, 8);80 card->cid.prod_name[5] = unstuff_bits(resp, 56, 8);81 card->cid.prod_name[6] = unstuff_bits(resp, 48, 8);82 card->cid.hwrev = unstuff_bits(resp, 44, 4);83 card->cid.fwrev = unstuff_bits(resp, 40, 4);84 card->cid.serial = unstuff_bits(resp, 16, 24);85 card->cid.month = unstuff_bits(resp, 12, 4);86 card->cid.year = unstuff_bits(resp, 8, 4) + 1997;87 break;88 89 case 2: /* MMC v2.0 - v2.2 */90 case 3: /* MMC v3.1 - v3.3 */91 case 4: /* MMC v4 */92 card->cid.manfid = unstuff_bits(resp, 120, 8);93 card->cid.oemid = unstuff_bits(resp, 104, 16);94 card->cid.prod_name[0] = unstuff_bits(resp, 96, 8);95 card->cid.prod_name[1] = unstuff_bits(resp, 88, 8);96 card->cid.prod_name[2] = unstuff_bits(resp, 80, 8);97 card->cid.prod_name[3] = unstuff_bits(resp, 72, 8);98 card->cid.prod_name[4] = unstuff_bits(resp, 64, 8);99 card->cid.prod_name[5] = unstuff_bits(resp, 56, 8);100 card->cid.prv = unstuff_bits(resp, 48, 8);101 card->cid.serial = unstuff_bits(resp, 16, 32);102 card->cid.month = unstuff_bits(resp, 12, 4);103 card->cid.year = unstuff_bits(resp, 8, 4) + 1997;104 break;105 106 default:107 pr_err("%s: card has unknown MMCA version %d\n",108 mmc_hostname(card->host), card->csd.mmca_vsn);109 return -EINVAL;110 }111 112 return 0;113}114 115static void mmc_set_erase_size(struct mmc_card *card)116{117 if (card->ext_csd.erase_group_def & 1)118 card->erase_size = card->ext_csd.hc_erase_size;119 else120 card->erase_size = card->csd.erase_size;121 122 mmc_init_erase(card);123}124 125 126static void mmc_set_wp_grp_size(struct mmc_card *card)127{128 if (card->ext_csd.erase_group_def & 1)129 card->wp_grp_size = card->ext_csd.hc_erase_size *130 card->ext_csd.raw_hc_erase_gap_size;131 else132 card->wp_grp_size = card->csd.erase_size *133 (card->csd.wp_grp_size + 1);134}135 136/*137 * Given a 128-bit response, decode to our card CSD structure.138 */139static int mmc_decode_csd(struct mmc_card *card)140{141 struct mmc_csd *csd = &card->csd;142 unsigned int e, m, a, b;143 u32 *resp = card->raw_csd;144 145 /*146 * We only understand CSD structure v1.1 and v1.2.147 * v1.2 has extra information in bits 15, 11 and 10.148 * We also support eMMC v4.4 & v4.41.149 */150 csd->structure = unstuff_bits(resp, 126, 2);151 if (csd->structure == 0) {152 pr_err("%s: unrecognised CSD structure version %d\n",153 mmc_hostname(card->host), csd->structure);154 return -EINVAL;155 }156 157 csd->mmca_vsn = unstuff_bits(resp, 122, 4);158 m = unstuff_bits(resp, 115, 4);159 e = unstuff_bits(resp, 112, 3);160 csd->taac_ns = (taac_exp[e] * taac_mant[m] + 9) / 10;161 csd->taac_clks = unstuff_bits(resp, 104, 8) * 100;162 163 m = unstuff_bits(resp, 99, 4);164 e = unstuff_bits(resp, 96, 3);165 csd->max_dtr = tran_exp[e] * tran_mant[m];166 csd->cmdclass = unstuff_bits(resp, 84, 12);167 168 e = unstuff_bits(resp, 47, 3);169 m = unstuff_bits(resp, 62, 12);170 csd->capacity = (1 + m) << (e + 2);171 172 csd->read_blkbits = unstuff_bits(resp, 80, 4);173 csd->read_partial = unstuff_bits(resp, 79, 1);174 csd->write_misalign = unstuff_bits(resp, 78, 1);175 csd->read_misalign = unstuff_bits(resp, 77, 1);176 csd->dsr_imp = unstuff_bits(resp, 76, 1);177 csd->r2w_factor = unstuff_bits(resp, 26, 3);178 csd->write_blkbits = unstuff_bits(resp, 22, 4);179 csd->write_partial = unstuff_bits(resp, 21, 1);180 181 if (csd->write_blkbits >= 9) {182 a = unstuff_bits(resp, 42, 5);183 b = unstuff_bits(resp, 37, 5);184 csd->erase_size = (a + 1) * (b + 1);185 csd->erase_size <<= csd->write_blkbits - 9;186 csd->wp_grp_size = unstuff_bits(resp, 32, 5);187 }188 189 return 0;190}191 192static void mmc_select_card_type(struct mmc_card *card)193{194 struct mmc_host *host = card->host;195 u8 card_type = card->ext_csd.raw_card_type;196 u32 caps = host->caps, caps2 = host->caps2;197 unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;198 unsigned int avail_type = 0;199 200 if (caps & MMC_CAP_MMC_HIGHSPEED &&201 card_type & EXT_CSD_CARD_TYPE_HS_26) {202 hs_max_dtr = MMC_HIGH_26_MAX_DTR;203 avail_type |= EXT_CSD_CARD_TYPE_HS_26;204 }205 206 if (caps & MMC_CAP_MMC_HIGHSPEED &&207 card_type & EXT_CSD_CARD_TYPE_HS_52) {208 hs_max_dtr = MMC_HIGH_52_MAX_DTR;209 avail_type |= EXT_CSD_CARD_TYPE_HS_52;210 }211 212 if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&213 card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {214 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;215 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;216 }217 218 if (caps & MMC_CAP_1_2V_DDR &&219 card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {220 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;221 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;222 }223 224 if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&225 card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {226 hs200_max_dtr = MMC_HS200_MAX_DTR;227 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;228 }229 230 if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&231 card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {232 hs200_max_dtr = MMC_HS200_MAX_DTR;233 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;234 }235 236 if (caps2 & MMC_CAP2_HS400_1_8V &&237 card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {238 hs200_max_dtr = MMC_HS200_MAX_DTR;239 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;240 }241 242 if (caps2 & MMC_CAP2_HS400_1_2V &&243 card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {244 hs200_max_dtr = MMC_HS200_MAX_DTR;245 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;246 }247 248 if ((caps2 & MMC_CAP2_HS400_ES) &&249 card->ext_csd.strobe_support &&250 (avail_type & EXT_CSD_CARD_TYPE_HS400))251 avail_type |= EXT_CSD_CARD_TYPE_HS400ES;252 253 card->ext_csd.hs_max_dtr = hs_max_dtr;254 card->ext_csd.hs200_max_dtr = hs200_max_dtr;255 card->mmc_avail_type = avail_type;256}257 258static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)259{260 u8 hc_erase_grp_sz, hc_wp_grp_sz;261 262 /*263 * Disable these attributes by default264 */265 card->ext_csd.enhanced_area_offset = -EINVAL;266 card->ext_csd.enhanced_area_size = -EINVAL;267 268 /*269 * Enhanced area feature support -- check whether the eMMC270 * card has the Enhanced area enabled. If so, export enhanced271 * area offset and size to user by adding sysfs interface.272 */273 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&274 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {275 if (card->ext_csd.partition_setting_completed) {276 hc_erase_grp_sz =277 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];278 hc_wp_grp_sz =279 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];280 281 /*282 * calculate the enhanced data area offset, in bytes283 */284 card->ext_csd.enhanced_area_offset =285 (((unsigned long long)ext_csd[139]) << 24) +286 (((unsigned long long)ext_csd[138]) << 16) +287 (((unsigned long long)ext_csd[137]) << 8) +288 (((unsigned long long)ext_csd[136]));289 if (mmc_card_blockaddr(card))290 card->ext_csd.enhanced_area_offset <<= 9;291 /*292 * calculate the enhanced data area size, in kilobytes293 */294 card->ext_csd.enhanced_area_size =295 (ext_csd[142] << 16) + (ext_csd[141] << 8) +296 ext_csd[140];297 card->ext_csd.enhanced_area_size *=298 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);299 card->ext_csd.enhanced_area_size <<= 9;300 } else {301 pr_warn("%s: defines enhanced area without partition setting complete\n",302 mmc_hostname(card->host));303 }304 }305}306 307static void mmc_part_add(struct mmc_card *card, u64 size,308 unsigned int part_cfg, char *name, int idx, bool ro,309 int area_type)310{311 card->part[card->nr_parts].size = size;312 card->part[card->nr_parts].part_cfg = part_cfg;313 sprintf(card->part[card->nr_parts].name, name, idx);314 card->part[card->nr_parts].force_ro = ro;315 card->part[card->nr_parts].area_type = area_type;316 card->nr_parts++;317}318 319static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)320{321 int idx;322 u8 hc_erase_grp_sz, hc_wp_grp_sz;323 u64 part_size;324 325 /*326 * General purpose partition feature support --327 * If ext_csd has the size of general purpose partitions,328 * set size, part_cfg, partition name in mmc_part.329 */330 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &331 EXT_CSD_PART_SUPPORT_PART_EN) {332 hc_erase_grp_sz =333 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];334 hc_wp_grp_sz =335 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];336 337 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {338 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&339 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&340 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])341 continue;342 if (card->ext_csd.partition_setting_completed == 0) {343 pr_warn("%s: has partition size defined without partition complete\n",344 mmc_hostname(card->host));345 break;346 }347 part_size =348 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]349 << 16) +350 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]351 << 8) +352 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];353 part_size *= (hc_erase_grp_sz * hc_wp_grp_sz);354 mmc_part_add(card, part_size << 19,355 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,356 "gp%d", idx, false,357 MMC_BLK_DATA_AREA_GP);358 }359 }360}361 362/* Minimum partition switch timeout in milliseconds */363#define MMC_MIN_PART_SWITCH_TIME 300364 365/*366 * Decode extended CSD.367 */368static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)369{370 int err = 0, idx;371 u64 part_size;372 struct device_node *np;373 bool broken_hpi = false;374 375 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */376 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];377 if (card->csd.structure == 3) {378 if (card->ext_csd.raw_ext_csd_structure > 2) {379 pr_err("%s: unrecognised EXT_CSD structure "380 "version %d\n", mmc_hostname(card->host),381 card->ext_csd.raw_ext_csd_structure);382 err = -EINVAL;383 goto out;384 }385 }386 387 np = mmc_of_find_child_device(card->host, 0);388 if (np && of_device_is_compatible(np, "mmc-card"))389 broken_hpi = of_property_read_bool(np, "broken-hpi");390 of_node_put(np);391 392 /*393 * The EXT_CSD format is meant to be forward compatible. As long394 * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV395 * are authorized, see JEDEC JESD84-B50 section B.8.396 */397 card->ext_csd.rev = ext_csd[EXT_CSD_REV];398 399 /* fixup device after ext_csd revision field is updated */400 mmc_fixup_device(card, mmc_ext_csd_fixups);401 402 card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];403 card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];404 card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];405 card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];406 if (card->ext_csd.rev >= 2) {407 card->ext_csd.sectors =408 ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |409 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |410 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |411 ext_csd[EXT_CSD_SEC_CNT + 3] << 24;412 413 /* Cards with density > 2GiB are sector addressed */414 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)415 mmc_card_set_blockaddr(card);416 }417 418 card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];419 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];420 421 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];422 card->ext_csd.raw_erase_timeout_mult =423 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];424 card->ext_csd.raw_hc_erase_grp_size =425 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];426 card->ext_csd.raw_boot_mult =427 ext_csd[EXT_CSD_BOOT_MULT];428 if (card->ext_csd.rev >= 3) {429 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];430 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];431 432 /* EXT_CSD value is in units of 10ms, but we store in ms */433 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];434 435 /* Sleep / awake timeout in 100ns units */436 if (sa_shift > 0 && sa_shift <= 0x17)437 card->ext_csd.sa_timeout =438 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];439 card->ext_csd.erase_group_def =440 ext_csd[EXT_CSD_ERASE_GROUP_DEF];441 card->ext_csd.hc_erase_timeout = 300 *442 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];443 card->ext_csd.hc_erase_size =444 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;445 446 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];447 448 /*449 * There are two boot regions of equal size, defined in450 * multiples of 128K.451 */452 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {453 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {454 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;455 mmc_part_add(card, part_size,456 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,457 "boot%d", idx, true,458 MMC_BLK_DATA_AREA_BOOT);459 }460 }461 }462 463 card->ext_csd.raw_hc_erase_gap_size =464 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];465 card->ext_csd.raw_sec_trim_mult =466 ext_csd[EXT_CSD_SEC_TRIM_MULT];467 card->ext_csd.raw_sec_erase_mult =468 ext_csd[EXT_CSD_SEC_ERASE_MULT];469 card->ext_csd.raw_sec_feature_support =470 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];471 card->ext_csd.raw_trim_mult =472 ext_csd[EXT_CSD_TRIM_MULT];473 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];474 card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];475 if (card->ext_csd.rev >= 4) {476 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &477 EXT_CSD_PART_SETTING_COMPLETED)478 card->ext_csd.partition_setting_completed = 1;479 else480 card->ext_csd.partition_setting_completed = 0;481 482 mmc_manage_enhanced_area(card, ext_csd);483 484 mmc_manage_gp_partitions(card, ext_csd);485 486 card->ext_csd.sec_trim_mult =487 ext_csd[EXT_CSD_SEC_TRIM_MULT];488 card->ext_csd.sec_erase_mult =489 ext_csd[EXT_CSD_SEC_ERASE_MULT];490 card->ext_csd.sec_feature_support =491 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];492 card->ext_csd.trim_timeout = 300 *493 ext_csd[EXT_CSD_TRIM_MULT];494 495 /*496 * Note that the call to mmc_part_add above defaults to read497 * only. If this default assumption is changed, the call must498 * take into account the value of boot_locked below.499 */500 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];501 card->ext_csd.boot_ro_lockable = true;502 503 /* Save power class values */504 card->ext_csd.raw_pwr_cl_52_195 =505 ext_csd[EXT_CSD_PWR_CL_52_195];506 card->ext_csd.raw_pwr_cl_26_195 =507 ext_csd[EXT_CSD_PWR_CL_26_195];508 card->ext_csd.raw_pwr_cl_52_360 =509 ext_csd[EXT_CSD_PWR_CL_52_360];510 card->ext_csd.raw_pwr_cl_26_360 =511 ext_csd[EXT_CSD_PWR_CL_26_360];512 card->ext_csd.raw_pwr_cl_200_195 =513 ext_csd[EXT_CSD_PWR_CL_200_195];514 card->ext_csd.raw_pwr_cl_200_360 =515 ext_csd[EXT_CSD_PWR_CL_200_360];516 card->ext_csd.raw_pwr_cl_ddr_52_195 =517 ext_csd[EXT_CSD_PWR_CL_DDR_52_195];518 card->ext_csd.raw_pwr_cl_ddr_52_360 =519 ext_csd[EXT_CSD_PWR_CL_DDR_52_360];520 card->ext_csd.raw_pwr_cl_ddr_200_360 =521 ext_csd[EXT_CSD_PWR_CL_DDR_200_360];522 }523 524 if (card->ext_csd.rev >= 5) {525 /* Adjust production date as per JEDEC JESD84-B451 */526 if (card->cid.year < 2010)527 card->cid.year += 16;528 529 /* check whether the eMMC card supports BKOPS */530 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {531 card->ext_csd.bkops = 1;532 card->ext_csd.man_bkops_en =533 (ext_csd[EXT_CSD_BKOPS_EN] &534 EXT_CSD_MANUAL_BKOPS_MASK);535 card->ext_csd.raw_bkops_status =536 ext_csd[EXT_CSD_BKOPS_STATUS];537 if (card->ext_csd.man_bkops_en)538 pr_debug("%s: MAN_BKOPS_EN bit is set\n",539 mmc_hostname(card->host));540 card->ext_csd.auto_bkops_en =541 (ext_csd[EXT_CSD_BKOPS_EN] &542 EXT_CSD_AUTO_BKOPS_MASK);543 if (card->ext_csd.auto_bkops_en)544 pr_debug("%s: AUTO_BKOPS_EN bit is set\n",545 mmc_hostname(card->host));546 }547 548 /* check whether the eMMC card supports HPI */549 if (!mmc_card_broken_hpi(card) &&550 !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {551 card->ext_csd.hpi = 1;552 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)553 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;554 else555 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;556 /*557 * Indicate the maximum timeout to close558 * a command interrupted by HPI559 */560 card->ext_csd.out_of_int_time =561 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;562 }563 564 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];565 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];566 567 /*568 * RPMB regions are defined in multiples of 128K.569 */570 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];571 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {572 mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,573 EXT_CSD_PART_CONFIG_ACC_RPMB,574 "rpmb", 0, false,575 MMC_BLK_DATA_AREA_RPMB);576 }577 }578 579 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];580 if (ext_csd[EXT_CSD_ERASED_MEM_CONT])581 card->erased_byte = 0xFF;582 else583 card->erased_byte = 0x0;584 585 /* eMMC v4.5 or later */586 card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;587 if (card->ext_csd.rev >= 6) {588 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;589 590 card->ext_csd.generic_cmd6_time = 10 *591 ext_csd[EXT_CSD_GENERIC_CMD6_TIME];592 card->ext_csd.power_off_longtime = 10 *593 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];594 595 card->ext_csd.cache_size =596 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |597 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |598 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |599 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;600 601 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)602 card->ext_csd.data_sector_size = 4096;603 else604 card->ext_csd.data_sector_size = 512;605 606 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&607 (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {608 card->ext_csd.data_tag_unit_size =609 ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *610 (card->ext_csd.data_sector_size);611 } else {612 card->ext_csd.data_tag_unit_size = 0;613 }614 } else {615 card->ext_csd.data_sector_size = 512;616 }617 618 /*619 * GENERIC_CMD6_TIME is to be used "unless a specific timeout is defined620 * when accessing a specific field", so use it here if there is no621 * PARTITION_SWITCH_TIME.622 */623 if (!card->ext_csd.part_time)624 card->ext_csd.part_time = card->ext_csd.generic_cmd6_time;625 /* Some eMMC set the value too low so set a minimum */626 if (card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)627 card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;628 629 /* eMMC v5 or later */630 if (card->ext_csd.rev >= 7) {631 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],632 MMC_FIRMWARE_LEN);633 card->ext_csd.ffu_capable =634 (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&635 !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);636 637 card->ext_csd.pre_eol_info = ext_csd[EXT_CSD_PRE_EOL_INFO];638 card->ext_csd.device_life_time_est_typ_a =639 ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_A];640 card->ext_csd.device_life_time_est_typ_b =641 ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_B];642 }643 644 /* eMMC v5.1 or later */645 if (card->ext_csd.rev >= 8) {646 card->ext_csd.cmdq_support = ext_csd[EXT_CSD_CMDQ_SUPPORT] &647 EXT_CSD_CMDQ_SUPPORTED;648 card->ext_csd.cmdq_depth = (ext_csd[EXT_CSD_CMDQ_DEPTH] &649 EXT_CSD_CMDQ_DEPTH_MASK) + 1;650 /* Exclude inefficiently small queue depths */651 if (card->ext_csd.cmdq_depth <= 2) {652 card->ext_csd.cmdq_support = false;653 card->ext_csd.cmdq_depth = 0;654 }655 if (card->ext_csd.cmdq_support) {656 pr_debug("%s: Command Queue supported depth %u\n",657 mmc_hostname(card->host),658 card->ext_csd.cmdq_depth);659 }660 card->ext_csd.enhanced_rpmb_supported =661 (card->ext_csd.rel_param &662 EXT_CSD_WR_REL_PARAM_EN_RPMB_REL_WR);663 }664out:665 return err;666}667 668static int mmc_read_ext_csd(struct mmc_card *card)669{670 u8 *ext_csd;671 int err;672 673 if (!mmc_can_ext_csd(card))674 return 0;675 676 err = mmc_get_ext_csd(card, &ext_csd);677 if (err) {678 /* If the host or the card can't do the switch,679 * fail more gracefully. */680 if ((err != -EINVAL)681 && (err != -ENOSYS)682 && (err != -EFAULT))683 return err;684 685 /*686 * High capacity cards should have this "magic" size687 * stored in their CSD.688 */689 if (card->csd.capacity == (4096 * 512)) {690 pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",691 mmc_hostname(card->host));692 } else {693 pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",694 mmc_hostname(card->host));695 err = 0;696 }697 698 return err;699 }700 701 err = mmc_decode_ext_csd(card, ext_csd);702 kfree(ext_csd);703 return err;704}705 706static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)707{708 u8 *bw_ext_csd;709 int err;710 711 if (bus_width == MMC_BUS_WIDTH_1)712 return 0;713 714 err = mmc_get_ext_csd(card, &bw_ext_csd);715 if (err)716 return err;717 718 /* only compare read only fields */719 err = !((card->ext_csd.raw_partition_support ==720 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&721 (card->ext_csd.raw_erased_mem_count ==722 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&723 (card->ext_csd.rev ==724 bw_ext_csd[EXT_CSD_REV]) &&725 (card->ext_csd.raw_ext_csd_structure ==726 bw_ext_csd[EXT_CSD_STRUCTURE]) &&727 (card->ext_csd.raw_card_type ==728 bw_ext_csd[EXT_CSD_CARD_TYPE]) &&729 (card->ext_csd.raw_s_a_timeout ==730 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&731 (card->ext_csd.raw_hc_erase_gap_size ==732 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&733 (card->ext_csd.raw_erase_timeout_mult ==734 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&735 (card->ext_csd.raw_hc_erase_grp_size ==736 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&737 (card->ext_csd.raw_sec_trim_mult ==738 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&739 (card->ext_csd.raw_sec_erase_mult ==740 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&741 (card->ext_csd.raw_sec_feature_support ==742 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&743 (card->ext_csd.raw_trim_mult ==744 bw_ext_csd[EXT_CSD_TRIM_MULT]) &&745 (card->ext_csd.raw_sectors[0] ==746 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&747 (card->ext_csd.raw_sectors[1] ==748 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&749 (card->ext_csd.raw_sectors[2] ==750 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&751 (card->ext_csd.raw_sectors[3] ==752 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&753 (card->ext_csd.raw_pwr_cl_52_195 ==754 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&755 (card->ext_csd.raw_pwr_cl_26_195 ==756 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&757 (card->ext_csd.raw_pwr_cl_52_360 ==758 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&759 (card->ext_csd.raw_pwr_cl_26_360 ==760 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&761 (card->ext_csd.raw_pwr_cl_200_195 ==762 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&763 (card->ext_csd.raw_pwr_cl_200_360 ==764 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&765 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==766 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&767 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==768 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&769 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==770 bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));771 772 if (err)773 err = -EINVAL;774 775 kfree(bw_ext_csd);776 return err;777}778 779MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],780 card->raw_cid[2], card->raw_cid[3]);781MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],782 card->raw_csd[2], card->raw_csd[3]);783MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);784MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);785MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);786MMC_DEV_ATTR(wp_grp_size, "%u\n", card->wp_grp_size << 9);787MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);788MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);789MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);790MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);791MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);792MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);793MMC_DEV_ATTR(rev, "0x%x\n", card->ext_csd.rev);794MMC_DEV_ATTR(pre_eol_info, "0x%02x\n", card->ext_csd.pre_eol_info);795MMC_DEV_ATTR(life_time, "0x%02x 0x%02x\n",796 card->ext_csd.device_life_time_est_typ_a,797 card->ext_csd.device_life_time_est_typ_b);798MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);799MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",800 card->ext_csd.enhanced_area_offset);801MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);802MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);803MMC_DEV_ATTR(enhanced_rpmb_supported, "%#x\n",804 card->ext_csd.enhanced_rpmb_supported);805MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);806MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);807MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);808MMC_DEV_ATTR(cmdq_en, "%d\n", card->ext_csd.cmdq_en);809 810static ssize_t mmc_fwrev_show(struct device *dev,811 struct device_attribute *attr,812 char *buf)813{814 struct mmc_card *card = mmc_dev_to_card(dev);815 816 if (card->ext_csd.rev < 7)817 return sysfs_emit(buf, "0x%x\n", card->cid.fwrev);818 else819 return sysfs_emit(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,820 card->ext_csd.fwrev);821}822 823static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);824 825static ssize_t mmc_dsr_show(struct device *dev,826 struct device_attribute *attr,827 char *buf)828{829 struct mmc_card *card = mmc_dev_to_card(dev);830 struct mmc_host *host = card->host;831 832 if (card->csd.dsr_imp && host->dsr_req)833 return sysfs_emit(buf, "0x%x\n", host->dsr);834 else835 /* return default DSR value */836 return sysfs_emit(buf, "0x%x\n", 0x404);837}838 839static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);840 841static struct attribute *mmc_std_attrs[] = {842 &dev_attr_cid.attr,843 &dev_attr_csd.attr,844 &dev_attr_date.attr,845 &dev_attr_erase_size.attr,846 &dev_attr_preferred_erase_size.attr,847 &dev_attr_wp_grp_size.attr,848 &dev_attr_fwrev.attr,849 &dev_attr_ffu_capable.attr,850 &dev_attr_hwrev.attr,851 &dev_attr_manfid.attr,852 &dev_attr_name.attr,853 &dev_attr_oemid.attr,854 &dev_attr_prv.attr,855 &dev_attr_rev.attr,856 &dev_attr_pre_eol_info.attr,857 &dev_attr_life_time.attr,858 &dev_attr_serial.attr,859 &dev_attr_enhanced_area_offset.attr,860 &dev_attr_enhanced_area_size.attr,861 &dev_attr_raw_rpmb_size_mult.attr,862 &dev_attr_enhanced_rpmb_supported.attr,863 &dev_attr_rel_sectors.attr,864 &dev_attr_ocr.attr,865 &dev_attr_rca.attr,866 &dev_attr_dsr.attr,867 &dev_attr_cmdq_en.attr,868 NULL,869};870ATTRIBUTE_GROUPS(mmc_std);871 872static const struct device_type mmc_type = {873 .groups = mmc_std_groups,874};875 876/*877 * Select the PowerClass for the current bus width878 * If power class is defined for 4/8 bit bus in the879 * extended CSD register, select it by executing the880 * mmc_switch command.881 */882static int __mmc_select_powerclass(struct mmc_card *card,883 unsigned int bus_width)884{885 struct mmc_host *host = card->host;886 struct mmc_ext_csd *ext_csd = &card->ext_csd;887 unsigned int pwrclass_val = 0;888 int err = 0;889 890 switch (1 << host->ios.vdd) {891 case MMC_VDD_165_195:892 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)893 pwrclass_val = ext_csd->raw_pwr_cl_26_195;894 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)895 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?896 ext_csd->raw_pwr_cl_52_195 :897 ext_csd->raw_pwr_cl_ddr_52_195;898 else if (host->ios.clock <= MMC_HS200_MAX_DTR)899 pwrclass_val = ext_csd->raw_pwr_cl_200_195;900 break;901 case MMC_VDD_27_28:902 case MMC_VDD_28_29:903 case MMC_VDD_29_30:904 case MMC_VDD_30_31:905 case MMC_VDD_31_32:906 case MMC_VDD_32_33:907 case MMC_VDD_33_34:908 case MMC_VDD_34_35:909 case MMC_VDD_35_36:910 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)911 pwrclass_val = ext_csd->raw_pwr_cl_26_360;912 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)913 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?914 ext_csd->raw_pwr_cl_52_360 :915 ext_csd->raw_pwr_cl_ddr_52_360;916 else if (host->ios.clock <= MMC_HS200_MAX_DTR)917 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?918 ext_csd->raw_pwr_cl_ddr_200_360 :919 ext_csd->raw_pwr_cl_200_360;920 break;921 default:922 pr_warn("%s: Voltage range not supported for power class\n",923 mmc_hostname(host));924 return -EINVAL;925 }926 927 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))928 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>929 EXT_CSD_PWR_CL_8BIT_SHIFT;930 else931 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>932 EXT_CSD_PWR_CL_4BIT_SHIFT;933 934 /* If the power class is different from the default value */935 if (pwrclass_val > 0) {936 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,937 EXT_CSD_POWER_CLASS,938 pwrclass_val,939 card->ext_csd.generic_cmd6_time);940 }941 942 return err;943}944 945static int mmc_select_powerclass(struct mmc_card *card)946{947 struct mmc_host *host = card->host;948 u32 bus_width, ext_csd_bits;949 int err, ddr;950 951 /* Power class selection is supported for versions >= 4.0 */952 if (!mmc_can_ext_csd(card))953 return 0;954 955 bus_width = host->ios.bus_width;956 /* Power class values are defined only for 4/8 bit bus */957 if (bus_width == MMC_BUS_WIDTH_1)958 return 0;959 960 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;961 if (ddr)962 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?963 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;964 else965 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?966 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;967 968 err = __mmc_select_powerclass(card, ext_csd_bits);969 if (err)970 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",971 mmc_hostname(host), 1 << bus_width, ddr);972 973 return err;974}975 976/*977 * Set the bus speed for the selected speed mode.978 */979static void mmc_set_bus_speed(struct mmc_card *card)980{981 unsigned int max_dtr = (unsigned int)-1;982 983 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&984 max_dtr > card->ext_csd.hs200_max_dtr)985 max_dtr = card->ext_csd.hs200_max_dtr;986 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)987 max_dtr = card->ext_csd.hs_max_dtr;988 else if (max_dtr > card->csd.max_dtr)989 max_dtr = card->csd.max_dtr;990 991 mmc_set_clock(card->host, max_dtr);992}993 994/*995 * Select the bus width amoung 4-bit and 8-bit(SDR).996 * If the bus width is changed successfully, return the selected width value.997 * Zero is returned instead of error value if the wide width is not supported.998 */999static int mmc_select_bus_width(struct mmc_card *card)1000{1001 static unsigned ext_csd_bits[] = {1002 EXT_CSD_BUS_WIDTH_8,1003 EXT_CSD_BUS_WIDTH_4,1004 EXT_CSD_BUS_WIDTH_1,1005 };1006 static unsigned bus_widths[] = {1007 MMC_BUS_WIDTH_8,1008 MMC_BUS_WIDTH_4,1009 MMC_BUS_WIDTH_1,1010 };1011 struct mmc_host *host = card->host;1012 unsigned idx, bus_width = 0;1013 int err = 0;1014 1015 if (!mmc_can_ext_csd(card) ||1016 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))1017 return 0;1018 1019 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;1020 1021 /*1022 * Unlike SD, MMC cards dont have a configuration register to notify1023 * supported bus width. So bus test command should be run to identify1024 * the supported bus width or compare the ext csd values of current1025 * bus width and ext csd values of 1 bit mode read earlier.1026 */1027 for (; idx < ARRAY_SIZE(bus_widths); idx++) {1028 /*1029 * Host is capable of 8bit transfer, then switch1030 * the device to work in 8bit transfer mode. If the1031 * mmc switch command returns error then switch to1032 * 4bit transfer mode. On success set the corresponding1033 * bus width on the host.1034 */1035 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1036 EXT_CSD_BUS_WIDTH,1037 ext_csd_bits[idx],1038 card->ext_csd.generic_cmd6_time);1039 if (err)1040 continue;1041 1042 bus_width = bus_widths[idx];1043 mmc_set_bus_width(host, bus_width);1044 1045 /*1046 * If controller can't handle bus width test,1047 * compare ext_csd previously read in 1 bit mode1048 * against ext_csd at new bus width1049 */1050 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))1051 err = mmc_compare_ext_csds(card, bus_width);1052 else1053 err = mmc_bus_test(card, bus_width);1054 1055 if (!err) {1056 err = bus_width;1057 break;1058 } else {1059 pr_warn("%s: switch to bus width %d failed\n",1060 mmc_hostname(host), 1 << bus_width);1061 }1062 }1063 1064 return err;1065}1066 1067/*1068 * Switch to the high-speed mode1069 */1070static int mmc_select_hs(struct mmc_card *card)1071{1072 int err;1073 1074 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1075 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,1076 card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,1077 true, true, MMC_CMD_RETRIES);1078 if (err)1079 pr_warn("%s: switch to high-speed failed, err:%d\n",1080 mmc_hostname(card->host), err);1081 1082 return err;1083}1084 1085/*1086 * Activate wide bus and DDR if supported.1087 */1088static int mmc_select_hs_ddr(struct mmc_card *card)1089{1090 struct mmc_host *host = card->host;1091 u32 bus_width, ext_csd_bits;1092 int err = 0;1093 1094 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))1095 return 0;1096 1097 bus_width = host->ios.bus_width;1098 if (bus_width == MMC_BUS_WIDTH_1)1099 return 0;1100 1101 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?1102 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;1103 1104 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1105 EXT_CSD_BUS_WIDTH,1106 ext_csd_bits,1107 card->ext_csd.generic_cmd6_time,1108 MMC_TIMING_MMC_DDR52,1109 true, true, MMC_CMD_RETRIES);1110 if (err) {1111 pr_err("%s: switch to bus width %d ddr failed\n",1112 mmc_hostname(host), 1 << bus_width);1113 return err;1114 }1115 1116 /*1117 * eMMC cards can support 3.3V to 1.2V i/o (vccq)1118 * signaling.1119 *1120 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.1121 *1122 * 1.8V vccq at 3.3V core voltage (vcc) is not required1123 * in the JEDEC spec for DDR.1124 *1125 * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all1126 * host controller can support this, like some of the SDHCI1127 * controller which connect to an eMMC device. Some of these1128 * host controller still needs to use 1.8v vccq for supporting1129 * DDR mode.1130 *1131 * So the sequence will be:1132 * if (host and device can both support 1.2v IO)1133 * use 1.2v IO;1134 * else if (host and device can both support 1.8v IO)1135 * use 1.8v IO;1136 * so if host and device can only support 3.3v IO, this is the1137 * last choice.1138 *1139 * WARNING: eMMC rules are NOT the same as SD DDR1140 */1141 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {1142 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);1143 if (!err)1144 return 0;1145 }1146 1147 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&1148 host->caps & MMC_CAP_1_8V_DDR)1149 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);1150 1151 /* make sure vccq is 3.3v after switching disaster */1152 if (err)1153 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);1154 1155 return err;1156}1157 1158static int mmc_select_hs400(struct mmc_card *card)1159{1160 struct mmc_host *host = card->host;1161 unsigned int max_dtr;1162 int err = 0;1163 u8 val;1164 1165 /*1166 * HS400 mode requires 8-bit bus width1167 */1168 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&1169 host->ios.bus_width == MMC_BUS_WIDTH_8))1170 return 0;1171 1172 /* Switch card to HS mode */1173 val = EXT_CSD_TIMING_HS;1174 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1175 EXT_CSD_HS_TIMING, val,1176 card->ext_csd.generic_cmd6_time, 0,1177 false, true, MMC_CMD_RETRIES);1178 if (err) {1179 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",1180 mmc_hostname(host), err);1181 return err;1182 }1183 1184 /* Prepare host to downgrade to HS timing */1185 if (host->ops->hs400_downgrade)1186 host->ops->hs400_downgrade(host);1187 1188 /* Set host controller to HS timing */1189 mmc_set_timing(host, MMC_TIMING_MMC_HS);1190 1191 /* Reduce frequency to HS frequency */1192 max_dtr = card->ext_csd.hs_max_dtr;1193 mmc_set_clock(host, max_dtr);1194 1195 err = mmc_switch_status(card, true);1196 if (err)1197 goto out_err;1198 1199 if (host->ops->hs400_prepare_ddr)1200 host->ops->hs400_prepare_ddr(host);1201 1202 /* Switch card to DDR */1203 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1204 EXT_CSD_BUS_WIDTH,1205 EXT_CSD_DDR_BUS_WIDTH_8,1206 card->ext_csd.generic_cmd6_time);1207 if (err) {1208 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",1209 mmc_hostname(host), err);1210 return err;1211 }1212 1213 /* Switch card to HS400 */1214 val = EXT_CSD_TIMING_HS400 |1215 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;1216 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1217 EXT_CSD_HS_TIMING, val,1218 card->ext_csd.generic_cmd6_time, 0,1219 false, true, MMC_CMD_RETRIES);1220 if (err) {1221 pr_err("%s: switch to hs400 failed, err:%d\n",1222 mmc_hostname(host), err);1223 return err;1224 }1225 1226 /* Set host controller to HS400 timing and frequency */1227 mmc_set_timing(host, MMC_TIMING_MMC_HS400);1228 mmc_set_bus_speed(card);1229 1230 if (host->ops->execute_hs400_tuning) {1231 mmc_retune_disable(host);1232 err = host->ops->execute_hs400_tuning(host, card);1233 mmc_retune_enable(host);1234 if (err)1235 goto out_err;1236 }1237 1238 if (host->ops->hs400_complete)1239 host->ops->hs400_complete(host);1240 1241 err = mmc_switch_status(card, true);1242 if (err)1243 goto out_err;1244 1245 return 0;1246 1247out_err:1248 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),1249 __func__, err);1250 return err;1251}1252 1253int mmc_hs200_to_hs400(struct mmc_card *card)1254{1255 return mmc_select_hs400(card);1256}1257 1258int mmc_hs400_to_hs200(struct mmc_card *card)1259{1260 struct mmc_host *host = card->host;1261 unsigned int max_dtr;1262 int err;1263 u8 val;1264 1265 /* Reduce frequency to HS */1266 max_dtr = card->ext_csd.hs_max_dtr;1267 mmc_set_clock(host, max_dtr);1268 1269 /* Switch HS400 to HS DDR */1270 val = EXT_CSD_TIMING_HS;1271 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,1272 val, card->ext_csd.generic_cmd6_time, 0,1273 false, true, MMC_CMD_RETRIES);1274 if (err)1275 goto out_err;1276 1277 if (host->ops->hs400_downgrade)1278 host->ops->hs400_downgrade(host);1279 1280 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);1281 1282 err = mmc_switch_status(card, true);1283 if (err)1284 goto out_err;1285 1286 /* Switch HS DDR to HS */1287 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,1288 EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,1289 0, false, true, MMC_CMD_RETRIES);1290 if (err)1291 goto out_err;1292 1293 mmc_set_timing(host, MMC_TIMING_MMC_HS);1294 1295 err = mmc_switch_status(card, true);1296 if (err)1297 goto out_err;1298 1299 /* Switch HS to HS200 */1300 val = EXT_CSD_TIMING_HS200 |1301 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;1302 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,1303 val, card->ext_csd.generic_cmd6_time, 0,1304 false, true, MMC_CMD_RETRIES);1305 if (err)1306 goto out_err;1307 1308 mmc_set_timing(host, MMC_TIMING_MMC_HS200);1309 1310 /*1311 * For HS200, CRC errors are not a reliable way to know the switch1312 * failed. If there really is a problem, we would expect tuning will1313 * fail and the result ends up the same.1314 */1315 err = mmc_switch_status(card, false);1316 if (err)1317 goto out_err;1318 1319 mmc_set_bus_speed(card);1320 1321 /* Prepare tuning for HS400 mode. */1322 if (host->ops->prepare_hs400_tuning)1323 host->ops->prepare_hs400_tuning(host, &host->ios);1324 1325 return 0;1326 1327out_err:1328 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),1329 __func__, err);1330 return err;1331}1332 1333static void mmc_select_driver_type(struct mmc_card *card)1334{1335 int card_drv_type, drive_strength, drv_type = 0;1336 int fixed_drv_type = card->host->fixed_drv_type;1337 1338 card_drv_type = card->ext_csd.raw_driver_strength |1339 mmc_driver_type_mask(0);1340 1341 if (fixed_drv_type >= 0)1342 drive_strength = card_drv_type & mmc_driver_type_mask(fixed_drv_type)1343 ? fixed_drv_type : 0;1344 else1345 drive_strength = mmc_select_drive_strength(card,1346 card->ext_csd.hs200_max_dtr,1347 card_drv_type, &drv_type);1348 1349 card->drive_strength = drive_strength;1350 1351 if (drv_type)1352 mmc_set_driver_type(card->host, drv_type);1353}1354 1355static int mmc_select_hs400es(struct mmc_card *card)1356{1357 struct mmc_host *host = card->host;1358 int err = -EINVAL;1359 u8 val;1360 1361 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)1362 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);1363 1364 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)1365 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);1366 1367 /* If fails try again during next card power cycle */1368 if (err)1369 goto out_err;1370 1371 err = mmc_select_bus_width(card);1372 if (err != MMC_BUS_WIDTH_8) {1373 pr_err("%s: switch to 8bit bus width failed, err:%d\n",1374 mmc_hostname(host), err);1375 err = err < 0 ? err : -ENOTSUPP;1376 goto out_err;1377 }1378 1379 /* Switch card to HS mode */1380 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1381 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,1382 card->ext_csd.generic_cmd6_time, 0,1383 false, true, MMC_CMD_RETRIES);1384 if (err) {1385 pr_err("%s: switch to hs for hs400es failed, err:%d\n",1386 mmc_hostname(host), err);1387 goto out_err;1388 }1389 1390 /*1391 * Bump to HS timing and frequency. Some cards don't handle1392 * SEND_STATUS reliably at the initial frequency.1393 */1394 mmc_set_timing(host, MMC_TIMING_MMC_HS);1395 mmc_set_bus_speed(card);1396 1397 err = mmc_switch_status(card, true);1398 if (err)1399 goto out_err;1400 1401 /* Switch card to DDR with strobe bit */1402 val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;1403 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1404 EXT_CSD_BUS_WIDTH,1405 val,1406 card->ext_csd.generic_cmd6_time);1407 if (err) {1408 pr_err("%s: switch to bus width for hs400es failed, err:%d\n",1409 mmc_hostname(host), err);1410 goto out_err;1411 }1412 1413 mmc_select_driver_type(card);1414 1415 /* Switch card to HS400 */1416 val = EXT_CSD_TIMING_HS400 |1417 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;1418 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1419 EXT_CSD_HS_TIMING, val,1420 card->ext_csd.generic_cmd6_time, 0,1421 false, true, MMC_CMD_RETRIES);1422 if (err) {1423 pr_err("%s: switch to hs400es failed, err:%d\n",1424 mmc_hostname(host), err);1425 goto out_err;1426 }1427 1428 /* Set host controller to HS400 timing and frequency */1429 mmc_set_timing(host, MMC_TIMING_MMC_HS400);1430 1431 /* Controller enable enhanced strobe function */1432 host->ios.enhanced_strobe = true;1433 if (host->ops->hs400_enhanced_strobe)1434 host->ops->hs400_enhanced_strobe(host, &host->ios);1435 1436 err = mmc_switch_status(card, true);1437 if (err)1438 goto out_err;1439 1440 return 0;1441 1442out_err:1443 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),1444 __func__, err);1445 return err;1446}1447 1448/*1449 * For device supporting HS200 mode, the following sequence1450 * should be done before executing the tuning process.1451 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)1452 * 2. switch to HS200 mode1453 * 3. set the clock to > 52Mhz and <=200MHz1454 */1455static int mmc_select_hs200(struct mmc_card *card)1456{1457 struct mmc_host *host = card->host;1458 unsigned int old_timing, old_signal_voltage, old_clock;1459 int err = -EINVAL;1460 u8 val;1461 1462 old_signal_voltage = host->ios.signal_voltage;1463 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)1464 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);1465 1466 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)1467 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);1468 1469 /* If fails try again during next card power cycle */1470 if (err)1471 return err;1472 1473 mmc_select_driver_type(card);1474 1475 /*1476 * Set the bus width(4 or 8) with host's support and1477 * switch to HS200 mode if bus width is set successfully.1478 */1479 err = mmc_select_bus_width(card);1480 if (err > 0) {1481 val = EXT_CSD_TIMING_HS200 |1482 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;1483 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1484 EXT_CSD_HS_TIMING, val,1485 card->ext_csd.generic_cmd6_time, 0,1486 false, true, MMC_CMD_RETRIES);1487 if (err)1488 goto err;1489 1490 /*1491 * Bump to HS timing and frequency. Some cards don't handle1492 * SEND_STATUS reliably at the initial frequency.1493 * NB: We can't move to full (HS200) speeds until after we've1494 * successfully switched over.1495 */1496 old_timing = host->ios.timing;1497 old_clock = host->ios.clock;1498 mmc_set_timing(host, MMC_TIMING_MMC_HS200);1499 mmc_set_clock(card->host, card->ext_csd.hs_max_dtr);1500 1501 /*1502 * For HS200, CRC errors are not a reliable way to know the1503 * switch failed. If there really is a problem, we would expect1504 * tuning will fail and the result ends up the same.1505 */1506 err = mmc_switch_status(card, false);1507 1508 /*1509 * mmc_select_timing() assumes timing has not changed if1510 * it is a switch error.1511 */1512 if (err == -EBADMSG) {1513 mmc_set_clock(host, old_clock);1514 mmc_set_timing(host, old_timing);1515 }1516 }1517err:1518 if (err) {1519 /* fall back to the old signal voltage, if fails report error */1520 if (mmc_set_signal_voltage(host, old_signal_voltage))1521 err = -EIO;1522 1523 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),1524 __func__, err);1525 }1526 return err;1527}1528 1529/*1530 * Activate High Speed, HS200 or HS400ES mode if supported.1531 */1532static int mmc_select_timing(struct mmc_card *card)1533{1534 int err = 0;1535 1536 if (!mmc_can_ext_csd(card))1537 goto bus_speed;1538 1539 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES) {1540 err = mmc_select_hs400es(card);1541 goto out;1542 }1543 1544 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200) {1545 err = mmc_select_hs200(card);1546 if (err == -EBADMSG)1547 card->mmc_avail_type &= ~EXT_CSD_CARD_TYPE_HS200;1548 else1549 goto out;1550 }1551 1552 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)1553 err = mmc_select_hs(card);1554 1555out:1556 if (err && err != -EBADMSG)1557 return err;1558 1559bus_speed:1560 /*1561 * Set the bus speed to the selected bus timing.1562 * If timing is not selected, backward compatible is the default.1563 */1564 mmc_set_bus_speed(card);1565 return 0;1566}1567 1568/*1569 * Execute tuning sequence to seek the proper bus operating1570 * conditions for HS200 and HS400, which sends CMD21 to the device.1571 */1572static int mmc_hs200_tuning(struct mmc_card *card)1573{1574 struct mmc_host *host = card->host;1575 1576 /*1577 * Timing should be adjusted to the HS400 target1578 * operation frequency for tuning process1579 */1580 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&1581 host->ios.bus_width == MMC_BUS_WIDTH_8)1582 if (host->ops->prepare_hs400_tuning)1583 host->ops->prepare_hs400_tuning(host, &host->ios);1584 1585 return mmc_execute_tuning(card);1586}1587 1588/*1589 * Handle the detection and initialisation of a card.1590 *1591 * In the case of a resume, "oldcard" will contain the card1592 * we're trying to reinitialise.1593 */1594static int mmc_init_card(struct mmc_host *host, u32 ocr,1595 struct mmc_card *oldcard)1596{1597 struct mmc_card *card;1598 int err;1599 u32 cid[4];1600 u32 rocr;1601 1602 WARN_ON(!host->claimed);1603 1604 /* Set correct bus mode for MMC before attempting init */1605 if (!mmc_host_is_spi(host))1606 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);1607 1608 /*1609 * Since we're changing the OCR value, we seem to1610 * need to tell some cards to go back to the idle1611 * state. We wait 1ms to give cards time to1612 * respond.1613 * mmc_go_idle is needed for eMMC that are asleep1614 */1615 mmc_go_idle(host);1616 1617 /* The extra bit indicates that we support high capacity */1618 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);1619 if (err)1620 goto err;1621 1622 /*1623 * For SPI, enable CRC as appropriate.1624 */1625 if (mmc_host_is_spi(host)) {1626 err = mmc_spi_set_crc(host, use_spi_crc);1627 if (err)1628 goto err;1629 }1630 1631 /*1632 * Fetch CID from card.1633 */1634 err = mmc_send_cid(host, cid);1635 if (err)1636 goto err;1637 1638 if (oldcard) {1639 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {1640 pr_debug("%s: Perhaps the card was replaced\n",1641 mmc_hostname(host));1642 err = -ENOENT;1643 goto err;1644 }1645 1646 card = oldcard;1647 } else {1648 /*1649 * Allocate card structure.1650 */1651 card = mmc_alloc_card(host, &mmc_type);1652 if (IS_ERR(card)) {1653 err = PTR_ERR(card);1654 goto err;1655 }1656 1657 card->ocr = ocr;1658 card->type = MMC_TYPE_MMC;1659 card->rca = 1;1660 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));1661 }1662 1663 /*1664 * Call the optional HC's init_card function to handle quirks.1665 */1666 if (host->ops->init_card)1667 host->ops->init_card(host, card);1668 1669 /*1670 * For native busses: set card RCA and quit open drain mode.1671 */1672 if (!mmc_host_is_spi(host)) {1673 err = mmc_set_relative_addr(card);1674 if (err)1675 goto free_card;1676 1677 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);1678 }1679 1680 if (!oldcard) {1681 /*1682 * Fetch CSD from card.1683 */1684 err = mmc_send_csd(card, card->raw_csd);1685 if (err)1686 goto free_card;1687 1688 err = mmc_decode_csd(card);1689 if (err)1690 goto free_card;1691 err = mmc_decode_cid(card);1692 if (err)1693 goto free_card;1694 }1695 1696 /*1697 * handling only for cards supporting DSR and hosts requesting1698 * DSR configuration1699 */1700 if (card->csd.dsr_imp && host->dsr_req)1701 mmc_set_dsr(host);1702 1703 /*1704 * Select card, as all following commands rely on that.1705 */1706 if (!mmc_host_is_spi(host)) {1707 err = mmc_select_card(card);1708 if (err)1709 goto free_card;1710 }1711 1712 if (!oldcard) {1713 /* Read extended CSD. */1714 err = mmc_read_ext_csd(card);1715 if (err)1716 goto free_card;1717 1718 /*1719 * If doing byte addressing, check if required to do sector1720 * addressing. Handle the case of <2GB cards needing sector1721 * addressing. See section 8.1 JEDEC Standard JED84-A441;1722 * ocr register has bit 30 set for sector addressing.1723 */1724 if (rocr & BIT(30))1725 mmc_card_set_blockaddr(card);1726 1727 /* Erase size depends on CSD and Extended CSD */1728 mmc_set_erase_size(card);1729 }1730 1731 /*1732 * Reselect the card type since host caps could have been changed when1733 * debugging even if the card is not new.1734 */1735 mmc_select_card_type(card);1736 1737 /* Enable ERASE_GRP_DEF. This bit is lost after a reset or power off. */1738 if (card->ext_csd.rev >= 3) {1739 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1740 EXT_CSD_ERASE_GROUP_DEF, 1,1741 card->ext_csd.generic_cmd6_time);1742 1743 if (err && err != -EBADMSG)1744 goto free_card;1745 1746 if (err) {1747 /*1748 * Just disable enhanced area off & sz1749 * will try to enable ERASE_GROUP_DEF1750 * during next time reinit1751 */1752 card->ext_csd.enhanced_area_offset = -EINVAL;1753 card->ext_csd.enhanced_area_size = -EINVAL;1754 } else {1755 card->ext_csd.erase_group_def = 1;1756 /*1757 * enable ERASE_GRP_DEF successfully.1758 * This will affect the erase size, so1759 * here need to reset erase size1760 */1761 mmc_set_erase_size(card);1762 }1763 }1764 mmc_set_wp_grp_size(card);1765 /*1766 * Ensure eMMC user default partition is enabled1767 */1768 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {1769 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;1770 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,1771 card->ext_csd.part_config,1772 card->ext_csd.part_time);1773 if (err && err != -EBADMSG)1774 goto free_card;1775 }1776 1777 /*1778 * Enable power_off_notification byte in the ext_csd register1779 */1780 if (card->ext_csd.rev >= 6) {1781 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1782 EXT_CSD_POWER_OFF_NOTIFICATION,1783 EXT_CSD_POWER_ON,1784 card->ext_csd.generic_cmd6_time);1785 if (err && err != -EBADMSG)1786 goto free_card;1787 1788 /*1789 * The err can be -EBADMSG or 0,1790 * so check for success and update the flag1791 */1792 if (!err)1793 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;1794 }1795 1796 /* set erase_arg */1797 if (mmc_can_discard(card))1798 card->erase_arg = MMC_DISCARD_ARG;1799 else if (mmc_can_trim(card))1800 card->erase_arg = MMC_TRIM_ARG;1801 else1802 card->erase_arg = MMC_ERASE_ARG;1803 1804 /*1805 * Select timing interface1806 */1807 err = mmc_select_timing(card);1808 if (err)1809 goto free_card;1810 1811 if (mmc_card_hs200(card)) {1812 host->doing_init_tune = 1;1813 1814 err = mmc_hs200_tuning(card);1815 if (!err)1816 err = mmc_select_hs400(card);1817 1818 host->doing_init_tune = 0;1819 1820 if (err)1821 goto free_card;1822 } else if (mmc_card_hs400es(card)) {1823 if (host->ops->execute_hs400_tuning) {1824 err = host->ops->execute_hs400_tuning(host, card);1825 if (err)1826 goto free_card;1827 }1828 } else {1829 /* Select the desired bus width optionally */1830 err = mmc_select_bus_width(card);1831 if (err > 0 && mmc_card_hs(card)) {1832 err = mmc_select_hs_ddr(card);1833 if (err)1834 goto free_card;1835 }1836 }1837 1838 /*1839 * Choose the power class with selected bus interface1840 */1841 mmc_select_powerclass(card);1842 1843 /*1844 * Enable HPI feature (if supported)1845 */1846 if (card->ext_csd.hpi) {1847 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1848 EXT_CSD_HPI_MGMT, 1,1849 card->ext_csd.generic_cmd6_time);1850 if (err && err != -EBADMSG)1851 goto free_card;1852 if (err) {1853 pr_warn("%s: Enabling HPI failed\n",1854 mmc_hostname(card->host));1855 card->ext_csd.hpi_en = 0;1856 } else {1857 card->ext_csd.hpi_en = 1;1858 }1859 }1860 1861 /*1862 * If cache size is higher than 0, this indicates the existence of cache1863 * and it can be turned on. Note that some eMMCs from Micron has been1864 * reported to need ~800 ms timeout, while enabling the cache after1865 * sudden power failure tests. Let's extend the timeout to a minimum of1866 * DEFAULT_CACHE_EN_TIMEOUT_MS and do it for all cards.1867 */1868 if (card->ext_csd.cache_size > 0) {1869 unsigned int timeout_ms = MIN_CACHE_EN_TIMEOUT_MS;1870 1871 timeout_ms = max(card->ext_csd.generic_cmd6_time, timeout_ms);1872 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,1873 EXT_CSD_CACHE_CTRL, 1, timeout_ms);1874 if (err && err != -EBADMSG)1875 goto free_card;1876 1877 /*1878 * Only if no error, cache is turned on successfully.1879 */1880 if (err) {1881 pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",1882 mmc_hostname(card->host), err);1883 card->ext_csd.cache_ctrl = 0;1884 } else {1885 card->ext_csd.cache_ctrl = 1;1886 }1887 }1888 1889 /*1890 * Enable Command Queue if supported. Note that Packed Commands cannot1891 * be used with Command Queue.1892 */1893 card->ext_csd.cmdq_en = false;1894 if (card->ext_csd.cmdq_support && host->caps2 & MMC_CAP2_CQE) {1895 err = mmc_cmdq_enable(card);1896 if (err && err != -EBADMSG)1897 goto free_card;1898 if (err) {1899 pr_warn("%s: Enabling CMDQ failed\n",1900 mmc_hostname(card->host));1901 card->ext_csd.cmdq_support = false;1902 card->ext_csd.cmdq_depth = 0;1903 }1904 }1905 /*1906 * In some cases (e.g. RPMB or mmc_test), the Command Queue must be1907 * disabled for a time, so a flag is needed to indicate to re-enable the1908 * Command Queue.1909 */1910 card->reenable_cmdq = card->ext_csd.cmdq_en;1911 1912 if (host->cqe_ops && !host->cqe_enabled) {1913 err = host->cqe_ops->cqe_enable(host, card);1914 if (!err) {1915 host->cqe_enabled = true;1916 1917 if (card->ext_csd.cmdq_en) {1918 pr_info("%s: Command Queue Engine enabled\n",1919 mmc_hostname(host));1920 } else {1921 host->hsq_enabled = true;1922 pr_info("%s: Host Software Queue enabled\n",1923 mmc_hostname(host));1924 }1925 }1926 }1927 1928 if (host->caps2 & MMC_CAP2_AVOID_3_3V &&1929 host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {1930 pr_err("%s: Host failed to negotiate down from 3.3V\n",1931 mmc_hostname(host));1932 err = -EINVAL;1933 goto free_card;1934 }1935 1936 if (!oldcard)1937 host->card = card;1938 1939 return 0;1940 1941free_card:1942 if (!oldcard)1943 mmc_remove_card(card);1944err:1945 return err;1946}1947 1948static int mmc_can_sleep(struct mmc_card *card)1949{1950 return card->ext_csd.rev >= 3;1951}1952 1953static int mmc_sleep_busy_cb(void *cb_data, bool *busy)1954{1955 struct mmc_host *host = cb_data;1956 1957 *busy = host->ops->card_busy(host);1958 return 0;1959}1960 1961static int mmc_sleep(struct mmc_host *host)1962{1963 struct mmc_command cmd = {};1964 struct mmc_card *card = host->card;1965 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);1966 bool use_r1b_resp;1967 int err;1968 1969 /* Re-tuning can't be done once the card is deselected */1970 mmc_retune_hold(host);1971 1972 err = mmc_deselect_cards(host);1973 if (err)1974 goto out_release;1975 1976 cmd.opcode = MMC_SLEEP_AWAKE;1977 cmd.arg = card->rca << 16;1978 cmd.arg |= 1 << 15;1979 use_r1b_resp = mmc_prepare_busy_cmd(host, &cmd, timeout_ms);1980 1981 err = mmc_wait_for_cmd(host, &cmd, 0);1982 if (err)1983 goto out_release;1984 1985 /*1986 * If the host does not wait while the card signals busy, then we can1987 * try to poll, but only if the host supports HW polling, as the1988 * SEND_STATUS cmd is not allowed. If we can't poll, then we simply need1989 * to wait the sleep/awake timeout.1990 */1991 if (host->caps & MMC_CAP_WAIT_WHILE_BUSY && use_r1b_resp)1992 goto out_release;1993 1994 if (!host->ops->card_busy) {1995 mmc_delay(timeout_ms);1996 goto out_release;1997 }1998 1999 err = __mmc_poll_for_busy(host, 0, timeout_ms, &mmc_sleep_busy_cb, host);2000 2001out_release:2002 mmc_retune_release(host);2003 return err;2004}2005 2006static int mmc_can_poweroff_notify(const struct mmc_card *card)2007{2008 return card &&2009 mmc_card_mmc(card) &&2010 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);2011}2012 2013static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)2014{2015 unsigned int timeout = card->ext_csd.generic_cmd6_time;2016 int err;2017 2018 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */2019 if (notify_type == EXT_CSD_POWER_OFF_LONG)2020 timeout = card->ext_csd.power_off_longtime;2021 2022 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,2023 EXT_CSD_POWER_OFF_NOTIFICATION,2024 notify_type, timeout, 0, false, false, MMC_CMD_RETRIES);2025 if (err)2026 pr_err("%s: Power Off Notification timed out, %u\n",2027 mmc_hostname(card->host), timeout);2028 2029 /* Disable the power off notification after the switch operation. */2030 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;2031 2032 return err;2033}2034 2035/*2036 * Host is being removed. Free up the current card.2037 */2038static void mmc_remove(struct mmc_host *host)2039{2040 mmc_remove_card(host->card);2041 host->card = NULL;2042}2043 2044/*2045 * Card detection - card is alive.2046 */2047static int mmc_alive(struct mmc_host *host)2048{2049 return mmc_send_status(host->card, NULL);2050}2051 2052/*2053 * Card detection callback from host.2054 */2055static void mmc_detect(struct mmc_host *host)2056{2057 int err;2058 2059 mmc_get_card(host->card, NULL);2060 2061 /*2062 * Just check if our card has been removed.2063 */2064 err = _mmc_detect_card_removed(host);2065 2066 mmc_put_card(host->card, NULL);2067 2068 if (err) {2069 mmc_remove(host);2070 2071 mmc_claim_host(host);2072 mmc_detach_bus(host);2073 mmc_power_off(host);2074 mmc_release_host(host);2075 }2076}2077 2078static bool _mmc_cache_enabled(struct mmc_host *host)2079{2080 return host->card->ext_csd.cache_size > 0 &&2081 host->card->ext_csd.cache_ctrl & 1;2082}2083 2084/*2085 * Flush the internal cache of the eMMC to non-volatile storage.2086 */2087static int _mmc_flush_cache(struct mmc_host *host)2088{2089 int err = 0;2090 2091 if (mmc_card_broken_cache_flush(host->card) && !host->card->written_flag)2092 return 0;2093 2094 if (_mmc_cache_enabled(host)) {2095 err = mmc_switch(host->card, EXT_CSD_CMD_SET_NORMAL,2096 EXT_CSD_FLUSH_CACHE, 1,2097 CACHE_FLUSH_TIMEOUT_MS);2098 if (err)2099 pr_err("%s: cache flush error %d\n", mmc_hostname(host), err);2100 else2101 host->card->written_flag = false;2102 }2103 2104 return err;2105}2106 2107static int _mmc_suspend(struct mmc_host *host, bool is_suspend)2108{2109 int err = 0;2110 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :2111 EXT_CSD_POWER_OFF_LONG;2112 2113 mmc_claim_host(host);2114 2115 if (mmc_card_suspended(host->card))2116 goto out;2117 2118 err = _mmc_flush_cache(host);2119 if (err)2120 goto out;2121 2122 if (mmc_can_poweroff_notify(host->card) &&2123 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend ||2124 (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND)))2125 err = mmc_poweroff_notify(host->card, notify_type);2126 else if (mmc_can_sleep(host->card))2127 err = mmc_sleep(host);2128 else if (!mmc_host_is_spi(host))2129 err = mmc_deselect_cards(host);2130 2131 if (!err) {2132 mmc_power_off(host);2133 mmc_card_set_suspended(host->card);2134 }2135out:2136 mmc_release_host(host);2137 return err;2138}2139 2140/*2141 * Suspend callback2142 */2143static int mmc_suspend(struct mmc_host *host)2144{2145 int err;2146 2147 err = _mmc_suspend(host, true);2148 if (!err) {2149 pm_runtime_disable(&host->card->dev);2150 pm_runtime_set_suspended(&host->card->dev);2151 }2152 2153 return err;2154}2155 2156/*2157 * This function tries to determine if the same card is still present2158 * and, if so, restore all state to it.2159 */2160static int _mmc_resume(struct mmc_host *host)2161{2162 int err = 0;2163 2164 mmc_claim_host(host);2165 2166 if (!mmc_card_suspended(host->card))2167 goto out;2168 2169 mmc_power_up(host, host->card->ocr);2170 err = mmc_init_card(host, host->card->ocr, host->card);2171 mmc_card_clr_suspended(host->card);2172 2173out:2174 mmc_release_host(host);2175 return err;2176}2177 2178/*2179 * Shutdown callback2180 */2181static int mmc_shutdown(struct mmc_host *host)2182{2183 int err = 0;2184 2185 /*2186 * In a specific case for poweroff notify, we need to resume the card2187 * before we can shutdown it properly.2188 */2189 if (mmc_can_poweroff_notify(host->card) &&2190 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))2191 err = _mmc_resume(host);2192 2193 if (!err)2194 err = _mmc_suspend(host, false);2195 2196 return err;2197}2198 2199/*2200 * Callback for resume.2201 */2202static int mmc_resume(struct mmc_host *host)2203{2204 pm_runtime_enable(&host->card->dev);2205 return 0;2206}2207 2208/*2209 * Callback for runtime_suspend.2210 */2211static int mmc_runtime_suspend(struct mmc_host *host)2212{2213 int err;2214 2215 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))2216 return 0;2217 2218 err = _mmc_suspend(host, true);2219 if (err)2220 pr_err("%s: error %d doing aggressive suspend\n",2221 mmc_hostname(host), err);2222 2223 return err;2224}2225 2226/*2227 * Callback for runtime_resume.2228 */2229static int mmc_runtime_resume(struct mmc_host *host)2230{2231 int err;2232 2233 err = _mmc_resume(host);2234 if (err && err != -ENOMEDIUM)2235 pr_err("%s: error %d doing runtime resume\n",2236 mmc_hostname(host), err);2237 2238 return 0;2239}2240 2241static int mmc_can_reset(struct mmc_card *card)2242{2243 u8 rst_n_function;2244 2245 rst_n_function = card->ext_csd.rst_n_function;2246 if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)2247 return 0;2248 return 1;2249}2250 2251static int _mmc_hw_reset(struct mmc_host *host)2252{2253 struct mmc_card *card = host->card;2254 2255 /*2256 * In the case of recovery, we can't expect flushing the cache to work2257 * always, but we have a go and ignore errors.2258 */2259 _mmc_flush_cache(host);2260 2261 if ((host->caps & MMC_CAP_HW_RESET) && host->ops->card_hw_reset &&2262 mmc_can_reset(card)) {2263 /* If the card accept RST_n signal, send it. */2264 mmc_set_clock(host, host->f_init);2265 host->ops->card_hw_reset(host);2266 /* Set initial state and call mmc_set_ios */2267 mmc_set_initial_state(host);2268 } else {2269 /* Do a brute force power cycle */2270 mmc_power_cycle(host, card->ocr);2271 mmc_pwrseq_reset(host);2272 }2273 return mmc_init_card(host, card->ocr, card);2274}2275 2276static const struct mmc_bus_ops mmc_ops = {2277 .remove = mmc_remove,2278 .detect = mmc_detect,2279 .suspend = mmc_suspend,2280 .resume = mmc_resume,2281 .runtime_suspend = mmc_runtime_suspend,2282 .runtime_resume = mmc_runtime_resume,2283 .alive = mmc_alive,2284 .shutdown = mmc_shutdown,2285 .hw_reset = _mmc_hw_reset,2286 .cache_enabled = _mmc_cache_enabled,2287 .flush_cache = _mmc_flush_cache,2288};2289 2290/*2291 * Starting point for MMC card init.2292 */2293int mmc_attach_mmc(struct mmc_host *host)2294{2295 int err;2296 u32 ocr, rocr;2297 2298 WARN_ON(!host->claimed);2299 2300 /* Set correct bus mode for MMC before attempting attach */2301 if (!mmc_host_is_spi(host))2302 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);2303 2304 err = mmc_send_op_cond(host, 0, &ocr);2305 if (err)2306 return err;2307 2308 mmc_attach_bus(host, &mmc_ops);2309 if (host->ocr_avail_mmc)2310 host->ocr_avail = host->ocr_avail_mmc;2311 2312 /*2313 * We need to get OCR a different way for SPI.2314 */2315 if (mmc_host_is_spi(host)) {2316 err = mmc_spi_read_ocr(host, 1, &ocr);2317 if (err)2318 goto err;2319 }2320 2321 rocr = mmc_select_voltage(host, ocr);2322 2323 /*2324 * Can we support the voltage of the card?2325 */2326 if (!rocr) {2327 err = -EINVAL;2328 goto err;2329 }2330 2331 /*2332 * Detect and init the card.2333 */2334 err = mmc_init_card(host, rocr, NULL);2335 if (err)2336 goto err;2337 2338 mmc_release_host(host);2339 err = mmc_add_card(host->card);2340 if (err)2341 goto remove_card;2342 2343 mmc_claim_host(host);2344 return 0;2345 2346remove_card:2347 mmc_remove_card(host->card);2348 mmc_claim_host(host);2349 host->card = NULL;2350err:2351 mmc_detach_bus(host);2352 2353 pr_err("%s: error %d whilst initialising MMC card\n",2354 mmc_hostname(host), err);2355 2356 return err;2357}2358