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/slab.h> 15 #include <linux/stat.h> 16 #include <linux/pm_runtime.h> 17 18 #include <linux/mmc/host.h> 19 #include <linux/mmc/card.h> 20 #include <linux/mmc/mmc.h> 21 22 #include "core.h" 23 #include "bus.h" 24 #include "mmc_ops.h" 25 #include "sd_ops.h" 26 27 static const unsigned int tran_exp[] = { 28 10000, 100000, 1000000, 10000000, 29 0, 0, 0, 0 30 }; 31 32 static const unsigned char tran_mant[] = { 33 0, 10, 12, 13, 15, 20, 25, 30, 34 35, 40, 45, 50, 55, 60, 70, 80, 35 }; 36 37 static const unsigned int tacc_exp[] = { 38 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 39 }; 40 41 static const unsigned int tacc_mant[] = { 42 0, 10, 12, 13, 15, 20, 25, 30, 43 35, 40, 45, 50, 55, 60, 70, 80, 44 }; 45 46 #define UNSTUFF_BITS(resp,start,size) \ 47 ({ \ 48 const int __size = size; \ 49 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \ 50 const int __off = 3 - ((start) / 32); \ 51 const int __shft = (start) & 31; \ 52 u32 __res; \ 53 \ 54 __res = resp[__off] >> __shft; \ 55 if (__size + __shft > 32) \ 56 __res |= resp[__off-1] << ((32 - __shft) % 32); \ 57 __res & __mask; \ 58 }) 59 60 /* 61 * Given the decoded CSD structure, decode the raw CID to our CID structure. 62 */ 63 static int mmc_decode_cid(struct mmc_card *card) 64 { 65 u32 *resp = card->raw_cid; 66 67 /* 68 * The selection of the format here is based upon published 69 * specs from sandisk and from what people have reported. 70 */ 71 switch (card->csd.mmca_vsn) { 72 case 0: /* MMC v1.0 - v1.2 */ 73 case 1: /* MMC v1.4 */ 74 card->cid.manfid = UNSTUFF_BITS(resp, 104, 24); 75 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 76 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 77 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 78 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 79 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 80 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 81 card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8); 82 card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4); 83 card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4); 84 card->cid.serial = UNSTUFF_BITS(resp, 16, 24); 85 card->cid.month = UNSTUFF_BITS(resp, 12, 4); 86 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 87 break; 88 89 case 2: /* MMC v2.0 - v2.2 */ 90 case 3: /* MMC v3.1 - v3.3 */ 91 case 4: /* MMC v4 */ 92 card->cid.manfid = UNSTUFF_BITS(resp, 120, 8); 93 card->cid.oemid = UNSTUFF_BITS(resp, 104, 16); 94 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 95 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 96 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 97 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 98 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 99 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 100 card->cid.prv = UNSTUFF_BITS(resp, 48, 8); 101 card->cid.serial = UNSTUFF_BITS(resp, 16, 32); 102 card->cid.month = UNSTUFF_BITS(resp, 12, 4); 103 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 104 break; 105 106 default: 107 pr_err("%s: card has unknown MMCA version %d\n", 108 mmc_hostname(card->host), card->csd.mmca_vsn); 109 return -EINVAL; 110 } 111 112 return 0; 113 } 114 115 static void mmc_set_erase_size(struct mmc_card *card) 116 { 117 if (card->ext_csd.erase_group_def & 1) 118 card->erase_size = card->ext_csd.hc_erase_size; 119 else 120 card->erase_size = card->csd.erase_size; 121 122 mmc_init_erase(card); 123 } 124 125 /* 126 * Given a 128-bit response, decode to our card CSD structure. 127 */ 128 static int mmc_decode_csd(struct mmc_card *card) 129 { 130 struct mmc_csd *csd = &card->csd; 131 unsigned int e, m, a, b; 132 u32 *resp = card->raw_csd; 133 134 /* 135 * We only understand CSD structure v1.1 and v1.2. 136 * v1.2 has extra information in bits 15, 11 and 10. 137 * We also support eMMC v4.4 & v4.41. 138 */ 139 csd->structure = UNSTUFF_BITS(resp, 126, 2); 140 if (csd->structure == 0) { 141 pr_err("%s: unrecognised CSD structure version %d\n", 142 mmc_hostname(card->host), csd->structure); 143 return -EINVAL; 144 } 145 146 csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4); 147 m = UNSTUFF_BITS(resp, 115, 4); 148 e = UNSTUFF_BITS(resp, 112, 3); 149 csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; 150 csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100; 151 152 m = UNSTUFF_BITS(resp, 99, 4); 153 e = UNSTUFF_BITS(resp, 96, 3); 154 csd->max_dtr = tran_exp[e] * tran_mant[m]; 155 csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); 156 157 e = UNSTUFF_BITS(resp, 47, 3); 158 m = UNSTUFF_BITS(resp, 62, 12); 159 csd->capacity = (1 + m) << (e + 2); 160 161 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4); 162 csd->read_partial = UNSTUFF_BITS(resp, 79, 1); 163 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1); 164 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1); 165 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); 166 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); 167 csd->write_partial = UNSTUFF_BITS(resp, 21, 1); 168 169 if (csd->write_blkbits >= 9) { 170 a = UNSTUFF_BITS(resp, 42, 5); 171 b = UNSTUFF_BITS(resp, 37, 5); 172 csd->erase_size = (a + 1) * (b + 1); 173 csd->erase_size <<= csd->write_blkbits - 9; 174 } 175 176 return 0; 177 } 178 179 /* 180 * Read extended CSD. 181 */ 182 static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd) 183 { 184 int err; 185 u8 *ext_csd; 186 187 BUG_ON(!card); 188 BUG_ON(!new_ext_csd); 189 190 *new_ext_csd = NULL; 191 192 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 193 return 0; 194 195 /* 196 * As the ext_csd is so large and mostly unused, we don't store the 197 * raw block in mmc_card. 198 */ 199 ext_csd = kmalloc(512, GFP_KERNEL); 200 if (!ext_csd) { 201 pr_err("%s: could not allocate a buffer to " 202 "receive the ext_csd.\n", mmc_hostname(card->host)); 203 return -ENOMEM; 204 } 205 206 err = mmc_send_ext_csd(card, ext_csd); 207 if (err) { 208 kfree(ext_csd); 209 *new_ext_csd = NULL; 210 211 /* If the host or the card can't do the switch, 212 * fail more gracefully. */ 213 if ((err != -EINVAL) 214 && (err != -ENOSYS) 215 && (err != -EFAULT)) 216 return err; 217 218 /* 219 * High capacity cards should have this "magic" size 220 * stored in their CSD. 221 */ 222 if (card->csd.capacity == (4096 * 512)) { 223 pr_err("%s: unable to read EXT_CSD " 224 "on a possible high capacity card. " 225 "Card will be ignored.\n", 226 mmc_hostname(card->host)); 227 } else { 228 pr_warning("%s: unable to read " 229 "EXT_CSD, performance might " 230 "suffer.\n", 231 mmc_hostname(card->host)); 232 err = 0; 233 } 234 } else 235 *new_ext_csd = ext_csd; 236 237 return err; 238 } 239 240 static void mmc_select_card_type(struct mmc_card *card) 241 { 242 struct mmc_host *host = card->host; 243 u8 card_type = card->ext_csd.raw_card_type & EXT_CSD_CARD_TYPE_MASK; 244 u32 caps = host->caps, caps2 = host->caps2; 245 unsigned int hs_max_dtr = 0; 246 247 if (card_type & EXT_CSD_CARD_TYPE_26) 248 hs_max_dtr = MMC_HIGH_26_MAX_DTR; 249 250 if (caps & MMC_CAP_MMC_HIGHSPEED && 251 card_type & EXT_CSD_CARD_TYPE_52) 252 hs_max_dtr = MMC_HIGH_52_MAX_DTR; 253 254 if ((caps & MMC_CAP_1_8V_DDR && 255 card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) || 256 (caps & MMC_CAP_1_2V_DDR && 257 card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)) 258 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR; 259 260 if ((caps2 & MMC_CAP2_HS200_1_8V_SDR && 261 card_type & EXT_CSD_CARD_TYPE_SDR_1_8V) || 262 (caps2 & MMC_CAP2_HS200_1_2V_SDR && 263 card_type & EXT_CSD_CARD_TYPE_SDR_1_2V)) 264 hs_max_dtr = MMC_HS200_MAX_DTR; 265 266 card->ext_csd.hs_max_dtr = hs_max_dtr; 267 card->ext_csd.card_type = card_type; 268 } 269 270 /* 271 * Decode extended CSD. 272 */ 273 static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) 274 { 275 int err = 0, idx; 276 unsigned int part_size; 277 u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0; 278 279 BUG_ON(!card); 280 281 if (!ext_csd) 282 return 0; 283 284 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */ 285 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE]; 286 if (card->csd.structure == 3) { 287 if (card->ext_csd.raw_ext_csd_structure > 2) { 288 pr_err("%s: unrecognised EXT_CSD structure " 289 "version %d\n", mmc_hostname(card->host), 290 card->ext_csd.raw_ext_csd_structure); 291 err = -EINVAL; 292 goto out; 293 } 294 } 295 296 card->ext_csd.rev = ext_csd[EXT_CSD_REV]; 297 if (card->ext_csd.rev > 7) { 298 pr_err("%s: unrecognised EXT_CSD revision %d\n", 299 mmc_hostname(card->host), card->ext_csd.rev); 300 err = -EINVAL; 301 goto out; 302 } 303 304 card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0]; 305 card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1]; 306 card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2]; 307 card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3]; 308 if (card->ext_csd.rev >= 2) { 309 card->ext_csd.sectors = 310 ext_csd[EXT_CSD_SEC_CNT + 0] << 0 | 311 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 | 312 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 | 313 ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 314 315 /* Cards with density > 2GiB are sector addressed */ 316 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512) 317 mmc_card_set_blockaddr(card); 318 } 319 320 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE]; 321 mmc_select_card_type(card); 322 323 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT]; 324 card->ext_csd.raw_erase_timeout_mult = 325 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 326 card->ext_csd.raw_hc_erase_grp_size = 327 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 328 if (card->ext_csd.rev >= 3) { 329 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT]; 330 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG]; 331 332 /* EXT_CSD value is in units of 10ms, but we store in ms */ 333 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME]; 334 335 /* Sleep / awake timeout in 100ns units */ 336 if (sa_shift > 0 && sa_shift <= 0x17) 337 card->ext_csd.sa_timeout = 338 1 << ext_csd[EXT_CSD_S_A_TIMEOUT]; 339 card->ext_csd.erase_group_def = 340 ext_csd[EXT_CSD_ERASE_GROUP_DEF]; 341 card->ext_csd.hc_erase_timeout = 300 * 342 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 343 card->ext_csd.hc_erase_size = 344 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10; 345 346 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C]; 347 348 /* 349 * There are two boot regions of equal size, defined in 350 * multiples of 128K. 351 */ 352 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) { 353 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) { 354 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17; 355 mmc_part_add(card, part_size, 356 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx, 357 "boot%d", idx, true, 358 MMC_BLK_DATA_AREA_BOOT); 359 } 360 } 361 } 362 363 card->ext_csd.raw_hc_erase_gap_size = 364 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 365 card->ext_csd.raw_sec_trim_mult = 366 ext_csd[EXT_CSD_SEC_TRIM_MULT]; 367 card->ext_csd.raw_sec_erase_mult = 368 ext_csd[EXT_CSD_SEC_ERASE_MULT]; 369 card->ext_csd.raw_sec_feature_support = 370 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 371 card->ext_csd.raw_trim_mult = 372 ext_csd[EXT_CSD_TRIM_MULT]; 373 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT]; 374 if (card->ext_csd.rev >= 4) { 375 /* 376 * Enhanced area feature support -- check whether the eMMC 377 * card has the Enhanced area enabled. If so, export enhanced 378 * area offset and size to user by adding sysfs interface. 379 */ 380 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) && 381 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) { 382 hc_erase_grp_sz = 383 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 384 hc_wp_grp_sz = 385 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 386 387 card->ext_csd.enhanced_area_en = 1; 388 /* 389 * calculate the enhanced data area offset, in bytes 390 */ 391 card->ext_csd.enhanced_area_offset = 392 (ext_csd[139] << 24) + (ext_csd[138] << 16) + 393 (ext_csd[137] << 8) + ext_csd[136]; 394 if (mmc_card_blockaddr(card)) 395 card->ext_csd.enhanced_area_offset <<= 9; 396 /* 397 * calculate the enhanced data area size, in kilobytes 398 */ 399 card->ext_csd.enhanced_area_size = 400 (ext_csd[142] << 16) + (ext_csd[141] << 8) + 401 ext_csd[140]; 402 card->ext_csd.enhanced_area_size *= 403 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz); 404 card->ext_csd.enhanced_area_size <<= 9; 405 } else { 406 /* 407 * If the enhanced area is not enabled, disable these 408 * device attributes. 409 */ 410 card->ext_csd.enhanced_area_offset = -EINVAL; 411 card->ext_csd.enhanced_area_size = -EINVAL; 412 } 413 414 /* 415 * General purpose partition feature support -- 416 * If ext_csd has the size of general purpose partitions, 417 * set size, part_cfg, partition name in mmc_part. 418 */ 419 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] & 420 EXT_CSD_PART_SUPPORT_PART_EN) { 421 if (card->ext_csd.enhanced_area_en != 1) { 422 hc_erase_grp_sz = 423 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 424 hc_wp_grp_sz = 425 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 426 427 card->ext_csd.enhanced_area_en = 1; 428 } 429 430 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) { 431 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] && 432 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] && 433 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]) 434 continue; 435 part_size = 436 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2] 437 << 16) + 438 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] 439 << 8) + 440 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3]; 441 part_size *= (size_t)(hc_erase_grp_sz * 442 hc_wp_grp_sz); 443 mmc_part_add(card, part_size << 19, 444 EXT_CSD_PART_CONFIG_ACC_GP0 + idx, 445 "gp%d", idx, false, 446 MMC_BLK_DATA_AREA_GP); 447 } 448 } 449 card->ext_csd.sec_trim_mult = 450 ext_csd[EXT_CSD_SEC_TRIM_MULT]; 451 card->ext_csd.sec_erase_mult = 452 ext_csd[EXT_CSD_SEC_ERASE_MULT]; 453 card->ext_csd.sec_feature_support = 454 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 455 card->ext_csd.trim_timeout = 300 * 456 ext_csd[EXT_CSD_TRIM_MULT]; 457 458 /* 459 * Note that the call to mmc_part_add above defaults to read 460 * only. If this default assumption is changed, the call must 461 * take into account the value of boot_locked below. 462 */ 463 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP]; 464 card->ext_csd.boot_ro_lockable = true; 465 466 /* Save power class values */ 467 card->ext_csd.raw_pwr_cl_52_195 = 468 ext_csd[EXT_CSD_PWR_CL_52_195]; 469 card->ext_csd.raw_pwr_cl_26_195 = 470 ext_csd[EXT_CSD_PWR_CL_26_195]; 471 card->ext_csd.raw_pwr_cl_52_360 = 472 ext_csd[EXT_CSD_PWR_CL_52_360]; 473 card->ext_csd.raw_pwr_cl_26_360 = 474 ext_csd[EXT_CSD_PWR_CL_26_360]; 475 card->ext_csd.raw_pwr_cl_200_195 = 476 ext_csd[EXT_CSD_PWR_CL_200_195]; 477 card->ext_csd.raw_pwr_cl_200_360 = 478 ext_csd[EXT_CSD_PWR_CL_200_360]; 479 card->ext_csd.raw_pwr_cl_ddr_52_195 = 480 ext_csd[EXT_CSD_PWR_CL_DDR_52_195]; 481 card->ext_csd.raw_pwr_cl_ddr_52_360 = 482 ext_csd[EXT_CSD_PWR_CL_DDR_52_360]; 483 } 484 485 if (card->ext_csd.rev >= 5) { 486 /* Adjust production date as per JEDEC JESD84-B451 */ 487 if (card->cid.year < 2010) 488 card->cid.year += 16; 489 490 /* check whether the eMMC card supports BKOPS */ 491 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) { 492 card->ext_csd.bkops = 1; 493 card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN]; 494 card->ext_csd.raw_bkops_status = 495 ext_csd[EXT_CSD_BKOPS_STATUS]; 496 if (!card->ext_csd.bkops_en) 497 pr_info("%s: BKOPS_EN bit is not set\n", 498 mmc_hostname(card->host)); 499 } 500 501 /* check whether the eMMC card supports HPI */ 502 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) { 503 card->ext_csd.hpi = 1; 504 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2) 505 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION; 506 else 507 card->ext_csd.hpi_cmd = MMC_SEND_STATUS; 508 /* 509 * Indicate the maximum timeout to close 510 * a command interrupted by HPI 511 */ 512 card->ext_csd.out_of_int_time = 513 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10; 514 } 515 516 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM]; 517 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION]; 518 519 /* 520 * RPMB regions are defined in multiples of 128K. 521 */ 522 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT]; 523 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) { 524 mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17, 525 EXT_CSD_PART_CONFIG_ACC_RPMB, 526 "rpmb", 0, false, 527 MMC_BLK_DATA_AREA_RPMB); 528 } 529 } 530 531 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT]; 532 if (ext_csd[EXT_CSD_ERASED_MEM_CONT]) 533 card->erased_byte = 0xFF; 534 else 535 card->erased_byte = 0x0; 536 537 /* eMMC v4.5 or later */ 538 if (card->ext_csd.rev >= 6) { 539 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE; 540 541 card->ext_csd.generic_cmd6_time = 10 * 542 ext_csd[EXT_CSD_GENERIC_CMD6_TIME]; 543 card->ext_csd.power_off_longtime = 10 * 544 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME]; 545 546 card->ext_csd.cache_size = 547 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 | 548 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 | 549 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 | 550 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24; 551 552 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1) 553 card->ext_csd.data_sector_size = 4096; 554 else 555 card->ext_csd.data_sector_size = 512; 556 557 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) && 558 (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) { 559 card->ext_csd.data_tag_unit_size = 560 ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) * 561 (card->ext_csd.data_sector_size); 562 } else { 563 card->ext_csd.data_tag_unit_size = 0; 564 } 565 566 card->ext_csd.max_packed_writes = 567 ext_csd[EXT_CSD_MAX_PACKED_WRITES]; 568 card->ext_csd.max_packed_reads = 569 ext_csd[EXT_CSD_MAX_PACKED_READS]; 570 } else { 571 card->ext_csd.data_sector_size = 512; 572 } 573 574 out: 575 return err; 576 } 577 578 static inline void mmc_free_ext_csd(u8 *ext_csd) 579 { 580 kfree(ext_csd); 581 } 582 583 584 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width) 585 { 586 u8 *bw_ext_csd; 587 int err; 588 589 if (bus_width == MMC_BUS_WIDTH_1) 590 return 0; 591 592 err = mmc_get_ext_csd(card, &bw_ext_csd); 593 594 if (err || bw_ext_csd == NULL) { 595 err = -EINVAL; 596 goto out; 597 } 598 599 /* only compare read only fields */ 600 err = !((card->ext_csd.raw_partition_support == 601 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) && 602 (card->ext_csd.raw_erased_mem_count == 603 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) && 604 (card->ext_csd.rev == 605 bw_ext_csd[EXT_CSD_REV]) && 606 (card->ext_csd.raw_ext_csd_structure == 607 bw_ext_csd[EXT_CSD_STRUCTURE]) && 608 (card->ext_csd.raw_card_type == 609 bw_ext_csd[EXT_CSD_CARD_TYPE]) && 610 (card->ext_csd.raw_s_a_timeout == 611 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) && 612 (card->ext_csd.raw_hc_erase_gap_size == 613 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) && 614 (card->ext_csd.raw_erase_timeout_mult == 615 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) && 616 (card->ext_csd.raw_hc_erase_grp_size == 617 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) && 618 (card->ext_csd.raw_sec_trim_mult == 619 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) && 620 (card->ext_csd.raw_sec_erase_mult == 621 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) && 622 (card->ext_csd.raw_sec_feature_support == 623 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) && 624 (card->ext_csd.raw_trim_mult == 625 bw_ext_csd[EXT_CSD_TRIM_MULT]) && 626 (card->ext_csd.raw_sectors[0] == 627 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) && 628 (card->ext_csd.raw_sectors[1] == 629 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) && 630 (card->ext_csd.raw_sectors[2] == 631 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) && 632 (card->ext_csd.raw_sectors[3] == 633 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) && 634 (card->ext_csd.raw_pwr_cl_52_195 == 635 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) && 636 (card->ext_csd.raw_pwr_cl_26_195 == 637 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) && 638 (card->ext_csd.raw_pwr_cl_52_360 == 639 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) && 640 (card->ext_csd.raw_pwr_cl_26_360 == 641 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) && 642 (card->ext_csd.raw_pwr_cl_200_195 == 643 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) && 644 (card->ext_csd.raw_pwr_cl_200_360 == 645 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) && 646 (card->ext_csd.raw_pwr_cl_ddr_52_195 == 647 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) && 648 (card->ext_csd.raw_pwr_cl_ddr_52_360 == 649 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360])); 650 if (err) 651 err = -EINVAL; 652 653 out: 654 mmc_free_ext_csd(bw_ext_csd); 655 return err; 656 } 657 658 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], 659 card->raw_cid[2], card->raw_cid[3]); 660 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], 661 card->raw_csd[2], card->raw_csd[3]); 662 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); 663 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); 664 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); 665 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev); 666 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); 667 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid); 668 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name); 669 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid); 670 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv); 671 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial); 672 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n", 673 card->ext_csd.enhanced_area_offset); 674 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size); 675 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult); 676 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors); 677 678 static struct attribute *mmc_std_attrs[] = { 679 &dev_attr_cid.attr, 680 &dev_attr_csd.attr, 681 &dev_attr_date.attr, 682 &dev_attr_erase_size.attr, 683 &dev_attr_preferred_erase_size.attr, 684 &dev_attr_fwrev.attr, 685 &dev_attr_hwrev.attr, 686 &dev_attr_manfid.attr, 687 &dev_attr_name.attr, 688 &dev_attr_oemid.attr, 689 &dev_attr_prv.attr, 690 &dev_attr_serial.attr, 691 &dev_attr_enhanced_area_offset.attr, 692 &dev_attr_enhanced_area_size.attr, 693 &dev_attr_raw_rpmb_size_mult.attr, 694 &dev_attr_rel_sectors.attr, 695 NULL, 696 }; 697 698 static struct attribute_group mmc_std_attr_group = { 699 .attrs = mmc_std_attrs, 700 }; 701 702 static const struct attribute_group *mmc_attr_groups[] = { 703 &mmc_std_attr_group, 704 NULL, 705 }; 706 707 static struct device_type mmc_type = { 708 .groups = mmc_attr_groups, 709 }; 710 711 /* 712 * Select the PowerClass for the current bus width 713 * If power class is defined for 4/8 bit bus in the 714 * extended CSD register, select it by executing the 715 * mmc_switch command. 716 */ 717 static int mmc_select_powerclass(struct mmc_card *card, 718 unsigned int bus_width) 719 { 720 int err = 0; 721 unsigned int pwrclass_val = 0; 722 struct mmc_host *host; 723 724 BUG_ON(!card); 725 726 host = card->host; 727 BUG_ON(!host); 728 729 /* Power class selection is supported for versions >= 4.0 */ 730 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 731 return 0; 732 733 /* Power class values are defined only for 4/8 bit bus */ 734 if (bus_width == EXT_CSD_BUS_WIDTH_1) 735 return 0; 736 737 switch (1 << host->ios.vdd) { 738 case MMC_VDD_165_195: 739 if (host->ios.clock <= 26000000) 740 pwrclass_val = card->ext_csd.raw_pwr_cl_26_195; 741 else if (host->ios.clock <= 52000000) 742 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 743 card->ext_csd.raw_pwr_cl_52_195 : 744 card->ext_csd.raw_pwr_cl_ddr_52_195; 745 else if (host->ios.clock <= 200000000) 746 pwrclass_val = card->ext_csd.raw_pwr_cl_200_195; 747 break; 748 case MMC_VDD_27_28: 749 case MMC_VDD_28_29: 750 case MMC_VDD_29_30: 751 case MMC_VDD_30_31: 752 case MMC_VDD_31_32: 753 case MMC_VDD_32_33: 754 case MMC_VDD_33_34: 755 case MMC_VDD_34_35: 756 case MMC_VDD_35_36: 757 if (host->ios.clock <= 26000000) 758 pwrclass_val = card->ext_csd.raw_pwr_cl_26_360; 759 else if (host->ios.clock <= 52000000) 760 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 761 card->ext_csd.raw_pwr_cl_52_360 : 762 card->ext_csd.raw_pwr_cl_ddr_52_360; 763 else if (host->ios.clock <= 200000000) 764 pwrclass_val = card->ext_csd.raw_pwr_cl_200_360; 765 break; 766 default: 767 pr_warning("%s: Voltage range not supported " 768 "for power class.\n", mmc_hostname(host)); 769 return -EINVAL; 770 } 771 772 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8)) 773 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >> 774 EXT_CSD_PWR_CL_8BIT_SHIFT; 775 else 776 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >> 777 EXT_CSD_PWR_CL_4BIT_SHIFT; 778 779 /* If the power class is different from the default value */ 780 if (pwrclass_val > 0) { 781 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 782 EXT_CSD_POWER_CLASS, 783 pwrclass_val, 784 card->ext_csd.generic_cmd6_time); 785 } 786 787 return err; 788 } 789 790 /* 791 * Selects the desired buswidth and switch to the HS200 mode 792 * if bus width set without error 793 */ 794 static int mmc_select_hs200(struct mmc_card *card) 795 { 796 int idx, err = -EINVAL; 797 struct mmc_host *host; 798 static unsigned ext_csd_bits[] = { 799 EXT_CSD_BUS_WIDTH_4, 800 EXT_CSD_BUS_WIDTH_8, 801 }; 802 static unsigned bus_widths[] = { 803 MMC_BUS_WIDTH_4, 804 MMC_BUS_WIDTH_8, 805 }; 806 807 BUG_ON(!card); 808 809 host = card->host; 810 811 if (card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_2V && 812 host->caps2 & MMC_CAP2_HS200_1_2V_SDR) 813 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 814 815 if (err && card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_8V && 816 host->caps2 & MMC_CAP2_HS200_1_8V_SDR) 817 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 818 819 /* If fails try again during next card power cycle */ 820 if (err) 821 goto err; 822 823 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 1 : 0; 824 825 /* 826 * Unlike SD, MMC cards dont have a configuration register to notify 827 * supported bus width. So bus test command should be run to identify 828 * the supported bus width or compare the ext csd values of current 829 * bus width and ext csd values of 1 bit mode read earlier. 830 */ 831 for (; idx >= 0; idx--) { 832 833 /* 834 * Host is capable of 8bit transfer, then switch 835 * the device to work in 8bit transfer mode. If the 836 * mmc switch command returns error then switch to 837 * 4bit transfer mode. On success set the corresponding 838 * bus width on the host. 839 */ 840 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 841 EXT_CSD_BUS_WIDTH, 842 ext_csd_bits[idx], 843 card->ext_csd.generic_cmd6_time); 844 if (err) 845 continue; 846 847 mmc_set_bus_width(card->host, bus_widths[idx]); 848 849 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) 850 err = mmc_compare_ext_csds(card, bus_widths[idx]); 851 else 852 err = mmc_bus_test(card, bus_widths[idx]); 853 if (!err) 854 break; 855 } 856 857 /* switch to HS200 mode if bus width set successfully */ 858 if (!err) 859 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 860 EXT_CSD_HS_TIMING, 2, 861 card->ext_csd.generic_cmd6_time, 862 true, true, true); 863 err: 864 return err; 865 } 866 867 /* 868 * Handle the detection and initialisation of a card. 869 * 870 * In the case of a resume, "oldcard" will contain the card 871 * we're trying to reinitialise. 872 */ 873 static int mmc_init_card(struct mmc_host *host, u32 ocr, 874 struct mmc_card *oldcard) 875 { 876 struct mmc_card *card; 877 int err, ddr = 0; 878 u32 cid[4]; 879 unsigned int max_dtr; 880 u32 rocr; 881 u8 *ext_csd = NULL; 882 883 BUG_ON(!host); 884 WARN_ON(!host->claimed); 885 886 /* Set correct bus mode for MMC before attempting init */ 887 if (!mmc_host_is_spi(host)) 888 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 889 890 /* 891 * Since we're changing the OCR value, we seem to 892 * need to tell some cards to go back to the idle 893 * state. We wait 1ms to give cards time to 894 * respond. 895 * mmc_go_idle is needed for eMMC that are asleep 896 */ 897 mmc_go_idle(host); 898 899 /* The extra bit indicates that we support high capacity */ 900 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr); 901 if (err) 902 goto err; 903 904 /* 905 * For SPI, enable CRC as appropriate. 906 */ 907 if (mmc_host_is_spi(host)) { 908 err = mmc_spi_set_crc(host, use_spi_crc); 909 if (err) 910 goto err; 911 } 912 913 /* 914 * Fetch CID from card. 915 */ 916 if (mmc_host_is_spi(host)) 917 err = mmc_send_cid(host, cid); 918 else 919 err = mmc_all_send_cid(host, cid); 920 if (err) 921 goto err; 922 923 if (oldcard) { 924 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) { 925 err = -ENOENT; 926 goto err; 927 } 928 929 card = oldcard; 930 } else { 931 /* 932 * Allocate card structure. 933 */ 934 card = mmc_alloc_card(host, &mmc_type); 935 if (IS_ERR(card)) { 936 err = PTR_ERR(card); 937 goto err; 938 } 939 940 card->ocr = ocr; 941 card->type = MMC_TYPE_MMC; 942 card->rca = 1; 943 memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); 944 } 945 946 /* 947 * For native busses: set card RCA and quit open drain mode. 948 */ 949 if (!mmc_host_is_spi(host)) { 950 err = mmc_set_relative_addr(card); 951 if (err) 952 goto free_card; 953 954 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 955 } 956 957 if (!oldcard) { 958 /* 959 * Fetch CSD from card. 960 */ 961 err = mmc_send_csd(card, card->raw_csd); 962 if (err) 963 goto free_card; 964 965 err = mmc_decode_csd(card); 966 if (err) 967 goto free_card; 968 err = mmc_decode_cid(card); 969 if (err) 970 goto free_card; 971 } 972 973 /* 974 * Select card, as all following commands rely on that. 975 */ 976 if (!mmc_host_is_spi(host)) { 977 err = mmc_select_card(card); 978 if (err) 979 goto free_card; 980 } 981 982 if (!oldcard) { 983 /* 984 * Fetch and process extended CSD. 985 */ 986 987 err = mmc_get_ext_csd(card, &ext_csd); 988 if (err) 989 goto free_card; 990 err = mmc_read_ext_csd(card, ext_csd); 991 if (err) 992 goto free_card; 993 994 /* If doing byte addressing, check if required to do sector 995 * addressing. Handle the case of <2GB cards needing sector 996 * addressing. See section 8.1 JEDEC Standard JED84-A441; 997 * ocr register has bit 30 set for sector addressing. 998 */ 999 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30))) 1000 mmc_card_set_blockaddr(card); 1001 1002 /* Erase size depends on CSD and Extended CSD */ 1003 mmc_set_erase_size(card); 1004 } 1005 1006 /* 1007 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF 1008 * bit. This bit will be lost every time after a reset or power off. 1009 */ 1010 if (card->ext_csd.enhanced_area_en || 1011 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) { 1012 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1013 EXT_CSD_ERASE_GROUP_DEF, 1, 1014 card->ext_csd.generic_cmd6_time); 1015 1016 if (err && err != -EBADMSG) 1017 goto free_card; 1018 1019 if (err) { 1020 err = 0; 1021 /* 1022 * Just disable enhanced area off & sz 1023 * will try to enable ERASE_GROUP_DEF 1024 * during next time reinit 1025 */ 1026 card->ext_csd.enhanced_area_offset = -EINVAL; 1027 card->ext_csd.enhanced_area_size = -EINVAL; 1028 } else { 1029 card->ext_csd.erase_group_def = 1; 1030 /* 1031 * enable ERASE_GRP_DEF successfully. 1032 * This will affect the erase size, so 1033 * here need to reset erase size 1034 */ 1035 mmc_set_erase_size(card); 1036 } 1037 } 1038 1039 /* 1040 * Ensure eMMC user default partition is enabled 1041 */ 1042 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) { 1043 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; 1044 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG, 1045 card->ext_csd.part_config, 1046 card->ext_csd.part_time); 1047 if (err && err != -EBADMSG) 1048 goto free_card; 1049 } 1050 1051 /* 1052 * Enable power_off_notification byte in the ext_csd register 1053 */ 1054 if (card->ext_csd.rev >= 6) { 1055 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1056 EXT_CSD_POWER_OFF_NOTIFICATION, 1057 EXT_CSD_POWER_ON, 1058 card->ext_csd.generic_cmd6_time); 1059 if (err && err != -EBADMSG) 1060 goto free_card; 1061 1062 /* 1063 * The err can be -EBADMSG or 0, 1064 * so check for success and update the flag 1065 */ 1066 if (!err) 1067 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON; 1068 } 1069 1070 /* 1071 * Activate high speed (if supported) 1072 */ 1073 if (card->ext_csd.hs_max_dtr != 0) { 1074 err = 0; 1075 if (card->ext_csd.hs_max_dtr > 52000000 && 1076 host->caps2 & MMC_CAP2_HS200) 1077 err = mmc_select_hs200(card); 1078 else if (host->caps & MMC_CAP_MMC_HIGHSPEED) 1079 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1080 EXT_CSD_HS_TIMING, 1, 1081 card->ext_csd.generic_cmd6_time, 1082 true, true, true); 1083 1084 if (err && err != -EBADMSG) 1085 goto free_card; 1086 1087 if (err) { 1088 pr_warning("%s: switch to highspeed failed\n", 1089 mmc_hostname(card->host)); 1090 err = 0; 1091 } else { 1092 if (card->ext_csd.hs_max_dtr > 52000000 && 1093 host->caps2 & MMC_CAP2_HS200) { 1094 mmc_card_set_hs200(card); 1095 mmc_set_timing(card->host, 1096 MMC_TIMING_MMC_HS200); 1097 } else { 1098 mmc_card_set_highspeed(card); 1099 mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 1100 } 1101 } 1102 } 1103 1104 /* 1105 * Compute bus speed. 1106 */ 1107 max_dtr = (unsigned int)-1; 1108 1109 if (mmc_card_highspeed(card) || mmc_card_hs200(card)) { 1110 if (max_dtr > card->ext_csd.hs_max_dtr) 1111 max_dtr = card->ext_csd.hs_max_dtr; 1112 if (mmc_card_highspeed(card) && (max_dtr > 52000000)) 1113 max_dtr = 52000000; 1114 } else if (max_dtr > card->csd.max_dtr) { 1115 max_dtr = card->csd.max_dtr; 1116 } 1117 1118 mmc_set_clock(host, max_dtr); 1119 1120 /* 1121 * Indicate DDR mode (if supported). 1122 */ 1123 if (mmc_card_highspeed(card)) { 1124 if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) 1125 && (host->caps & MMC_CAP_1_8V_DDR)) 1126 ddr = MMC_1_8V_DDR_MODE; 1127 else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) 1128 && (host->caps & MMC_CAP_1_2V_DDR)) 1129 ddr = MMC_1_2V_DDR_MODE; 1130 } 1131 1132 /* 1133 * Indicate HS200 SDR mode (if supported). 1134 */ 1135 if (mmc_card_hs200(card)) { 1136 u32 ext_csd_bits; 1137 u32 bus_width = card->host->ios.bus_width; 1138 1139 /* 1140 * For devices supporting HS200 mode, the bus width has 1141 * to be set before executing the tuning function. If 1142 * set before tuning, then device will respond with CRC 1143 * errors for responses on CMD line. So for HS200 the 1144 * sequence will be 1145 * 1. set bus width 4bit / 8 bit (1 bit not supported) 1146 * 2. switch to HS200 mode 1147 * 3. set the clock to > 52Mhz <=200MHz and 1148 * 4. execute tuning for HS200 1149 */ 1150 if ((host->caps2 & MMC_CAP2_HS200) && 1151 card->host->ops->execute_tuning) { 1152 mmc_host_clk_hold(card->host); 1153 err = card->host->ops->execute_tuning(card->host, 1154 MMC_SEND_TUNING_BLOCK_HS200); 1155 mmc_host_clk_release(card->host); 1156 } 1157 if (err) { 1158 pr_warning("%s: tuning execution failed\n", 1159 mmc_hostname(card->host)); 1160 goto err; 1161 } 1162 1163 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 1164 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4; 1165 err = mmc_select_powerclass(card, ext_csd_bits); 1166 if (err) 1167 pr_warning("%s: power class selection to bus width %d" 1168 " failed\n", mmc_hostname(card->host), 1169 1 << bus_width); 1170 } 1171 1172 /* 1173 * Activate wide bus and DDR (if supported). 1174 */ 1175 if (!mmc_card_hs200(card) && 1176 (card->csd.mmca_vsn >= CSD_SPEC_VER_4) && 1177 (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) { 1178 static unsigned ext_csd_bits[][2] = { 1179 { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 }, 1180 { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 }, 1181 { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 }, 1182 }; 1183 static unsigned bus_widths[] = { 1184 MMC_BUS_WIDTH_8, 1185 MMC_BUS_WIDTH_4, 1186 MMC_BUS_WIDTH_1 1187 }; 1188 unsigned idx, bus_width = 0; 1189 1190 if (host->caps & MMC_CAP_8_BIT_DATA) 1191 idx = 0; 1192 else 1193 idx = 1; 1194 for (; idx < ARRAY_SIZE(bus_widths); idx++) { 1195 bus_width = bus_widths[idx]; 1196 if (bus_width == MMC_BUS_WIDTH_1) 1197 ddr = 0; /* no DDR for 1-bit width */ 1198 err = mmc_select_powerclass(card, ext_csd_bits[idx][0]); 1199 if (err) 1200 pr_warning("%s: power class selection to " 1201 "bus width %d failed\n", 1202 mmc_hostname(card->host), 1203 1 << bus_width); 1204 1205 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1206 EXT_CSD_BUS_WIDTH, 1207 ext_csd_bits[idx][0], 1208 card->ext_csd.generic_cmd6_time); 1209 if (!err) { 1210 mmc_set_bus_width(card->host, bus_width); 1211 1212 /* 1213 * If controller can't handle bus width test, 1214 * compare ext_csd previously read in 1 bit mode 1215 * against ext_csd at new bus width 1216 */ 1217 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) 1218 err = mmc_compare_ext_csds(card, 1219 bus_width); 1220 else 1221 err = mmc_bus_test(card, bus_width); 1222 if (!err) 1223 break; 1224 } 1225 } 1226 1227 if (!err && ddr) { 1228 err = mmc_select_powerclass(card, ext_csd_bits[idx][1]); 1229 if (err) 1230 pr_warning("%s: power class selection to " 1231 "bus width %d ddr %d failed\n", 1232 mmc_hostname(card->host), 1233 1 << bus_width, ddr); 1234 1235 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1236 EXT_CSD_BUS_WIDTH, 1237 ext_csd_bits[idx][1], 1238 card->ext_csd.generic_cmd6_time); 1239 } 1240 if (err) { 1241 pr_warning("%s: switch to bus width %d ddr %d " 1242 "failed\n", mmc_hostname(card->host), 1243 1 << bus_width, ddr); 1244 goto free_card; 1245 } else if (ddr) { 1246 /* 1247 * eMMC cards can support 3.3V to 1.2V i/o (vccq) 1248 * signaling. 1249 * 1250 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq. 1251 * 1252 * 1.8V vccq at 3.3V core voltage (vcc) is not required 1253 * in the JEDEC spec for DDR. 1254 * 1255 * Do not force change in vccq since we are obviously 1256 * working and no change to vccq is needed. 1257 * 1258 * WARNING: eMMC rules are NOT the same as SD DDR 1259 */ 1260 if (ddr == MMC_1_2V_DDR_MODE) { 1261 err = __mmc_set_signal_voltage(host, 1262 MMC_SIGNAL_VOLTAGE_120); 1263 if (err) 1264 goto err; 1265 } 1266 mmc_card_set_ddr_mode(card); 1267 mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50); 1268 mmc_set_bus_width(card->host, bus_width); 1269 } 1270 } 1271 1272 /* 1273 * Enable HPI feature (if supported) 1274 */ 1275 if (card->ext_csd.hpi) { 1276 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1277 EXT_CSD_HPI_MGMT, 1, 1278 card->ext_csd.generic_cmd6_time); 1279 if (err && err != -EBADMSG) 1280 goto free_card; 1281 if (err) { 1282 pr_warning("%s: Enabling HPI failed\n", 1283 mmc_hostname(card->host)); 1284 err = 0; 1285 } else 1286 card->ext_csd.hpi_en = 1; 1287 } 1288 1289 /* 1290 * If cache size is higher than 0, this indicates 1291 * the existence of cache and it can be turned on. 1292 */ 1293 if (card->ext_csd.cache_size > 0) { 1294 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1295 EXT_CSD_CACHE_CTRL, 1, 1296 card->ext_csd.generic_cmd6_time); 1297 if (err && err != -EBADMSG) 1298 goto free_card; 1299 1300 /* 1301 * Only if no error, cache is turned on successfully. 1302 */ 1303 if (err) { 1304 pr_warning("%s: Cache is supported, " 1305 "but failed to turn on (%d)\n", 1306 mmc_hostname(card->host), err); 1307 card->ext_csd.cache_ctrl = 0; 1308 err = 0; 1309 } else { 1310 card->ext_csd.cache_ctrl = 1; 1311 } 1312 } 1313 1314 /* 1315 * The mandatory minimum values are defined for packed command. 1316 * read: 5, write: 3 1317 */ 1318 if (card->ext_csd.max_packed_writes >= 3 && 1319 card->ext_csd.max_packed_reads >= 5 && 1320 host->caps2 & MMC_CAP2_PACKED_CMD) { 1321 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1322 EXT_CSD_EXP_EVENTS_CTRL, 1323 EXT_CSD_PACKED_EVENT_EN, 1324 card->ext_csd.generic_cmd6_time); 1325 if (err && err != -EBADMSG) 1326 goto free_card; 1327 if (err) { 1328 pr_warn("%s: Enabling packed event failed\n", 1329 mmc_hostname(card->host)); 1330 card->ext_csd.packed_event_en = 0; 1331 err = 0; 1332 } else { 1333 card->ext_csd.packed_event_en = 1; 1334 } 1335 } 1336 1337 if (!oldcard) 1338 host->card = card; 1339 1340 mmc_free_ext_csd(ext_csd); 1341 return 0; 1342 1343 free_card: 1344 if (!oldcard) 1345 mmc_remove_card(card); 1346 err: 1347 mmc_free_ext_csd(ext_csd); 1348 1349 return err; 1350 } 1351 1352 static int mmc_can_sleep(struct mmc_card *card) 1353 { 1354 return (card && card->ext_csd.rev >= 3); 1355 } 1356 1357 static int mmc_sleep(struct mmc_host *host) 1358 { 1359 struct mmc_command cmd = {0}; 1360 struct mmc_card *card = host->card; 1361 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000); 1362 int err; 1363 1364 err = mmc_deselect_cards(host); 1365 if (err) 1366 return err; 1367 1368 cmd.opcode = MMC_SLEEP_AWAKE; 1369 cmd.arg = card->rca << 16; 1370 cmd.arg |= 1 << 15; 1371 1372 /* 1373 * If the max_busy_timeout of the host is specified, validate it against 1374 * the sleep cmd timeout. A failure means we need to prevent the host 1375 * from doing hw busy detection, which is done by converting to a R1 1376 * response instead of a R1B. 1377 */ 1378 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) { 1379 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1380 } else { 1381 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 1382 cmd.busy_timeout = timeout_ms; 1383 } 1384 1385 err = mmc_wait_for_cmd(host, &cmd, 0); 1386 if (err) 1387 return err; 1388 1389 /* 1390 * If the host does not wait while the card signals busy, then we will 1391 * will have to wait the sleep/awake timeout. Note, we cannot use the 1392 * SEND_STATUS command to poll the status because that command (and most 1393 * others) is invalid while the card sleeps. 1394 */ 1395 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY)) 1396 mmc_delay(timeout_ms); 1397 1398 return err; 1399 } 1400 1401 static int mmc_can_poweroff_notify(const struct mmc_card *card) 1402 { 1403 return card && 1404 mmc_card_mmc(card) && 1405 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON); 1406 } 1407 1408 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type) 1409 { 1410 unsigned int timeout = card->ext_csd.generic_cmd6_time; 1411 int err; 1412 1413 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */ 1414 if (notify_type == EXT_CSD_POWER_OFF_LONG) 1415 timeout = card->ext_csd.power_off_longtime; 1416 1417 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1418 EXT_CSD_POWER_OFF_NOTIFICATION, 1419 notify_type, timeout, true, false, false); 1420 if (err) 1421 pr_err("%s: Power Off Notification timed out, %u\n", 1422 mmc_hostname(card->host), timeout); 1423 1424 /* Disable the power off notification after the switch operation. */ 1425 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION; 1426 1427 return err; 1428 } 1429 1430 /* 1431 * Host is being removed. Free up the current card. 1432 */ 1433 static void mmc_remove(struct mmc_host *host) 1434 { 1435 BUG_ON(!host); 1436 BUG_ON(!host->card); 1437 1438 mmc_remove_card(host->card); 1439 host->card = NULL; 1440 } 1441 1442 /* 1443 * Card detection - card is alive. 1444 */ 1445 static int mmc_alive(struct mmc_host *host) 1446 { 1447 return mmc_send_status(host->card, NULL); 1448 } 1449 1450 /* 1451 * Card detection callback from host. 1452 */ 1453 static void mmc_detect(struct mmc_host *host) 1454 { 1455 int err; 1456 1457 BUG_ON(!host); 1458 BUG_ON(!host->card); 1459 1460 mmc_get_card(host->card); 1461 1462 /* 1463 * Just check if our card has been removed. 1464 */ 1465 err = _mmc_detect_card_removed(host); 1466 1467 mmc_put_card(host->card); 1468 1469 if (err) { 1470 mmc_remove(host); 1471 1472 mmc_claim_host(host); 1473 mmc_detach_bus(host); 1474 mmc_power_off(host); 1475 mmc_release_host(host); 1476 } 1477 } 1478 1479 static int _mmc_suspend(struct mmc_host *host, bool is_suspend) 1480 { 1481 int err = 0; 1482 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT : 1483 EXT_CSD_POWER_OFF_LONG; 1484 1485 BUG_ON(!host); 1486 BUG_ON(!host->card); 1487 1488 mmc_claim_host(host); 1489 1490 if (mmc_card_suspended(host->card)) 1491 goto out; 1492 1493 if (mmc_card_doing_bkops(host->card)) { 1494 err = mmc_stop_bkops(host->card); 1495 if (err) 1496 goto out; 1497 } 1498 1499 err = mmc_flush_cache(host->card); 1500 if (err) 1501 goto out; 1502 1503 if (mmc_can_poweroff_notify(host->card) && 1504 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend)) 1505 err = mmc_poweroff_notify(host->card, notify_type); 1506 else if (mmc_can_sleep(host->card)) 1507 err = mmc_sleep(host); 1508 else if (!mmc_host_is_spi(host)) 1509 err = mmc_deselect_cards(host); 1510 host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200); 1511 1512 if (!err) { 1513 mmc_power_off(host); 1514 mmc_card_set_suspended(host->card); 1515 } 1516 out: 1517 mmc_release_host(host); 1518 return err; 1519 } 1520 1521 /* 1522 * Suspend callback 1523 */ 1524 static int mmc_suspend(struct mmc_host *host) 1525 { 1526 int err; 1527 1528 err = _mmc_suspend(host, true); 1529 if (!err) { 1530 pm_runtime_disable(&host->card->dev); 1531 pm_runtime_set_suspended(&host->card->dev); 1532 } 1533 1534 return err; 1535 } 1536 1537 /* 1538 * This function tries to determine if the same card is still present 1539 * and, if so, restore all state to it. 1540 */ 1541 static int _mmc_resume(struct mmc_host *host) 1542 { 1543 int err = 0; 1544 1545 BUG_ON(!host); 1546 BUG_ON(!host->card); 1547 1548 mmc_claim_host(host); 1549 1550 if (!mmc_card_suspended(host->card)) 1551 goto out; 1552 1553 mmc_power_up(host, host->card->ocr); 1554 err = mmc_init_card(host, host->card->ocr, host->card); 1555 mmc_card_clr_suspended(host->card); 1556 1557 out: 1558 mmc_release_host(host); 1559 return err; 1560 } 1561 1562 /* 1563 * Shutdown callback 1564 */ 1565 static int mmc_shutdown(struct mmc_host *host) 1566 { 1567 int err = 0; 1568 1569 /* 1570 * In a specific case for poweroff notify, we need to resume the card 1571 * before we can shutdown it properly. 1572 */ 1573 if (mmc_can_poweroff_notify(host->card) && 1574 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE)) 1575 err = _mmc_resume(host); 1576 1577 if (!err) 1578 err = _mmc_suspend(host, false); 1579 1580 return err; 1581 } 1582 1583 /* 1584 * Callback for resume. 1585 */ 1586 static int mmc_resume(struct mmc_host *host) 1587 { 1588 int err = 0; 1589 1590 if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) { 1591 err = _mmc_resume(host); 1592 pm_runtime_set_active(&host->card->dev); 1593 pm_runtime_mark_last_busy(&host->card->dev); 1594 } 1595 pm_runtime_enable(&host->card->dev); 1596 1597 return err; 1598 } 1599 1600 /* 1601 * Callback for runtime_suspend. 1602 */ 1603 static int mmc_runtime_suspend(struct mmc_host *host) 1604 { 1605 int err; 1606 1607 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM)) 1608 return 0; 1609 1610 err = _mmc_suspend(host, true); 1611 if (err) 1612 pr_err("%s: error %d doing aggessive suspend\n", 1613 mmc_hostname(host), err); 1614 1615 return err; 1616 } 1617 1618 /* 1619 * Callback for runtime_resume. 1620 */ 1621 static int mmc_runtime_resume(struct mmc_host *host) 1622 { 1623 int err; 1624 1625 if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME))) 1626 return 0; 1627 1628 err = _mmc_resume(host); 1629 if (err) 1630 pr_err("%s: error %d doing aggessive resume\n", 1631 mmc_hostname(host), err); 1632 1633 return 0; 1634 } 1635 1636 static int mmc_power_restore(struct mmc_host *host) 1637 { 1638 int ret; 1639 1640 host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200); 1641 mmc_claim_host(host); 1642 ret = mmc_init_card(host, host->card->ocr, host->card); 1643 mmc_release_host(host); 1644 1645 return ret; 1646 } 1647 1648 static const struct mmc_bus_ops mmc_ops = { 1649 .remove = mmc_remove, 1650 .detect = mmc_detect, 1651 .suspend = mmc_suspend, 1652 .resume = mmc_resume, 1653 .runtime_suspend = mmc_runtime_suspend, 1654 .runtime_resume = mmc_runtime_resume, 1655 .power_restore = mmc_power_restore, 1656 .alive = mmc_alive, 1657 .shutdown = mmc_shutdown, 1658 }; 1659 1660 /* 1661 * Starting point for MMC card init. 1662 */ 1663 int mmc_attach_mmc(struct mmc_host *host) 1664 { 1665 int err; 1666 u32 ocr, rocr; 1667 1668 BUG_ON(!host); 1669 WARN_ON(!host->claimed); 1670 1671 /* Set correct bus mode for MMC before attempting attach */ 1672 if (!mmc_host_is_spi(host)) 1673 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 1674 1675 err = mmc_send_op_cond(host, 0, &ocr); 1676 if (err) 1677 return err; 1678 1679 mmc_attach_bus(host, &mmc_ops); 1680 if (host->ocr_avail_mmc) 1681 host->ocr_avail = host->ocr_avail_mmc; 1682 1683 /* 1684 * We need to get OCR a different way for SPI. 1685 */ 1686 if (mmc_host_is_spi(host)) { 1687 err = mmc_spi_read_ocr(host, 1, &ocr); 1688 if (err) 1689 goto err; 1690 } 1691 1692 rocr = mmc_select_voltage(host, ocr); 1693 1694 /* 1695 * Can we support the voltage of the card? 1696 */ 1697 if (!rocr) { 1698 err = -EINVAL; 1699 goto err; 1700 } 1701 1702 /* 1703 * Detect and init the card. 1704 */ 1705 err = mmc_init_card(host, rocr, NULL); 1706 if (err) 1707 goto err; 1708 1709 mmc_release_host(host); 1710 err = mmc_add_card(host->card); 1711 mmc_claim_host(host); 1712 if (err) 1713 goto remove_card; 1714 1715 return 0; 1716 1717 remove_card: 1718 mmc_release_host(host); 1719 mmc_remove_card(host->card); 1720 mmc_claim_host(host); 1721 host->card = NULL; 1722 err: 1723 mmc_detach_bus(host); 1724 1725 pr_err("%s: error %d whilst initialising MMC card\n", 1726 mmc_hostname(host), err); 1727 1728 return err; 1729 } 1730