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 16 #include <linux/mmc/host.h> 17 #include <linux/mmc/card.h> 18 #include <linux/mmc/mmc.h> 19 20 #include "core.h" 21 #include "bus.h" 22 #include "mmc_ops.h" 23 #include "sd_ops.h" 24 25 static const unsigned int tran_exp[] = { 26 10000, 100000, 1000000, 10000000, 27 0, 0, 0, 0 28 }; 29 30 static const unsigned char tran_mant[] = { 31 0, 10, 12, 13, 15, 20, 25, 30, 32 35, 40, 45, 50, 55, 60, 70, 80, 33 }; 34 35 static const unsigned int tacc_exp[] = { 36 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 37 }; 38 39 static const unsigned int tacc_mant[] = { 40 0, 10, 12, 13, 15, 20, 25, 30, 41 35, 40, 45, 50, 55, 60, 70, 80, 42 }; 43 44 #define UNSTUFF_BITS(resp,start,size) \ 45 ({ \ 46 const int __size = size; \ 47 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \ 48 const int __off = 3 - ((start) / 32); \ 49 const int __shft = (start) & 31; \ 50 u32 __res; \ 51 \ 52 __res = resp[__off] >> __shft; \ 53 if (__size + __shft > 32) \ 54 __res |= resp[__off-1] << ((32 - __shft) % 32); \ 55 __res & __mask; \ 56 }) 57 58 /* 59 * Given the decoded CSD structure, decode the raw CID to our CID structure. 60 */ 61 static int mmc_decode_cid(struct mmc_card *card) 62 { 63 u32 *resp = card->raw_cid; 64 65 /* 66 * The selection of the format here is based upon published 67 * specs from sandisk and from what people have reported. 68 */ 69 switch (card->csd.mmca_vsn) { 70 case 0: /* MMC v1.0 - v1.2 */ 71 case 1: /* MMC v1.4 */ 72 card->cid.manfid = UNSTUFF_BITS(resp, 104, 24); 73 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 74 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 75 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 76 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 77 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 78 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 79 card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8); 80 card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4); 81 card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4); 82 card->cid.serial = UNSTUFF_BITS(resp, 16, 24); 83 card->cid.month = UNSTUFF_BITS(resp, 12, 4); 84 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 85 break; 86 87 case 2: /* MMC v2.0 - v2.2 */ 88 case 3: /* MMC v3.1 - v3.3 */ 89 case 4: /* MMC v4 */ 90 card->cid.manfid = UNSTUFF_BITS(resp, 120, 8); 91 card->cid.oemid = UNSTUFF_BITS(resp, 104, 16); 92 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 93 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 94 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 95 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 96 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 97 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 98 card->cid.serial = UNSTUFF_BITS(resp, 16, 32); 99 card->cid.month = UNSTUFF_BITS(resp, 12, 4); 100 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 101 break; 102 103 default: 104 pr_err("%s: card has unknown MMCA version %d\n", 105 mmc_hostname(card->host), card->csd.mmca_vsn); 106 return -EINVAL; 107 } 108 109 return 0; 110 } 111 112 static void mmc_set_erase_size(struct mmc_card *card) 113 { 114 if (card->ext_csd.erase_group_def & 1) 115 card->erase_size = card->ext_csd.hc_erase_size; 116 else 117 card->erase_size = card->csd.erase_size; 118 119 mmc_init_erase(card); 120 } 121 122 /* 123 * Given a 128-bit response, decode to our card CSD structure. 124 */ 125 static int mmc_decode_csd(struct mmc_card *card) 126 { 127 struct mmc_csd *csd = &card->csd; 128 unsigned int e, m, a, b; 129 u32 *resp = card->raw_csd; 130 131 /* 132 * We only understand CSD structure v1.1 and v1.2. 133 * v1.2 has extra information in bits 15, 11 and 10. 134 * We also support eMMC v4.4 & v4.41. 135 */ 136 csd->structure = UNSTUFF_BITS(resp, 126, 2); 137 if (csd->structure == 0) { 138 pr_err("%s: unrecognised CSD structure version %d\n", 139 mmc_hostname(card->host), csd->structure); 140 return -EINVAL; 141 } 142 143 csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4); 144 m = UNSTUFF_BITS(resp, 115, 4); 145 e = UNSTUFF_BITS(resp, 112, 3); 146 csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; 147 csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100; 148 149 m = UNSTUFF_BITS(resp, 99, 4); 150 e = UNSTUFF_BITS(resp, 96, 3); 151 csd->max_dtr = tran_exp[e] * tran_mant[m]; 152 csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); 153 154 e = UNSTUFF_BITS(resp, 47, 3); 155 m = UNSTUFF_BITS(resp, 62, 12); 156 csd->capacity = (1 + m) << (e + 2); 157 158 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4); 159 csd->read_partial = UNSTUFF_BITS(resp, 79, 1); 160 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1); 161 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1); 162 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); 163 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); 164 csd->write_partial = UNSTUFF_BITS(resp, 21, 1); 165 166 if (csd->write_blkbits >= 9) { 167 a = UNSTUFF_BITS(resp, 42, 5); 168 b = UNSTUFF_BITS(resp, 37, 5); 169 csd->erase_size = (a + 1) * (b + 1); 170 csd->erase_size <<= csd->write_blkbits - 9; 171 } 172 173 return 0; 174 } 175 176 /* 177 * Read extended CSD. 178 */ 179 static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd) 180 { 181 int err; 182 u8 *ext_csd; 183 184 BUG_ON(!card); 185 BUG_ON(!new_ext_csd); 186 187 *new_ext_csd = NULL; 188 189 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 190 return 0; 191 192 /* 193 * As the ext_csd is so large and mostly unused, we don't store the 194 * raw block in mmc_card. 195 */ 196 ext_csd = kmalloc(512, GFP_KERNEL); 197 if (!ext_csd) { 198 pr_err("%s: could not allocate a buffer to " 199 "receive the ext_csd.\n", mmc_hostname(card->host)); 200 return -ENOMEM; 201 } 202 203 err = mmc_send_ext_csd(card, ext_csd); 204 if (err) { 205 kfree(ext_csd); 206 *new_ext_csd = NULL; 207 208 /* If the host or the card can't do the switch, 209 * fail more gracefully. */ 210 if ((err != -EINVAL) 211 && (err != -ENOSYS) 212 && (err != -EFAULT)) 213 return err; 214 215 /* 216 * High capacity cards should have this "magic" size 217 * stored in their CSD. 218 */ 219 if (card->csd.capacity == (4096 * 512)) { 220 pr_err("%s: unable to read EXT_CSD " 221 "on a possible high capacity card. " 222 "Card will be ignored.\n", 223 mmc_hostname(card->host)); 224 } else { 225 pr_warning("%s: unable to read " 226 "EXT_CSD, performance might " 227 "suffer.\n", 228 mmc_hostname(card->host)); 229 err = 0; 230 } 231 } else 232 *new_ext_csd = ext_csd; 233 234 return err; 235 } 236 237 /* 238 * Decode extended CSD. 239 */ 240 static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) 241 { 242 int err = 0, idx; 243 unsigned int part_size; 244 u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0; 245 246 BUG_ON(!card); 247 248 if (!ext_csd) 249 return 0; 250 251 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */ 252 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE]; 253 if (card->csd.structure == 3) { 254 if (card->ext_csd.raw_ext_csd_structure > 2) { 255 pr_err("%s: unrecognised EXT_CSD structure " 256 "version %d\n", mmc_hostname(card->host), 257 card->ext_csd.raw_ext_csd_structure); 258 err = -EINVAL; 259 goto out; 260 } 261 } 262 263 card->ext_csd.rev = ext_csd[EXT_CSD_REV]; 264 if (card->ext_csd.rev > 6) { 265 pr_err("%s: unrecognised EXT_CSD revision %d\n", 266 mmc_hostname(card->host), card->ext_csd.rev); 267 err = -EINVAL; 268 goto out; 269 } 270 271 card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0]; 272 card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1]; 273 card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2]; 274 card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3]; 275 if (card->ext_csd.rev >= 2) { 276 card->ext_csd.sectors = 277 ext_csd[EXT_CSD_SEC_CNT + 0] << 0 | 278 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 | 279 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 | 280 ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 281 282 /* Cards with density > 2GiB are sector addressed */ 283 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512) 284 mmc_card_set_blockaddr(card); 285 } 286 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE]; 287 switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) { 288 case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 | 289 EXT_CSD_CARD_TYPE_26: 290 card->ext_csd.hs_max_dtr = 52000000; 291 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52; 292 break; 293 case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 | 294 EXT_CSD_CARD_TYPE_26: 295 card->ext_csd.hs_max_dtr = 52000000; 296 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V; 297 break; 298 case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 | 299 EXT_CSD_CARD_TYPE_26: 300 card->ext_csd.hs_max_dtr = 52000000; 301 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V; 302 break; 303 case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26: 304 card->ext_csd.hs_max_dtr = 52000000; 305 break; 306 case EXT_CSD_CARD_TYPE_26: 307 card->ext_csd.hs_max_dtr = 26000000; 308 break; 309 default: 310 /* MMC v4 spec says this cannot happen */ 311 pr_warning("%s: card is mmc v4 but doesn't " 312 "support any high-speed modes.\n", 313 mmc_hostname(card->host)); 314 } 315 316 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT]; 317 card->ext_csd.raw_erase_timeout_mult = 318 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 319 card->ext_csd.raw_hc_erase_grp_size = 320 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 321 if (card->ext_csd.rev >= 3) { 322 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT]; 323 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG]; 324 325 /* EXT_CSD value is in units of 10ms, but we store in ms */ 326 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME]; 327 328 /* Sleep / awake timeout in 100ns units */ 329 if (sa_shift > 0 && sa_shift <= 0x17) 330 card->ext_csd.sa_timeout = 331 1 << ext_csd[EXT_CSD_S_A_TIMEOUT]; 332 card->ext_csd.erase_group_def = 333 ext_csd[EXT_CSD_ERASE_GROUP_DEF]; 334 card->ext_csd.hc_erase_timeout = 300 * 335 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 336 card->ext_csd.hc_erase_size = 337 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10; 338 339 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C]; 340 341 /* 342 * There are two boot regions of equal size, defined in 343 * multiples of 128K. 344 */ 345 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) { 346 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) { 347 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17; 348 mmc_part_add(card, part_size, 349 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx, 350 "boot%d", idx, true); 351 } 352 } 353 } 354 355 card->ext_csd.raw_hc_erase_gap_size = 356 ext_csd[EXT_CSD_PARTITION_ATTRIBUTE]; 357 card->ext_csd.raw_sec_trim_mult = 358 ext_csd[EXT_CSD_SEC_TRIM_MULT]; 359 card->ext_csd.raw_sec_erase_mult = 360 ext_csd[EXT_CSD_SEC_ERASE_MULT]; 361 card->ext_csd.raw_sec_feature_support = 362 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 363 card->ext_csd.raw_trim_mult = 364 ext_csd[EXT_CSD_TRIM_MULT]; 365 if (card->ext_csd.rev >= 4) { 366 /* 367 * Enhanced area feature support -- check whether the eMMC 368 * card has the Enhanced area enabled. If so, export enhanced 369 * area offset and size to user by adding sysfs interface. 370 */ 371 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT]; 372 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) && 373 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) { 374 hc_erase_grp_sz = 375 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 376 hc_wp_grp_sz = 377 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 378 379 card->ext_csd.enhanced_area_en = 1; 380 /* 381 * calculate the enhanced data area offset, in bytes 382 */ 383 card->ext_csd.enhanced_area_offset = 384 (ext_csd[139] << 24) + (ext_csd[138] << 16) + 385 (ext_csd[137] << 8) + ext_csd[136]; 386 if (mmc_card_blockaddr(card)) 387 card->ext_csd.enhanced_area_offset <<= 9; 388 /* 389 * calculate the enhanced data area size, in kilobytes 390 */ 391 card->ext_csd.enhanced_area_size = 392 (ext_csd[142] << 16) + (ext_csd[141] << 8) + 393 ext_csd[140]; 394 card->ext_csd.enhanced_area_size *= 395 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz); 396 card->ext_csd.enhanced_area_size <<= 9; 397 } else { 398 /* 399 * If the enhanced area is not enabled, disable these 400 * device attributes. 401 */ 402 card->ext_csd.enhanced_area_offset = -EINVAL; 403 card->ext_csd.enhanced_area_size = -EINVAL; 404 } 405 406 /* 407 * General purpose partition feature support -- 408 * If ext_csd has the size of general purpose partitions, 409 * set size, part_cfg, partition name in mmc_part. 410 */ 411 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] & 412 EXT_CSD_PART_SUPPORT_PART_EN) { 413 if (card->ext_csd.enhanced_area_en != 1) { 414 hc_erase_grp_sz = 415 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 416 hc_wp_grp_sz = 417 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 418 419 card->ext_csd.enhanced_area_en = 1; 420 } 421 422 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) { 423 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] && 424 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] && 425 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]) 426 continue; 427 part_size = 428 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2] 429 << 16) + 430 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] 431 << 8) + 432 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3]; 433 part_size *= (size_t)(hc_erase_grp_sz * 434 hc_wp_grp_sz); 435 mmc_part_add(card, part_size << 19, 436 EXT_CSD_PART_CONFIG_ACC_GP0 + idx, 437 "gp%d", idx, false); 438 } 439 } 440 card->ext_csd.sec_trim_mult = 441 ext_csd[EXT_CSD_SEC_TRIM_MULT]; 442 card->ext_csd.sec_erase_mult = 443 ext_csd[EXT_CSD_SEC_ERASE_MULT]; 444 card->ext_csd.sec_feature_support = 445 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 446 card->ext_csd.trim_timeout = 300 * 447 ext_csd[EXT_CSD_TRIM_MULT]; 448 } 449 450 if (card->ext_csd.rev >= 5) { 451 /* check whether the eMMC card supports HPI */ 452 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) { 453 card->ext_csd.hpi = 1; 454 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2) 455 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION; 456 else 457 card->ext_csd.hpi_cmd = MMC_SEND_STATUS; 458 /* 459 * Indicate the maximum timeout to close 460 * a command interrupted by HPI 461 */ 462 card->ext_csd.out_of_int_time = 463 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10; 464 } 465 466 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM]; 467 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION]; 468 } 469 470 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT]; 471 if (ext_csd[EXT_CSD_ERASED_MEM_CONT]) 472 card->erased_byte = 0xFF; 473 else 474 card->erased_byte = 0x0; 475 476 /* eMMC v4.5 or later */ 477 if (card->ext_csd.rev >= 6) { 478 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE; 479 480 card->ext_csd.generic_cmd6_time = 10 * 481 ext_csd[EXT_CSD_GENERIC_CMD6_TIME]; 482 card->ext_csd.power_off_longtime = 10 * 483 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME]; 484 485 card->ext_csd.cache_size = 486 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 | 487 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 | 488 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 | 489 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24; 490 } 491 492 out: 493 return err; 494 } 495 496 static inline void mmc_free_ext_csd(u8 *ext_csd) 497 { 498 kfree(ext_csd); 499 } 500 501 502 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width) 503 { 504 u8 *bw_ext_csd; 505 int err; 506 507 if (bus_width == MMC_BUS_WIDTH_1) 508 return 0; 509 510 err = mmc_get_ext_csd(card, &bw_ext_csd); 511 512 if (err || bw_ext_csd == NULL) { 513 if (bus_width != MMC_BUS_WIDTH_1) 514 err = -EINVAL; 515 goto out; 516 } 517 518 if (bus_width == MMC_BUS_WIDTH_1) 519 goto out; 520 521 /* only compare read only fields */ 522 err = (!(card->ext_csd.raw_partition_support == 523 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) && 524 (card->ext_csd.raw_erased_mem_count == 525 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) && 526 (card->ext_csd.rev == 527 bw_ext_csd[EXT_CSD_REV]) && 528 (card->ext_csd.raw_ext_csd_structure == 529 bw_ext_csd[EXT_CSD_STRUCTURE]) && 530 (card->ext_csd.raw_card_type == 531 bw_ext_csd[EXT_CSD_CARD_TYPE]) && 532 (card->ext_csd.raw_s_a_timeout == 533 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) && 534 (card->ext_csd.raw_hc_erase_gap_size == 535 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) && 536 (card->ext_csd.raw_erase_timeout_mult == 537 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) && 538 (card->ext_csd.raw_hc_erase_grp_size == 539 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) && 540 (card->ext_csd.raw_sec_trim_mult == 541 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) && 542 (card->ext_csd.raw_sec_erase_mult == 543 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) && 544 (card->ext_csd.raw_sec_feature_support == 545 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) && 546 (card->ext_csd.raw_trim_mult == 547 bw_ext_csd[EXT_CSD_TRIM_MULT]) && 548 (card->ext_csd.raw_sectors[0] == 549 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) && 550 (card->ext_csd.raw_sectors[1] == 551 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) && 552 (card->ext_csd.raw_sectors[2] == 553 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) && 554 (card->ext_csd.raw_sectors[3] == 555 bw_ext_csd[EXT_CSD_SEC_CNT + 3])); 556 if (err) 557 err = -EINVAL; 558 559 out: 560 mmc_free_ext_csd(bw_ext_csd); 561 return err; 562 } 563 564 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], 565 card->raw_cid[2], card->raw_cid[3]); 566 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], 567 card->raw_csd[2], card->raw_csd[3]); 568 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); 569 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); 570 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); 571 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev); 572 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); 573 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid); 574 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name); 575 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid); 576 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial); 577 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n", 578 card->ext_csd.enhanced_area_offset); 579 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size); 580 581 static struct attribute *mmc_std_attrs[] = { 582 &dev_attr_cid.attr, 583 &dev_attr_csd.attr, 584 &dev_attr_date.attr, 585 &dev_attr_erase_size.attr, 586 &dev_attr_preferred_erase_size.attr, 587 &dev_attr_fwrev.attr, 588 &dev_attr_hwrev.attr, 589 &dev_attr_manfid.attr, 590 &dev_attr_name.attr, 591 &dev_attr_oemid.attr, 592 &dev_attr_serial.attr, 593 &dev_attr_enhanced_area_offset.attr, 594 &dev_attr_enhanced_area_size.attr, 595 NULL, 596 }; 597 598 static struct attribute_group mmc_std_attr_group = { 599 .attrs = mmc_std_attrs, 600 }; 601 602 static const struct attribute_group *mmc_attr_groups[] = { 603 &mmc_std_attr_group, 604 NULL, 605 }; 606 607 static struct device_type mmc_type = { 608 .groups = mmc_attr_groups, 609 }; 610 611 /* 612 * Select the PowerClass for the current bus width 613 * If power class is defined for 4/8 bit bus in the 614 * extended CSD register, select it by executing the 615 * mmc_switch command. 616 */ 617 static int mmc_select_powerclass(struct mmc_card *card, 618 unsigned int bus_width, u8 *ext_csd) 619 { 620 int err = 0; 621 unsigned int pwrclass_val; 622 unsigned int index = 0; 623 struct mmc_host *host; 624 625 BUG_ON(!card); 626 627 host = card->host; 628 BUG_ON(!host); 629 630 if (ext_csd == NULL) 631 return 0; 632 633 /* Power class selection is supported for versions >= 4.0 */ 634 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 635 return 0; 636 637 /* Power class values are defined only for 4/8 bit bus */ 638 if (bus_width == EXT_CSD_BUS_WIDTH_1) 639 return 0; 640 641 switch (1 << host->ios.vdd) { 642 case MMC_VDD_165_195: 643 if (host->ios.clock <= 26000000) 644 index = EXT_CSD_PWR_CL_26_195; 645 else if (host->ios.clock <= 52000000) 646 index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 647 EXT_CSD_PWR_CL_52_195 : 648 EXT_CSD_PWR_CL_DDR_52_195; 649 else if (host->ios.clock <= 200000000) 650 index = EXT_CSD_PWR_CL_200_195; 651 break; 652 case MMC_VDD_32_33: 653 case MMC_VDD_33_34: 654 case MMC_VDD_34_35: 655 case MMC_VDD_35_36: 656 if (host->ios.clock <= 26000000) 657 index = EXT_CSD_PWR_CL_26_360; 658 else if (host->ios.clock <= 52000000) 659 index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 660 EXT_CSD_PWR_CL_52_360 : 661 EXT_CSD_PWR_CL_DDR_52_360; 662 else if (host->ios.clock <= 200000000) 663 index = EXT_CSD_PWR_CL_200_360; 664 break; 665 default: 666 pr_warning("%s: Voltage range not supported " 667 "for power class.\n", mmc_hostname(host)); 668 return -EINVAL; 669 } 670 671 pwrclass_val = ext_csd[index]; 672 673 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8)) 674 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >> 675 EXT_CSD_PWR_CL_8BIT_SHIFT; 676 else 677 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >> 678 EXT_CSD_PWR_CL_4BIT_SHIFT; 679 680 /* If the power class is different from the default value */ 681 if (pwrclass_val > 0) { 682 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 683 EXT_CSD_POWER_CLASS, 684 pwrclass_val, 685 card->ext_csd.generic_cmd6_time); 686 } 687 688 return err; 689 } 690 691 /* 692 * Handle the detection and initialisation of a card. 693 * 694 * In the case of a resume, "oldcard" will contain the card 695 * we're trying to reinitialise. 696 */ 697 static int mmc_init_card(struct mmc_host *host, u32 ocr, 698 struct mmc_card *oldcard) 699 { 700 struct mmc_card *card; 701 int err, ddr = 0; 702 u32 cid[4]; 703 unsigned int max_dtr; 704 u32 rocr; 705 u8 *ext_csd = NULL; 706 707 BUG_ON(!host); 708 WARN_ON(!host->claimed); 709 710 /* Set correct bus mode for MMC before attempting init */ 711 if (!mmc_host_is_spi(host)) 712 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 713 714 /* 715 * Since we're changing the OCR value, we seem to 716 * need to tell some cards to go back to the idle 717 * state. We wait 1ms to give cards time to 718 * respond. 719 * mmc_go_idle is needed for eMMC that are asleep 720 */ 721 mmc_go_idle(host); 722 723 /* The extra bit indicates that we support high capacity */ 724 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr); 725 if (err) 726 goto err; 727 728 /* 729 * For SPI, enable CRC as appropriate. 730 */ 731 if (mmc_host_is_spi(host)) { 732 err = mmc_spi_set_crc(host, use_spi_crc); 733 if (err) 734 goto err; 735 } 736 737 /* 738 * Fetch CID from card. 739 */ 740 if (mmc_host_is_spi(host)) 741 err = mmc_send_cid(host, cid); 742 else 743 err = mmc_all_send_cid(host, cid); 744 if (err) 745 goto err; 746 747 if (oldcard) { 748 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) { 749 err = -ENOENT; 750 goto err; 751 } 752 753 card = oldcard; 754 } else { 755 /* 756 * Allocate card structure. 757 */ 758 card = mmc_alloc_card(host, &mmc_type); 759 if (IS_ERR(card)) { 760 err = PTR_ERR(card); 761 goto err; 762 } 763 764 card->type = MMC_TYPE_MMC; 765 card->rca = 1; 766 memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); 767 } 768 769 /* 770 * For native busses: set card RCA and quit open drain mode. 771 */ 772 if (!mmc_host_is_spi(host)) { 773 err = mmc_set_relative_addr(card); 774 if (err) 775 goto free_card; 776 777 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 778 } 779 780 if (!oldcard) { 781 /* 782 * Fetch CSD from card. 783 */ 784 err = mmc_send_csd(card, card->raw_csd); 785 if (err) 786 goto free_card; 787 788 err = mmc_decode_csd(card); 789 if (err) 790 goto free_card; 791 err = mmc_decode_cid(card); 792 if (err) 793 goto free_card; 794 } 795 796 /* 797 * Select card, as all following commands rely on that. 798 */ 799 if (!mmc_host_is_spi(host)) { 800 err = mmc_select_card(card); 801 if (err) 802 goto free_card; 803 } 804 805 if (!oldcard) { 806 /* 807 * Fetch and process extended CSD. 808 */ 809 810 err = mmc_get_ext_csd(card, &ext_csd); 811 if (err) 812 goto free_card; 813 err = mmc_read_ext_csd(card, ext_csd); 814 if (err) 815 goto free_card; 816 817 /* If doing byte addressing, check if required to do sector 818 * addressing. Handle the case of <2GB cards needing sector 819 * addressing. See section 8.1 JEDEC Standard JED84-A441; 820 * ocr register has bit 30 set for sector addressing. 821 */ 822 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30))) 823 mmc_card_set_blockaddr(card); 824 825 /* Erase size depends on CSD and Extended CSD */ 826 mmc_set_erase_size(card); 827 } 828 829 /* 830 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF 831 * bit. This bit will be lost every time after a reset or power off. 832 */ 833 if (card->ext_csd.enhanced_area_en) { 834 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 835 EXT_CSD_ERASE_GROUP_DEF, 1, 836 card->ext_csd.generic_cmd6_time); 837 838 if (err && err != -EBADMSG) 839 goto free_card; 840 841 if (err) { 842 err = 0; 843 /* 844 * Just disable enhanced area off & sz 845 * will try to enable ERASE_GROUP_DEF 846 * during next time reinit 847 */ 848 card->ext_csd.enhanced_area_offset = -EINVAL; 849 card->ext_csd.enhanced_area_size = -EINVAL; 850 } else { 851 card->ext_csd.erase_group_def = 1; 852 /* 853 * enable ERASE_GRP_DEF successfully. 854 * This will affect the erase size, so 855 * here need to reset erase size 856 */ 857 mmc_set_erase_size(card); 858 } 859 } 860 861 /* 862 * Ensure eMMC user default partition is enabled 863 */ 864 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) { 865 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; 866 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG, 867 card->ext_csd.part_config, 868 card->ext_csd.part_time); 869 if (err && err != -EBADMSG) 870 goto free_card; 871 } 872 873 /* 874 * If the host supports the power_off_notify capability then 875 * set the notification byte in the ext_csd register of device 876 */ 877 if ((host->caps2 & MMC_CAP2_POWEROFF_NOTIFY) && 878 (card->poweroff_notify_state == MMC_NO_POWER_NOTIFICATION)) { 879 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 880 EXT_CSD_POWER_OFF_NOTIFICATION, 881 EXT_CSD_POWER_ON, 882 card->ext_csd.generic_cmd6_time); 883 if (err && err != -EBADMSG) 884 goto free_card; 885 } 886 887 if (!err) 888 card->poweroff_notify_state = MMC_POWERED_ON; 889 890 /* 891 * Activate high speed (if supported) 892 */ 893 if ((card->ext_csd.hs_max_dtr != 0) && 894 (host->caps & MMC_CAP_MMC_HIGHSPEED)) { 895 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 896 EXT_CSD_HS_TIMING, 1, 897 card->ext_csd.generic_cmd6_time); 898 if (err && err != -EBADMSG) 899 goto free_card; 900 901 if (err) { 902 pr_warning("%s: switch to highspeed failed\n", 903 mmc_hostname(card->host)); 904 err = 0; 905 } else { 906 mmc_card_set_highspeed(card); 907 mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 908 } 909 } 910 911 /* 912 * Enable HPI feature (if supported) 913 */ 914 if (card->ext_csd.hpi) { 915 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 916 EXT_CSD_HPI_MGMT, 1, 0); 917 if (err && err != -EBADMSG) 918 goto free_card; 919 if (err) { 920 pr_warning("%s: Enabling HPI failed\n", 921 mmc_hostname(card->host)); 922 err = 0; 923 } else 924 card->ext_csd.hpi_en = 1; 925 } 926 927 /* 928 * Compute bus speed. 929 */ 930 max_dtr = (unsigned int)-1; 931 932 if (mmc_card_highspeed(card)) { 933 if (max_dtr > card->ext_csd.hs_max_dtr) 934 max_dtr = card->ext_csd.hs_max_dtr; 935 } else if (max_dtr > card->csd.max_dtr) { 936 max_dtr = card->csd.max_dtr; 937 } 938 939 mmc_set_clock(host, max_dtr); 940 941 /* 942 * Indicate DDR mode (if supported). 943 */ 944 if (mmc_card_highspeed(card)) { 945 if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) 946 && ((host->caps & (MMC_CAP_1_8V_DDR | 947 MMC_CAP_UHS_DDR50)) 948 == (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50))) 949 ddr = MMC_1_8V_DDR_MODE; 950 else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) 951 && ((host->caps & (MMC_CAP_1_2V_DDR | 952 MMC_CAP_UHS_DDR50)) 953 == (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50))) 954 ddr = MMC_1_2V_DDR_MODE; 955 } 956 957 /* 958 * Activate wide bus and DDR (if supported). 959 */ 960 if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) && 961 (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) { 962 static unsigned ext_csd_bits[][2] = { 963 { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 }, 964 { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 }, 965 { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 }, 966 }; 967 static unsigned bus_widths[] = { 968 MMC_BUS_WIDTH_8, 969 MMC_BUS_WIDTH_4, 970 MMC_BUS_WIDTH_1 971 }; 972 unsigned idx, bus_width = 0; 973 974 if (host->caps & MMC_CAP_8_BIT_DATA) 975 idx = 0; 976 else 977 idx = 1; 978 for (; idx < ARRAY_SIZE(bus_widths); idx++) { 979 bus_width = bus_widths[idx]; 980 if (bus_width == MMC_BUS_WIDTH_1) 981 ddr = 0; /* no DDR for 1-bit width */ 982 err = mmc_select_powerclass(card, ext_csd_bits[idx][0], 983 ext_csd); 984 if (err) 985 pr_err("%s: power class selection to " 986 "bus width %d failed\n", 987 mmc_hostname(card->host), 988 1 << bus_width); 989 990 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 991 EXT_CSD_BUS_WIDTH, 992 ext_csd_bits[idx][0], 993 card->ext_csd.generic_cmd6_time); 994 if (!err) { 995 mmc_set_bus_width(card->host, bus_width); 996 997 /* 998 * If controller can't handle bus width test, 999 * compare ext_csd previously read in 1 bit mode 1000 * against ext_csd at new bus width 1001 */ 1002 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) 1003 err = mmc_compare_ext_csds(card, 1004 bus_width); 1005 else 1006 err = mmc_bus_test(card, bus_width); 1007 if (!err) 1008 break; 1009 } 1010 } 1011 1012 if (!err && ddr) { 1013 err = mmc_select_powerclass(card, ext_csd_bits[idx][1], 1014 ext_csd); 1015 if (err) 1016 pr_err("%s: power class selection to " 1017 "bus width %d ddr %d failed\n", 1018 mmc_hostname(card->host), 1019 1 << bus_width, ddr); 1020 1021 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1022 EXT_CSD_BUS_WIDTH, 1023 ext_csd_bits[idx][1], 1024 card->ext_csd.generic_cmd6_time); 1025 } 1026 if (err) { 1027 pr_warning("%s: switch to bus width %d ddr %d " 1028 "failed\n", mmc_hostname(card->host), 1029 1 << bus_width, ddr); 1030 goto free_card; 1031 } else if (ddr) { 1032 /* 1033 * eMMC cards can support 3.3V to 1.2V i/o (vccq) 1034 * signaling. 1035 * 1036 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq. 1037 * 1038 * 1.8V vccq at 3.3V core voltage (vcc) is not required 1039 * in the JEDEC spec for DDR. 1040 * 1041 * Do not force change in vccq since we are obviously 1042 * working and no change to vccq is needed. 1043 * 1044 * WARNING: eMMC rules are NOT the same as SD DDR 1045 */ 1046 if (ddr == EXT_CSD_CARD_TYPE_DDR_1_2V) { 1047 err = mmc_set_signal_voltage(host, 1048 MMC_SIGNAL_VOLTAGE_120, 0); 1049 if (err) 1050 goto err; 1051 } 1052 mmc_card_set_ddr_mode(card); 1053 mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50); 1054 mmc_set_bus_width(card->host, bus_width); 1055 } 1056 } 1057 1058 /* 1059 * If cache size is higher than 0, this indicates 1060 * the existence of cache and it can be turned on. 1061 */ 1062 if ((host->caps2 & MMC_CAP2_CACHE_CTRL) && 1063 card->ext_csd.cache_size > 0) { 1064 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1065 EXT_CSD_CACHE_CTRL, 1, 0); 1066 if (err && err != -EBADMSG) 1067 goto free_card; 1068 1069 /* 1070 * Only if no error, cache is turned on successfully. 1071 */ 1072 card->ext_csd.cache_ctrl = err ? 0 : 1; 1073 } 1074 1075 if (!oldcard) 1076 host->card = card; 1077 1078 mmc_free_ext_csd(ext_csd); 1079 return 0; 1080 1081 free_card: 1082 if (!oldcard) 1083 mmc_remove_card(card); 1084 err: 1085 mmc_free_ext_csd(ext_csd); 1086 1087 return err; 1088 } 1089 1090 /* 1091 * Host is being removed. Free up the current card. 1092 */ 1093 static void mmc_remove(struct mmc_host *host) 1094 { 1095 BUG_ON(!host); 1096 BUG_ON(!host->card); 1097 1098 mmc_remove_card(host->card); 1099 host->card = NULL; 1100 } 1101 1102 /* 1103 * Card detection callback from host. 1104 */ 1105 static void mmc_detect(struct mmc_host *host) 1106 { 1107 int err; 1108 1109 BUG_ON(!host); 1110 BUG_ON(!host->card); 1111 1112 mmc_claim_host(host); 1113 1114 /* 1115 * Just check if our card has been removed. 1116 */ 1117 err = mmc_send_status(host->card, NULL); 1118 1119 mmc_release_host(host); 1120 1121 if (err) { 1122 mmc_remove(host); 1123 1124 mmc_claim_host(host); 1125 mmc_detach_bus(host); 1126 mmc_power_off(host); 1127 mmc_release_host(host); 1128 } 1129 } 1130 1131 /* 1132 * Suspend callback from host. 1133 */ 1134 static int mmc_suspend(struct mmc_host *host) 1135 { 1136 int err = 0; 1137 1138 BUG_ON(!host); 1139 BUG_ON(!host->card); 1140 1141 mmc_claim_host(host); 1142 if (mmc_card_can_sleep(host)) 1143 err = mmc_card_sleep(host); 1144 else if (!mmc_host_is_spi(host)) 1145 mmc_deselect_cards(host); 1146 host->card->state &= ~MMC_STATE_HIGHSPEED; 1147 mmc_release_host(host); 1148 1149 return err; 1150 } 1151 1152 /* 1153 * Resume callback from host. 1154 * 1155 * This function tries to determine if the same card is still present 1156 * and, if so, restore all state to it. 1157 */ 1158 static int mmc_resume(struct mmc_host *host) 1159 { 1160 int err; 1161 1162 BUG_ON(!host); 1163 BUG_ON(!host->card); 1164 1165 mmc_claim_host(host); 1166 err = mmc_init_card(host, host->ocr, host->card); 1167 mmc_release_host(host); 1168 1169 return err; 1170 } 1171 1172 static int mmc_power_restore(struct mmc_host *host) 1173 { 1174 int ret; 1175 1176 host->card->state &= ~MMC_STATE_HIGHSPEED; 1177 mmc_claim_host(host); 1178 ret = mmc_init_card(host, host->ocr, host->card); 1179 mmc_release_host(host); 1180 1181 return ret; 1182 } 1183 1184 static int mmc_sleep(struct mmc_host *host) 1185 { 1186 struct mmc_card *card = host->card; 1187 int err = -ENOSYS; 1188 1189 if (card && card->ext_csd.rev >= 3) { 1190 err = mmc_card_sleepawake(host, 1); 1191 if (err < 0) 1192 pr_debug("%s: Error %d while putting card into sleep", 1193 mmc_hostname(host), err); 1194 } 1195 1196 return err; 1197 } 1198 1199 static int mmc_awake(struct mmc_host *host) 1200 { 1201 struct mmc_card *card = host->card; 1202 int err = -ENOSYS; 1203 1204 if (card && card->ext_csd.rev >= 3) { 1205 err = mmc_card_sleepawake(host, 0); 1206 if (err < 0) 1207 pr_debug("%s: Error %d while awaking sleeping card", 1208 mmc_hostname(host), err); 1209 } 1210 1211 return err; 1212 } 1213 1214 static const struct mmc_bus_ops mmc_ops = { 1215 .awake = mmc_awake, 1216 .sleep = mmc_sleep, 1217 .remove = mmc_remove, 1218 .detect = mmc_detect, 1219 .suspend = NULL, 1220 .resume = NULL, 1221 .power_restore = mmc_power_restore, 1222 }; 1223 1224 static const struct mmc_bus_ops mmc_ops_unsafe = { 1225 .awake = mmc_awake, 1226 .sleep = mmc_sleep, 1227 .remove = mmc_remove, 1228 .detect = mmc_detect, 1229 .suspend = mmc_suspend, 1230 .resume = mmc_resume, 1231 .power_restore = mmc_power_restore, 1232 }; 1233 1234 static void mmc_attach_bus_ops(struct mmc_host *host) 1235 { 1236 const struct mmc_bus_ops *bus_ops; 1237 1238 if (!mmc_card_is_removable(host)) 1239 bus_ops = &mmc_ops_unsafe; 1240 else 1241 bus_ops = &mmc_ops; 1242 mmc_attach_bus(host, bus_ops); 1243 } 1244 1245 /* 1246 * Starting point for MMC card init. 1247 */ 1248 int mmc_attach_mmc(struct mmc_host *host) 1249 { 1250 int err; 1251 u32 ocr; 1252 1253 BUG_ON(!host); 1254 WARN_ON(!host->claimed); 1255 1256 /* Set correct bus mode for MMC before attempting attach */ 1257 if (!mmc_host_is_spi(host)) 1258 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 1259 1260 err = mmc_send_op_cond(host, 0, &ocr); 1261 if (err) 1262 return err; 1263 1264 mmc_attach_bus_ops(host); 1265 if (host->ocr_avail_mmc) 1266 host->ocr_avail = host->ocr_avail_mmc; 1267 1268 /* 1269 * We need to get OCR a different way for SPI. 1270 */ 1271 if (mmc_host_is_spi(host)) { 1272 err = mmc_spi_read_ocr(host, 1, &ocr); 1273 if (err) 1274 goto err; 1275 } 1276 1277 /* 1278 * Sanity check the voltages that the card claims to 1279 * support. 1280 */ 1281 if (ocr & 0x7F) { 1282 pr_warning("%s: card claims to support voltages " 1283 "below the defined range. These will be ignored.\n", 1284 mmc_hostname(host)); 1285 ocr &= ~0x7F; 1286 } 1287 1288 host->ocr = mmc_select_voltage(host, ocr); 1289 1290 /* 1291 * Can we support the voltage of the card? 1292 */ 1293 if (!host->ocr) { 1294 err = -EINVAL; 1295 goto err; 1296 } 1297 1298 /* 1299 * Detect and init the card. 1300 */ 1301 err = mmc_init_card(host, host->ocr, NULL); 1302 if (err) 1303 goto err; 1304 1305 mmc_release_host(host); 1306 err = mmc_add_card(host->card); 1307 mmc_claim_host(host); 1308 if (err) 1309 goto remove_card; 1310 1311 return 0; 1312 1313 remove_card: 1314 mmc_release_host(host); 1315 mmc_remove_card(host->card); 1316 mmc_claim_host(host); 1317 host->card = NULL; 1318 err: 1319 mmc_detach_bus(host); 1320 1321 pr_err("%s: error %d whilst initialising MMC card\n", 1322 mmc_hostname(host), err); 1323 1324 return err; 1325 } 1326