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