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