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