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 out: 622 return err; 623 } 624 625 static int mmc_read_ext_csd(struct mmc_card *card) 626 { 627 u8 *ext_csd; 628 int err; 629 630 if (!mmc_can_ext_csd(card)) 631 return 0; 632 633 err = mmc_get_ext_csd(card, &ext_csd); 634 if (err) { 635 /* If the host or the card can't do the switch, 636 * fail more gracefully. */ 637 if ((err != -EINVAL) 638 && (err != -ENOSYS) 639 && (err != -EFAULT)) 640 return err; 641 642 /* 643 * High capacity cards should have this "magic" size 644 * stored in their CSD. 645 */ 646 if (card->csd.capacity == (4096 * 512)) { 647 pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n", 648 mmc_hostname(card->host)); 649 } else { 650 pr_warn("%s: unable to read EXT_CSD, performance might suffer\n", 651 mmc_hostname(card->host)); 652 err = 0; 653 } 654 655 return err; 656 } 657 658 err = mmc_decode_ext_csd(card, ext_csd); 659 kfree(ext_csd); 660 return err; 661 } 662 663 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width) 664 { 665 u8 *bw_ext_csd; 666 int err; 667 668 if (bus_width == MMC_BUS_WIDTH_1) 669 return 0; 670 671 err = mmc_get_ext_csd(card, &bw_ext_csd); 672 if (err) 673 return err; 674 675 /* only compare read only fields */ 676 err = !((card->ext_csd.raw_partition_support == 677 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) && 678 (card->ext_csd.raw_erased_mem_count == 679 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) && 680 (card->ext_csd.rev == 681 bw_ext_csd[EXT_CSD_REV]) && 682 (card->ext_csd.raw_ext_csd_structure == 683 bw_ext_csd[EXT_CSD_STRUCTURE]) && 684 (card->ext_csd.raw_card_type == 685 bw_ext_csd[EXT_CSD_CARD_TYPE]) && 686 (card->ext_csd.raw_s_a_timeout == 687 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) && 688 (card->ext_csd.raw_hc_erase_gap_size == 689 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) && 690 (card->ext_csd.raw_erase_timeout_mult == 691 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) && 692 (card->ext_csd.raw_hc_erase_grp_size == 693 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) && 694 (card->ext_csd.raw_sec_trim_mult == 695 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) && 696 (card->ext_csd.raw_sec_erase_mult == 697 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) && 698 (card->ext_csd.raw_sec_feature_support == 699 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) && 700 (card->ext_csd.raw_trim_mult == 701 bw_ext_csd[EXT_CSD_TRIM_MULT]) && 702 (card->ext_csd.raw_sectors[0] == 703 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) && 704 (card->ext_csd.raw_sectors[1] == 705 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) && 706 (card->ext_csd.raw_sectors[2] == 707 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) && 708 (card->ext_csd.raw_sectors[3] == 709 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) && 710 (card->ext_csd.raw_pwr_cl_52_195 == 711 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) && 712 (card->ext_csd.raw_pwr_cl_26_195 == 713 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) && 714 (card->ext_csd.raw_pwr_cl_52_360 == 715 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) && 716 (card->ext_csd.raw_pwr_cl_26_360 == 717 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) && 718 (card->ext_csd.raw_pwr_cl_200_195 == 719 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) && 720 (card->ext_csd.raw_pwr_cl_200_360 == 721 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) && 722 (card->ext_csd.raw_pwr_cl_ddr_52_195 == 723 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) && 724 (card->ext_csd.raw_pwr_cl_ddr_52_360 == 725 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) && 726 (card->ext_csd.raw_pwr_cl_ddr_200_360 == 727 bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360])); 728 729 if (err) 730 err = -EINVAL; 731 732 kfree(bw_ext_csd); 733 return err; 734 } 735 736 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], 737 card->raw_cid[2], card->raw_cid[3]); 738 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], 739 card->raw_csd[2], card->raw_csd[3]); 740 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); 741 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); 742 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); 743 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable); 744 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); 745 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid); 746 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name); 747 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid); 748 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv); 749 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial); 750 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n", 751 card->ext_csd.enhanced_area_offset); 752 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size); 753 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult); 754 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors); 755 MMC_DEV_ATTR(ocr, "%08x\n", card->ocr); 756 757 static ssize_t mmc_fwrev_show(struct device *dev, 758 struct device_attribute *attr, 759 char *buf) 760 { 761 struct mmc_card *card = mmc_dev_to_card(dev); 762 763 if (card->ext_csd.rev < 7) { 764 return sprintf(buf, "0x%x\n", card->cid.fwrev); 765 } else { 766 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN, 767 card->ext_csd.fwrev); 768 } 769 } 770 771 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL); 772 773 static ssize_t mmc_dsr_show(struct device *dev, 774 struct device_attribute *attr, 775 char *buf) 776 { 777 struct mmc_card *card = mmc_dev_to_card(dev); 778 struct mmc_host *host = card->host; 779 780 if (card->csd.dsr_imp && host->dsr_req) 781 return sprintf(buf, "0x%x\n", host->dsr); 782 else 783 /* return default DSR value */ 784 return sprintf(buf, "0x%x\n", 0x404); 785 } 786 787 static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL); 788 789 static struct attribute *mmc_std_attrs[] = { 790 &dev_attr_cid.attr, 791 &dev_attr_csd.attr, 792 &dev_attr_date.attr, 793 &dev_attr_erase_size.attr, 794 &dev_attr_preferred_erase_size.attr, 795 &dev_attr_fwrev.attr, 796 &dev_attr_ffu_capable.attr, 797 &dev_attr_hwrev.attr, 798 &dev_attr_manfid.attr, 799 &dev_attr_name.attr, 800 &dev_attr_oemid.attr, 801 &dev_attr_prv.attr, 802 &dev_attr_serial.attr, 803 &dev_attr_enhanced_area_offset.attr, 804 &dev_attr_enhanced_area_size.attr, 805 &dev_attr_raw_rpmb_size_mult.attr, 806 &dev_attr_rel_sectors.attr, 807 &dev_attr_ocr.attr, 808 &dev_attr_dsr.attr, 809 NULL, 810 }; 811 ATTRIBUTE_GROUPS(mmc_std); 812 813 static struct device_type mmc_type = { 814 .groups = mmc_std_groups, 815 }; 816 817 /* 818 * Select the PowerClass for the current bus width 819 * If power class is defined for 4/8 bit bus in the 820 * extended CSD register, select it by executing the 821 * mmc_switch command. 822 */ 823 static int __mmc_select_powerclass(struct mmc_card *card, 824 unsigned int bus_width) 825 { 826 struct mmc_host *host = card->host; 827 struct mmc_ext_csd *ext_csd = &card->ext_csd; 828 unsigned int pwrclass_val = 0; 829 int err = 0; 830 831 switch (1 << host->ios.vdd) { 832 case MMC_VDD_165_195: 833 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR) 834 pwrclass_val = ext_csd->raw_pwr_cl_26_195; 835 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR) 836 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 837 ext_csd->raw_pwr_cl_52_195 : 838 ext_csd->raw_pwr_cl_ddr_52_195; 839 else if (host->ios.clock <= MMC_HS200_MAX_DTR) 840 pwrclass_val = ext_csd->raw_pwr_cl_200_195; 841 break; 842 case MMC_VDD_27_28: 843 case MMC_VDD_28_29: 844 case MMC_VDD_29_30: 845 case MMC_VDD_30_31: 846 case MMC_VDD_31_32: 847 case MMC_VDD_32_33: 848 case MMC_VDD_33_34: 849 case MMC_VDD_34_35: 850 case MMC_VDD_35_36: 851 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR) 852 pwrclass_val = ext_csd->raw_pwr_cl_26_360; 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_360 : 856 ext_csd->raw_pwr_cl_ddr_52_360; 857 else if (host->ios.clock <= MMC_HS200_MAX_DTR) 858 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ? 859 ext_csd->raw_pwr_cl_ddr_200_360 : 860 ext_csd->raw_pwr_cl_200_360; 861 break; 862 default: 863 pr_warn("%s: Voltage range not supported for power class\n", 864 mmc_hostname(host)); 865 return -EINVAL; 866 } 867 868 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8)) 869 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >> 870 EXT_CSD_PWR_CL_8BIT_SHIFT; 871 else 872 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >> 873 EXT_CSD_PWR_CL_4BIT_SHIFT; 874 875 /* If the power class is different from the default value */ 876 if (pwrclass_val > 0) { 877 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 878 EXT_CSD_POWER_CLASS, 879 pwrclass_val, 880 card->ext_csd.generic_cmd6_time); 881 } 882 883 return err; 884 } 885 886 static int mmc_select_powerclass(struct mmc_card *card) 887 { 888 struct mmc_host *host = card->host; 889 u32 bus_width, ext_csd_bits; 890 int err, ddr; 891 892 /* Power class selection is supported for versions >= 4.0 */ 893 if (!mmc_can_ext_csd(card)) 894 return 0; 895 896 bus_width = host->ios.bus_width; 897 /* Power class values are defined only for 4/8 bit bus */ 898 if (bus_width == MMC_BUS_WIDTH_1) 899 return 0; 900 901 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52; 902 if (ddr) 903 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 904 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4; 905 else 906 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 907 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4; 908 909 err = __mmc_select_powerclass(card, ext_csd_bits); 910 if (err) 911 pr_warn("%s: power class selection to bus width %d ddr %d failed\n", 912 mmc_hostname(host), 1 << bus_width, ddr); 913 914 return err; 915 } 916 917 /* 918 * Set the bus speed for the selected speed mode. 919 */ 920 static void mmc_set_bus_speed(struct mmc_card *card) 921 { 922 unsigned int max_dtr = (unsigned int)-1; 923 924 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) && 925 max_dtr > card->ext_csd.hs200_max_dtr) 926 max_dtr = card->ext_csd.hs200_max_dtr; 927 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr) 928 max_dtr = card->ext_csd.hs_max_dtr; 929 else if (max_dtr > card->csd.max_dtr) 930 max_dtr = card->csd.max_dtr; 931 932 mmc_set_clock(card->host, max_dtr); 933 } 934 935 /* 936 * Select the bus width amoung 4-bit and 8-bit(SDR). 937 * If the bus width is changed successfully, return the selected width value. 938 * Zero is returned instead of error value if the wide width is not supported. 939 */ 940 static int mmc_select_bus_width(struct mmc_card *card) 941 { 942 static unsigned ext_csd_bits[] = { 943 EXT_CSD_BUS_WIDTH_8, 944 EXT_CSD_BUS_WIDTH_4, 945 }; 946 static unsigned bus_widths[] = { 947 MMC_BUS_WIDTH_8, 948 MMC_BUS_WIDTH_4, 949 }; 950 struct mmc_host *host = card->host; 951 unsigned idx, bus_width = 0; 952 int err = 0; 953 954 if (!mmc_can_ext_csd(card) || 955 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) 956 return 0; 957 958 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1; 959 960 /* 961 * Unlike SD, MMC cards dont have a configuration register to notify 962 * supported bus width. So bus test command should be run to identify 963 * the supported bus width or compare the ext csd values of current 964 * bus width and ext csd values of 1 bit mode read earlier. 965 */ 966 for (; idx < ARRAY_SIZE(bus_widths); idx++) { 967 /* 968 * Host is capable of 8bit transfer, then switch 969 * the device to work in 8bit transfer mode. If the 970 * mmc switch command returns error then switch to 971 * 4bit transfer mode. On success set the corresponding 972 * bus width on the host. 973 */ 974 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 975 EXT_CSD_BUS_WIDTH, 976 ext_csd_bits[idx], 977 card->ext_csd.generic_cmd6_time); 978 if (err) 979 continue; 980 981 bus_width = bus_widths[idx]; 982 mmc_set_bus_width(host, bus_width); 983 984 /* 985 * If controller can't handle bus width test, 986 * compare ext_csd previously read in 1 bit mode 987 * against ext_csd at new bus width 988 */ 989 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) 990 err = mmc_compare_ext_csds(card, bus_width); 991 else 992 err = mmc_bus_test(card, bus_width); 993 994 if (!err) { 995 err = bus_width; 996 break; 997 } else { 998 pr_warn("%s: switch to bus width %d failed\n", 999 mmc_hostname(host), 1 << bus_width); 1000 } 1001 } 1002 1003 return err; 1004 } 1005 1006 /* Caller must hold re-tuning */ 1007 static int mmc_switch_status(struct mmc_card *card) 1008 { 1009 u32 status; 1010 int err; 1011 1012 err = mmc_send_status(card, &status); 1013 if (err) 1014 return err; 1015 1016 return mmc_switch_status_error(card->host, status); 1017 } 1018 1019 /* 1020 * Switch to the high-speed mode 1021 */ 1022 static int mmc_select_hs(struct mmc_card *card) 1023 { 1024 int err; 1025 1026 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1027 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS, 1028 card->ext_csd.generic_cmd6_time, 1029 true, false, true); 1030 if (!err) { 1031 mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 1032 err = mmc_switch_status(card); 1033 } 1034 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 if (err) { 1066 pr_err("%s: switch to bus width %d ddr failed\n", 1067 mmc_hostname(host), 1 << bus_width); 1068 return err; 1069 } 1070 1071 /* 1072 * eMMC cards can support 3.3V to 1.2V i/o (vccq) 1073 * signaling. 1074 * 1075 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq. 1076 * 1077 * 1.8V vccq at 3.3V core voltage (vcc) is not required 1078 * in the JEDEC spec for DDR. 1079 * 1080 * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all 1081 * host controller can support this, like some of the SDHCI 1082 * controller which connect to an eMMC device. Some of these 1083 * host controller still needs to use 1.8v vccq for supporting 1084 * DDR mode. 1085 * 1086 * So the sequence will be: 1087 * if (host and device can both support 1.2v IO) 1088 * use 1.2v IO; 1089 * else if (host and device can both support 1.8v IO) 1090 * use 1.8v IO; 1091 * so if host and device can only support 3.3v IO, this is the 1092 * last choice. 1093 * 1094 * WARNING: eMMC rules are NOT the same as SD DDR 1095 */ 1096 err = -EINVAL; 1097 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) 1098 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 1099 1100 if (err && (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V)) 1101 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 1102 1103 /* make sure vccq is 3.3v after switching disaster */ 1104 if (err) 1105 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330); 1106 1107 if (!err) 1108 mmc_set_timing(host, MMC_TIMING_MMC_DDR52); 1109 1110 return err; 1111 } 1112 1113 static int mmc_select_hs400(struct mmc_card *card) 1114 { 1115 struct mmc_host *host = card->host; 1116 unsigned int max_dtr; 1117 int err = 0; 1118 u8 val; 1119 1120 /* 1121 * HS400 mode requires 8-bit bus width 1122 */ 1123 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 && 1124 host->ios.bus_width == MMC_BUS_WIDTH_8)) 1125 return 0; 1126 1127 /* Switch card to HS mode */ 1128 val = EXT_CSD_TIMING_HS; 1129 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1130 EXT_CSD_HS_TIMING, val, 1131 card->ext_csd.generic_cmd6_time, 1132 true, false, true); 1133 if (err) { 1134 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n", 1135 mmc_hostname(host), err); 1136 return err; 1137 } 1138 1139 /* Set host controller to HS timing */ 1140 mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 1141 1142 /* Reduce frequency to HS frequency */ 1143 max_dtr = card->ext_csd.hs_max_dtr; 1144 mmc_set_clock(host, max_dtr); 1145 1146 err = mmc_switch_status(card); 1147 if (err) 1148 goto out_err; 1149 1150 /* Switch card to DDR */ 1151 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1152 EXT_CSD_BUS_WIDTH, 1153 EXT_CSD_DDR_BUS_WIDTH_8, 1154 card->ext_csd.generic_cmd6_time); 1155 if (err) { 1156 pr_err("%s: switch to bus width for hs400 failed, err:%d\n", 1157 mmc_hostname(host), err); 1158 return err; 1159 } 1160 1161 /* Switch card to HS400 */ 1162 val = EXT_CSD_TIMING_HS400 | 1163 card->drive_strength << EXT_CSD_DRV_STR_SHIFT; 1164 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1165 EXT_CSD_HS_TIMING, val, 1166 card->ext_csd.generic_cmd6_time, 1167 true, false, true); 1168 if (err) { 1169 pr_err("%s: switch to hs400 failed, err:%d\n", 1170 mmc_hostname(host), err); 1171 return err; 1172 } 1173 1174 /* Set host controller to HS400 timing and frequency */ 1175 mmc_set_timing(host, MMC_TIMING_MMC_HS400); 1176 mmc_set_bus_speed(card); 1177 1178 err = mmc_switch_status(card); 1179 if (err) 1180 goto out_err; 1181 1182 return 0; 1183 1184 out_err: 1185 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host), 1186 __func__, err); 1187 return err; 1188 } 1189 1190 int mmc_hs200_to_hs400(struct mmc_card *card) 1191 { 1192 return mmc_select_hs400(card); 1193 } 1194 1195 int mmc_hs400_to_hs200(struct mmc_card *card) 1196 { 1197 struct mmc_host *host = card->host; 1198 unsigned int max_dtr; 1199 int err; 1200 u8 val; 1201 1202 /* Reduce frequency to HS */ 1203 max_dtr = card->ext_csd.hs_max_dtr; 1204 mmc_set_clock(host, max_dtr); 1205 1206 /* Switch HS400 to HS DDR */ 1207 val = EXT_CSD_TIMING_HS; 1208 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1209 val, card->ext_csd.generic_cmd6_time, 1210 true, false, true); 1211 if (err) 1212 goto out_err; 1213 1214 mmc_set_timing(host, MMC_TIMING_MMC_DDR52); 1215 1216 err = mmc_switch_status(card); 1217 if (err) 1218 goto out_err; 1219 1220 /* Switch HS DDR to HS */ 1221 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, 1222 EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time, 1223 true, false, true); 1224 if (err) 1225 goto out_err; 1226 1227 mmc_set_timing(host, MMC_TIMING_MMC_HS); 1228 1229 err = mmc_switch_status(card); 1230 if (err) 1231 goto out_err; 1232 1233 /* Switch HS to HS200 */ 1234 val = EXT_CSD_TIMING_HS200 | 1235 card->drive_strength << EXT_CSD_DRV_STR_SHIFT; 1236 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1237 val, card->ext_csd.generic_cmd6_time, 1238 true, false, true); 1239 if (err) 1240 goto out_err; 1241 1242 mmc_set_timing(host, MMC_TIMING_MMC_HS200); 1243 1244 err = mmc_switch_status(card); 1245 if (err) 1246 goto out_err; 1247 1248 mmc_set_bus_speed(card); 1249 1250 return 0; 1251 1252 out_err: 1253 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host), 1254 __func__, err); 1255 return err; 1256 } 1257 1258 static int mmc_select_hs400es(struct mmc_card *card) 1259 { 1260 struct mmc_host *host = card->host; 1261 int err = 0; 1262 u8 val; 1263 1264 if (!(host->caps & MMC_CAP_8_BIT_DATA)) { 1265 err = -ENOTSUPP; 1266 goto out_err; 1267 } 1268 1269 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V) 1270 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 1271 1272 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V) 1273 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 1274 1275 /* If fails try again during next card power cycle */ 1276 if (err) 1277 goto out_err; 1278 1279 err = mmc_select_bus_width(card); 1280 if (err < 0) 1281 goto out_err; 1282 1283 /* Switch card to HS mode */ 1284 err = mmc_select_hs(card); 1285 if (err) 1286 goto out_err; 1287 1288 mmc_set_clock(host, card->ext_csd.hs_max_dtr); 1289 1290 err = mmc_switch_status(card); 1291 if (err) 1292 goto out_err; 1293 1294 /* Switch card to DDR with strobe bit */ 1295 val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE; 1296 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1297 EXT_CSD_BUS_WIDTH, 1298 val, 1299 card->ext_csd.generic_cmd6_time); 1300 if (err) { 1301 pr_err("%s: switch to bus width for hs400es failed, err:%d\n", 1302 mmc_hostname(host), err); 1303 goto out_err; 1304 } 1305 1306 /* Switch card to HS400 */ 1307 val = EXT_CSD_TIMING_HS400 | 1308 card->drive_strength << EXT_CSD_DRV_STR_SHIFT; 1309 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1310 EXT_CSD_HS_TIMING, val, 1311 card->ext_csd.generic_cmd6_time, 1312 true, false, true); 1313 if (err) { 1314 pr_err("%s: switch to hs400es failed, err:%d\n", 1315 mmc_hostname(host), err); 1316 goto out_err; 1317 } 1318 1319 /* Set host controller to HS400 timing and frequency */ 1320 mmc_set_timing(host, MMC_TIMING_MMC_HS400); 1321 1322 /* Controller enable enhanced strobe function */ 1323 host->ios.enhanced_strobe = true; 1324 if (host->ops->hs400_enhanced_strobe) 1325 host->ops->hs400_enhanced_strobe(host, &host->ios); 1326 1327 err = mmc_switch_status(card); 1328 if (err) 1329 goto out_err; 1330 1331 return 0; 1332 1333 out_err: 1334 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host), 1335 __func__, err); 1336 return err; 1337 } 1338 1339 static void mmc_select_driver_type(struct mmc_card *card) 1340 { 1341 int card_drv_type, drive_strength, drv_type; 1342 1343 card_drv_type = card->ext_csd.raw_driver_strength | 1344 mmc_driver_type_mask(0); 1345 1346 drive_strength = mmc_select_drive_strength(card, 1347 card->ext_csd.hs200_max_dtr, 1348 card_drv_type, &drv_type); 1349 1350 card->drive_strength = drive_strength; 1351 1352 if (drv_type) 1353 mmc_set_driver_type(card->host, drv_type); 1354 } 1355 1356 /* 1357 * For device supporting HS200 mode, the following sequence 1358 * should be done before executing the tuning process. 1359 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported) 1360 * 2. switch to HS200 mode 1361 * 3. set the clock to > 52Mhz and <=200MHz 1362 */ 1363 static int mmc_select_hs200(struct mmc_card *card) 1364 { 1365 struct mmc_host *host = card->host; 1366 unsigned int old_timing, old_signal_voltage; 1367 int err = -EINVAL; 1368 u8 val; 1369 1370 old_signal_voltage = host->ios.signal_voltage; 1371 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V) 1372 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 1373 1374 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V) 1375 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 1376 1377 /* If fails try again during next card power cycle */ 1378 if (err) 1379 return err; 1380 1381 mmc_select_driver_type(card); 1382 1383 /* 1384 * Set the bus width(4 or 8) with host's support and 1385 * switch to HS200 mode if bus width is set successfully. 1386 */ 1387 err = mmc_select_bus_width(card); 1388 if (err > 0) { 1389 val = EXT_CSD_TIMING_HS200 | 1390 card->drive_strength << EXT_CSD_DRV_STR_SHIFT; 1391 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1392 EXT_CSD_HS_TIMING, val, 1393 card->ext_csd.generic_cmd6_time, 1394 true, false, true); 1395 if (err) 1396 goto err; 1397 old_timing = host->ios.timing; 1398 mmc_set_timing(host, MMC_TIMING_MMC_HS200); 1399 1400 err = mmc_switch_status(card); 1401 /* 1402 * mmc_select_timing() assumes timing has not changed if 1403 * it is a switch error. 1404 */ 1405 if (err == -EBADMSG) 1406 mmc_set_timing(host, old_timing); 1407 } 1408 err: 1409 if (err) { 1410 /* fall back to the old signal voltage, if fails report error */ 1411 if (__mmc_set_signal_voltage(host, old_signal_voltage)) 1412 err = -EIO; 1413 1414 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host), 1415 __func__, err); 1416 } 1417 return err; 1418 } 1419 1420 /* 1421 * Activate High Speed, HS200 or HS400ES mode if supported. 1422 */ 1423 static int mmc_select_timing(struct mmc_card *card) 1424 { 1425 int err = 0; 1426 1427 if (!mmc_can_ext_csd(card)) 1428 goto bus_speed; 1429 1430 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES) 1431 err = mmc_select_hs400es(card); 1432 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200) 1433 err = mmc_select_hs200(card); 1434 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS) 1435 err = mmc_select_hs(card); 1436 1437 if (err && err != -EBADMSG) 1438 return err; 1439 1440 bus_speed: 1441 /* 1442 * Set the bus speed to the selected bus timing. 1443 * If timing is not selected, backward compatible is the default. 1444 */ 1445 mmc_set_bus_speed(card); 1446 return 0; 1447 } 1448 1449 /* 1450 * Execute tuning sequence to seek the proper bus operating 1451 * conditions for HS200 and HS400, which sends CMD21 to the device. 1452 */ 1453 static int mmc_hs200_tuning(struct mmc_card *card) 1454 { 1455 struct mmc_host *host = card->host; 1456 1457 /* 1458 * Timing should be adjusted to the HS400 target 1459 * operation frequency for tuning process 1460 */ 1461 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 && 1462 host->ios.bus_width == MMC_BUS_WIDTH_8) 1463 if (host->ops->prepare_hs400_tuning) 1464 host->ops->prepare_hs400_tuning(host, &host->ios); 1465 1466 return mmc_execute_tuning(card); 1467 } 1468 1469 /* 1470 * Handle the detection and initialisation of a card. 1471 * 1472 * In the case of a resume, "oldcard" will contain the card 1473 * we're trying to reinitialise. 1474 */ 1475 static int mmc_init_card(struct mmc_host *host, u32 ocr, 1476 struct mmc_card *oldcard) 1477 { 1478 struct mmc_card *card; 1479 int err; 1480 u32 cid[4]; 1481 u32 rocr; 1482 1483 BUG_ON(!host); 1484 WARN_ON(!host->claimed); 1485 1486 /* Set correct bus mode for MMC before attempting init */ 1487 if (!mmc_host_is_spi(host)) 1488 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 1489 1490 /* 1491 * Since we're changing the OCR value, we seem to 1492 * need to tell some cards to go back to the idle 1493 * state. We wait 1ms to give cards time to 1494 * respond. 1495 * mmc_go_idle is needed for eMMC that are asleep 1496 */ 1497 mmc_go_idle(host); 1498 1499 /* The extra bit indicates that we support high capacity */ 1500 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr); 1501 if (err) 1502 goto err; 1503 1504 /* 1505 * For SPI, enable CRC as appropriate. 1506 */ 1507 if (mmc_host_is_spi(host)) { 1508 err = mmc_spi_set_crc(host, use_spi_crc); 1509 if (err) 1510 goto err; 1511 } 1512 1513 /* 1514 * Fetch CID from card. 1515 */ 1516 if (mmc_host_is_spi(host)) 1517 err = mmc_send_cid(host, cid); 1518 else 1519 err = mmc_all_send_cid(host, cid); 1520 if (err) 1521 goto err; 1522 1523 if (oldcard) { 1524 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) { 1525 err = -ENOENT; 1526 goto err; 1527 } 1528 1529 card = oldcard; 1530 } else { 1531 /* 1532 * Allocate card structure. 1533 */ 1534 card = mmc_alloc_card(host, &mmc_type); 1535 if (IS_ERR(card)) { 1536 err = PTR_ERR(card); 1537 goto err; 1538 } 1539 1540 card->ocr = ocr; 1541 card->type = MMC_TYPE_MMC; 1542 card->rca = 1; 1543 memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); 1544 } 1545 1546 /* 1547 * Call the optional HC's init_card function to handle quirks. 1548 */ 1549 if (host->ops->init_card) 1550 host->ops->init_card(host, card); 1551 1552 /* 1553 * For native busses: set card RCA and quit open drain mode. 1554 */ 1555 if (!mmc_host_is_spi(host)) { 1556 err = mmc_set_relative_addr(card); 1557 if (err) 1558 goto free_card; 1559 1560 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 1561 } 1562 1563 if (!oldcard) { 1564 /* 1565 * Fetch CSD from card. 1566 */ 1567 err = mmc_send_csd(card, card->raw_csd); 1568 if (err) 1569 goto free_card; 1570 1571 err = mmc_decode_csd(card); 1572 if (err) 1573 goto free_card; 1574 err = mmc_decode_cid(card); 1575 if (err) 1576 goto free_card; 1577 } 1578 1579 /* 1580 * handling only for cards supporting DSR and hosts requesting 1581 * DSR configuration 1582 */ 1583 if (card->csd.dsr_imp && host->dsr_req) 1584 mmc_set_dsr(host); 1585 1586 /* 1587 * Select card, as all following commands rely on that. 1588 */ 1589 if (!mmc_host_is_spi(host)) { 1590 err = mmc_select_card(card); 1591 if (err) 1592 goto free_card; 1593 } 1594 1595 if (!oldcard) { 1596 /* Read extended CSD. */ 1597 err = mmc_read_ext_csd(card); 1598 if (err) 1599 goto free_card; 1600 1601 /* 1602 * If doing byte addressing, check if required to do sector 1603 * addressing. Handle the case of <2GB cards needing sector 1604 * addressing. See section 8.1 JEDEC Standard JED84-A441; 1605 * ocr register has bit 30 set for sector addressing. 1606 */ 1607 if (rocr & BIT(30)) 1608 mmc_card_set_blockaddr(card); 1609 1610 /* Erase size depends on CSD and Extended CSD */ 1611 mmc_set_erase_size(card); 1612 } 1613 1614 /* 1615 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF 1616 * bit. This bit will be lost every time after a reset or power off. 1617 */ 1618 if (card->ext_csd.partition_setting_completed || 1619 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) { 1620 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1621 EXT_CSD_ERASE_GROUP_DEF, 1, 1622 card->ext_csd.generic_cmd6_time); 1623 1624 if (err && err != -EBADMSG) 1625 goto free_card; 1626 1627 if (err) { 1628 err = 0; 1629 /* 1630 * Just disable enhanced area off & sz 1631 * will try to enable ERASE_GROUP_DEF 1632 * during next time reinit 1633 */ 1634 card->ext_csd.enhanced_area_offset = -EINVAL; 1635 card->ext_csd.enhanced_area_size = -EINVAL; 1636 } else { 1637 card->ext_csd.erase_group_def = 1; 1638 /* 1639 * enable ERASE_GRP_DEF successfully. 1640 * This will affect the erase size, so 1641 * here need to reset erase size 1642 */ 1643 mmc_set_erase_size(card); 1644 } 1645 } 1646 1647 /* 1648 * Ensure eMMC user default partition is enabled 1649 */ 1650 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) { 1651 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; 1652 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG, 1653 card->ext_csd.part_config, 1654 card->ext_csd.part_time); 1655 if (err && err != -EBADMSG) 1656 goto free_card; 1657 } 1658 1659 /* 1660 * Enable power_off_notification byte in the ext_csd register 1661 */ 1662 if (card->ext_csd.rev >= 6) { 1663 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1664 EXT_CSD_POWER_OFF_NOTIFICATION, 1665 EXT_CSD_POWER_ON, 1666 card->ext_csd.generic_cmd6_time); 1667 if (err && err != -EBADMSG) 1668 goto free_card; 1669 1670 /* 1671 * The err can be -EBADMSG or 0, 1672 * so check for success and update the flag 1673 */ 1674 if (!err) 1675 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON; 1676 } 1677 1678 /* 1679 * Select timing interface 1680 */ 1681 err = mmc_select_timing(card); 1682 if (err) 1683 goto free_card; 1684 1685 if (mmc_card_hs200(card)) { 1686 err = mmc_hs200_tuning(card); 1687 if (err) 1688 goto free_card; 1689 1690 err = mmc_select_hs400(card); 1691 if (err) 1692 goto free_card; 1693 } else if (mmc_card_hs(card)) { 1694 /* Select the desired bus width optionally */ 1695 err = mmc_select_bus_width(card); 1696 if (err > 0) { 1697 err = mmc_select_hs_ddr(card); 1698 if (err) 1699 goto free_card; 1700 } 1701 } 1702 1703 /* 1704 * Choose the power class with selected bus interface 1705 */ 1706 mmc_select_powerclass(card); 1707 1708 /* 1709 * Enable HPI feature (if supported) 1710 */ 1711 if (card->ext_csd.hpi) { 1712 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1713 EXT_CSD_HPI_MGMT, 1, 1714 card->ext_csd.generic_cmd6_time); 1715 if (err && err != -EBADMSG) 1716 goto free_card; 1717 if (err) { 1718 pr_warn("%s: Enabling HPI failed\n", 1719 mmc_hostname(card->host)); 1720 err = 0; 1721 } else 1722 card->ext_csd.hpi_en = 1; 1723 } 1724 1725 /* 1726 * If cache size is higher than 0, this indicates 1727 * the existence of cache and it can be turned on. 1728 */ 1729 if (!mmc_card_broken_hpi(card) && 1730 card->ext_csd.cache_size > 0) { 1731 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1732 EXT_CSD_CACHE_CTRL, 1, 1733 card->ext_csd.generic_cmd6_time); 1734 if (err && err != -EBADMSG) 1735 goto free_card; 1736 1737 /* 1738 * Only if no error, cache is turned on successfully. 1739 */ 1740 if (err) { 1741 pr_warn("%s: Cache is supported, but failed to turn on (%d)\n", 1742 mmc_hostname(card->host), err); 1743 card->ext_csd.cache_ctrl = 0; 1744 err = 0; 1745 } else { 1746 card->ext_csd.cache_ctrl = 1; 1747 } 1748 } 1749 1750 /* 1751 * The mandatory minimum values are defined for packed command. 1752 * read: 5, write: 3 1753 */ 1754 if (card->ext_csd.max_packed_writes >= 3 && 1755 card->ext_csd.max_packed_reads >= 5 && 1756 host->caps2 & MMC_CAP2_PACKED_CMD) { 1757 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1758 EXT_CSD_EXP_EVENTS_CTRL, 1759 EXT_CSD_PACKED_EVENT_EN, 1760 card->ext_csd.generic_cmd6_time); 1761 if (err && err != -EBADMSG) 1762 goto free_card; 1763 if (err) { 1764 pr_warn("%s: Enabling packed event failed\n", 1765 mmc_hostname(card->host)); 1766 card->ext_csd.packed_event_en = 0; 1767 err = 0; 1768 } else { 1769 card->ext_csd.packed_event_en = 1; 1770 } 1771 } 1772 1773 if (!oldcard) 1774 host->card = card; 1775 1776 return 0; 1777 1778 free_card: 1779 if (!oldcard) 1780 mmc_remove_card(card); 1781 err: 1782 return err; 1783 } 1784 1785 static int mmc_can_sleep(struct mmc_card *card) 1786 { 1787 return (card && card->ext_csd.rev >= 3); 1788 } 1789 1790 static int mmc_sleep(struct mmc_host *host) 1791 { 1792 struct mmc_command cmd = {0}; 1793 struct mmc_card *card = host->card; 1794 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000); 1795 int err; 1796 1797 /* Re-tuning can't be done once the card is deselected */ 1798 mmc_retune_hold(host); 1799 1800 err = mmc_deselect_cards(host); 1801 if (err) 1802 goto out_release; 1803 1804 cmd.opcode = MMC_SLEEP_AWAKE; 1805 cmd.arg = card->rca << 16; 1806 cmd.arg |= 1 << 15; 1807 1808 /* 1809 * If the max_busy_timeout of the host is specified, validate it against 1810 * the sleep cmd timeout. A failure means we need to prevent the host 1811 * from doing hw busy detection, which is done by converting to a R1 1812 * response instead of a R1B. 1813 */ 1814 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) { 1815 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1816 } else { 1817 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 1818 cmd.busy_timeout = timeout_ms; 1819 } 1820 1821 err = mmc_wait_for_cmd(host, &cmd, 0); 1822 if (err) 1823 goto out_release; 1824 1825 /* 1826 * If the host does not wait while the card signals busy, then we will 1827 * will have to wait the sleep/awake timeout. Note, we cannot use the 1828 * SEND_STATUS command to poll the status because that command (and most 1829 * others) is invalid while the card sleeps. 1830 */ 1831 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY)) 1832 mmc_delay(timeout_ms); 1833 1834 out_release: 1835 mmc_retune_release(host); 1836 return err; 1837 } 1838 1839 static int mmc_can_poweroff_notify(const struct mmc_card *card) 1840 { 1841 return card && 1842 mmc_card_mmc(card) && 1843 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON); 1844 } 1845 1846 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type) 1847 { 1848 unsigned int timeout = card->ext_csd.generic_cmd6_time; 1849 int err; 1850 1851 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */ 1852 if (notify_type == EXT_CSD_POWER_OFF_LONG) 1853 timeout = card->ext_csd.power_off_longtime; 1854 1855 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1856 EXT_CSD_POWER_OFF_NOTIFICATION, 1857 notify_type, timeout, true, false, false); 1858 if (err) 1859 pr_err("%s: Power Off Notification timed out, %u\n", 1860 mmc_hostname(card->host), timeout); 1861 1862 /* Disable the power off notification after the switch operation. */ 1863 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION; 1864 1865 return err; 1866 } 1867 1868 /* 1869 * Host is being removed. Free up the current card. 1870 */ 1871 static void mmc_remove(struct mmc_host *host) 1872 { 1873 BUG_ON(!host); 1874 BUG_ON(!host->card); 1875 1876 mmc_remove_card(host->card); 1877 host->card = NULL; 1878 } 1879 1880 /* 1881 * Card detection - card is alive. 1882 */ 1883 static int mmc_alive(struct mmc_host *host) 1884 { 1885 return mmc_send_status(host->card, NULL); 1886 } 1887 1888 /* 1889 * Card detection callback from host. 1890 */ 1891 static void mmc_detect(struct mmc_host *host) 1892 { 1893 int err; 1894 1895 BUG_ON(!host); 1896 BUG_ON(!host->card); 1897 1898 mmc_get_card(host->card); 1899 1900 /* 1901 * Just check if our card has been removed. 1902 */ 1903 err = _mmc_detect_card_removed(host); 1904 1905 mmc_put_card(host->card); 1906 1907 if (err) { 1908 mmc_remove(host); 1909 1910 mmc_claim_host(host); 1911 mmc_detach_bus(host); 1912 mmc_power_off(host); 1913 mmc_release_host(host); 1914 } 1915 } 1916 1917 static int _mmc_suspend(struct mmc_host *host, bool is_suspend) 1918 { 1919 int err = 0; 1920 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT : 1921 EXT_CSD_POWER_OFF_LONG; 1922 1923 BUG_ON(!host); 1924 BUG_ON(!host->card); 1925 1926 mmc_claim_host(host); 1927 1928 if (mmc_card_suspended(host->card)) 1929 goto out; 1930 1931 if (mmc_card_doing_bkops(host->card)) { 1932 err = mmc_stop_bkops(host->card); 1933 if (err) 1934 goto out; 1935 } 1936 1937 err = mmc_flush_cache(host->card); 1938 if (err) 1939 goto out; 1940 1941 if (mmc_can_poweroff_notify(host->card) && 1942 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend)) 1943 err = mmc_poweroff_notify(host->card, notify_type); 1944 else if (mmc_can_sleep(host->card)) 1945 err = mmc_sleep(host); 1946 else if (!mmc_host_is_spi(host)) 1947 err = mmc_deselect_cards(host); 1948 1949 if (!err) { 1950 mmc_power_off(host); 1951 mmc_card_set_suspended(host->card); 1952 } 1953 out: 1954 mmc_release_host(host); 1955 return err; 1956 } 1957 1958 /* 1959 * Suspend callback 1960 */ 1961 static int mmc_suspend(struct mmc_host *host) 1962 { 1963 int err; 1964 1965 err = _mmc_suspend(host, true); 1966 if (!err) { 1967 pm_runtime_disable(&host->card->dev); 1968 pm_runtime_set_suspended(&host->card->dev); 1969 } 1970 1971 return err; 1972 } 1973 1974 /* 1975 * This function tries to determine if the same card is still present 1976 * and, if so, restore all state to it. 1977 */ 1978 static int _mmc_resume(struct mmc_host *host) 1979 { 1980 int err = 0; 1981 1982 BUG_ON(!host); 1983 BUG_ON(!host->card); 1984 1985 mmc_claim_host(host); 1986 1987 if (!mmc_card_suspended(host->card)) 1988 goto out; 1989 1990 mmc_power_up(host, host->card->ocr); 1991 err = mmc_init_card(host, host->card->ocr, host->card); 1992 mmc_card_clr_suspended(host->card); 1993 1994 out: 1995 mmc_release_host(host); 1996 return err; 1997 } 1998 1999 /* 2000 * Shutdown callback 2001 */ 2002 static int mmc_shutdown(struct mmc_host *host) 2003 { 2004 int err = 0; 2005 2006 /* 2007 * In a specific case for poweroff notify, we need to resume the card 2008 * before we can shutdown it properly. 2009 */ 2010 if (mmc_can_poweroff_notify(host->card) && 2011 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE)) 2012 err = _mmc_resume(host); 2013 2014 if (!err) 2015 err = _mmc_suspend(host, false); 2016 2017 return err; 2018 } 2019 2020 /* 2021 * Callback for resume. 2022 */ 2023 static int mmc_resume(struct mmc_host *host) 2024 { 2025 pm_runtime_enable(&host->card->dev); 2026 return 0; 2027 } 2028 2029 /* 2030 * Callback for runtime_suspend. 2031 */ 2032 static int mmc_runtime_suspend(struct mmc_host *host) 2033 { 2034 int err; 2035 2036 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM)) 2037 return 0; 2038 2039 err = _mmc_suspend(host, true); 2040 if (err) 2041 pr_err("%s: error %d doing aggressive suspend\n", 2042 mmc_hostname(host), err); 2043 2044 return err; 2045 } 2046 2047 /* 2048 * Callback for runtime_resume. 2049 */ 2050 static int mmc_runtime_resume(struct mmc_host *host) 2051 { 2052 int err; 2053 2054 err = _mmc_resume(host); 2055 if (err && err != -ENOMEDIUM) 2056 pr_err("%s: error %d doing runtime resume\n", 2057 mmc_hostname(host), err); 2058 2059 return 0; 2060 } 2061 2062 int mmc_can_reset(struct mmc_card *card) 2063 { 2064 u8 rst_n_function; 2065 2066 rst_n_function = card->ext_csd.rst_n_function; 2067 if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED) 2068 return 0; 2069 return 1; 2070 } 2071 EXPORT_SYMBOL(mmc_can_reset); 2072 2073 static int mmc_reset(struct mmc_host *host) 2074 { 2075 struct mmc_card *card = host->card; 2076 2077 /* 2078 * In the case of recovery, we can't expect flushing the cache to work 2079 * always, but we have a go and ignore errors. 2080 */ 2081 mmc_flush_cache(host->card); 2082 2083 if ((host->caps & MMC_CAP_HW_RESET) && host->ops->hw_reset && 2084 mmc_can_reset(card)) { 2085 /* If the card accept RST_n signal, send it. */ 2086 mmc_set_clock(host, host->f_init); 2087 host->ops->hw_reset(host); 2088 /* Set initial state and call mmc_set_ios */ 2089 mmc_set_initial_state(host); 2090 } else { 2091 /* Do a brute force power cycle */ 2092 mmc_power_cycle(host, card->ocr); 2093 } 2094 return mmc_init_card(host, card->ocr, card); 2095 } 2096 2097 static const struct mmc_bus_ops mmc_ops = { 2098 .remove = mmc_remove, 2099 .detect = mmc_detect, 2100 .suspend = mmc_suspend, 2101 .resume = mmc_resume, 2102 .runtime_suspend = mmc_runtime_suspend, 2103 .runtime_resume = mmc_runtime_resume, 2104 .alive = mmc_alive, 2105 .shutdown = mmc_shutdown, 2106 .reset = mmc_reset, 2107 }; 2108 2109 /* 2110 * Starting point for MMC card init. 2111 */ 2112 int mmc_attach_mmc(struct mmc_host *host) 2113 { 2114 int err; 2115 u32 ocr, rocr; 2116 2117 BUG_ON(!host); 2118 WARN_ON(!host->claimed); 2119 2120 /* Set correct bus mode for MMC before attempting attach */ 2121 if (!mmc_host_is_spi(host)) 2122 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 2123 2124 err = mmc_send_op_cond(host, 0, &ocr); 2125 if (err) 2126 return err; 2127 2128 mmc_attach_bus(host, &mmc_ops); 2129 if (host->ocr_avail_mmc) 2130 host->ocr_avail = host->ocr_avail_mmc; 2131 2132 /* 2133 * We need to get OCR a different way for SPI. 2134 */ 2135 if (mmc_host_is_spi(host)) { 2136 err = mmc_spi_read_ocr(host, 1, &ocr); 2137 if (err) 2138 goto err; 2139 } 2140 2141 rocr = mmc_select_voltage(host, ocr); 2142 2143 /* 2144 * Can we support the voltage of the card? 2145 */ 2146 if (!rocr) { 2147 err = -EINVAL; 2148 goto err; 2149 } 2150 2151 /* 2152 * Detect and init the card. 2153 */ 2154 err = mmc_init_card(host, rocr, NULL); 2155 if (err) 2156 goto err; 2157 2158 mmc_release_host(host); 2159 err = mmc_add_card(host->card); 2160 if (err) 2161 goto remove_card; 2162 2163 mmc_claim_host(host); 2164 return 0; 2165 2166 remove_card: 2167 mmc_remove_card(host->card); 2168 mmc_claim_host(host); 2169 host->card = NULL; 2170 err: 2171 mmc_detach_bus(host); 2172 2173 pr_err("%s: error %d whilst initialising MMC card\n", 2174 mmc_hostname(host), err); 2175 2176 return err; 2177 } 2178