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