2 * linux/drivers/mmc/core/mmc.c
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.
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.
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/stat.h>
16 #include <linux/pm_runtime.h>
18 #include <linux/mmc/host.h>
19 #include <linux/mmc/card.h>
20 #include <linux/mmc/mmc.h>
27 static const unsigned int tran_exp[] = {
28 10000, 100000, 1000000, 10000000,
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,
37 static const unsigned int tacc_exp[] = {
38 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
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,
46 #define UNSTUFF_BITS(resp,start,size) \
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; \
54 __res = resp[__off] >> __shft; \
55 if (__size + __shft > 32) \
56 __res |= resp[__off-1] << ((32 - __shft) % 32); \
61 * Given the decoded CSD structure, decode the raw CID to our CID structure.
63 static int mmc_decode_cid(struct mmc_card *card)
65 u32 *resp = card->raw_cid;
68 * The selection of the format here is based upon published
69 * specs from sandisk and from what people have reported.
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;
89 case 2: /* MMC v2.0 - v2.2 */
90 case 3: /* MMC v3.1 - v3.3 */
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;
107 pr_err("%s: card has unknown MMCA version %d\n",
108 mmc_hostname(card->host), card->csd.mmca_vsn);
115 static void mmc_set_erase_size(struct mmc_card *card)
117 if (card->ext_csd.erase_group_def & 1)
118 card->erase_size = card->ext_csd.hc_erase_size;
120 card->erase_size = card->csd.erase_size;
122 mmc_init_erase(card);
126 * Given a 128-bit response, decode to our card CSD structure.
128 static int mmc_decode_csd(struct mmc_card *card)
130 struct mmc_csd *csd = &card->csd;
131 unsigned int e, m, a, b;
132 u32 *resp = card->raw_csd;
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.
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);
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;
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);
157 e = UNSTUFF_BITS(resp, 47, 3);
158 m = UNSTUFF_BITS(resp, 62, 12);
159 csd->capacity = (1 + m) << (e + 2);
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);
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;
182 static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
188 BUG_ON(!new_ext_csd);
192 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
196 * As the ext_csd is so large and mostly unused, we don't store the
197 * raw block in mmc_card.
199 ext_csd = kmalloc(512, GFP_KERNEL);
201 pr_err("%s: could not allocate a buffer to "
202 "receive the ext_csd.\n", mmc_hostname(card->host));
206 err = mmc_send_ext_csd(card, ext_csd);
211 /* If the host or the card can't do the switch,
212 * fail more gracefully. */
219 * High capacity cards should have this "magic" size
220 * stored in their CSD.
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));
228 pr_warning("%s: unable to read "
229 "EXT_CSD, performance might "
231 mmc_hostname(card->host));
235 *new_ext_csd = ext_csd;
240 static void mmc_select_card_type(struct mmc_card *card)
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
302 * Decode extended CSD.
304 static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
307 unsigned int part_size;
308 u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0;
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);
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);
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;
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);
351 card->ext_csd.boot_info = ext_csd[EXT_CSD_BOOT_INFO];
352 card->ext_csd.boot_config = ext_csd[EXT_CSD_PART_CONFIG];
353 card->ext_csd.boot_size = ext_csd[EXT_CSD_BOOT_MULT];
354 card->ext_csd.boot_bus_width = ext_csd[EXT_CSD_BOOT_BUS_WIDTH];
356 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
357 mmc_select_card_type(card);
359 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
360 card->ext_csd.raw_erase_timeout_mult =
361 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
362 card->ext_csd.raw_hc_erase_grp_size =
363 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
364 if (card->ext_csd.rev >= 3) {
365 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
366 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
368 /* EXT_CSD value is in units of 10ms, but we store in ms */
369 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
371 /* Sleep / awake timeout in 100ns units */
372 if (sa_shift > 0 && sa_shift <= 0x17)
373 card->ext_csd.sa_timeout =
374 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
375 card->ext_csd.erase_group_def =
376 ext_csd[EXT_CSD_ERASE_GROUP_DEF];
377 card->ext_csd.hc_erase_timeout = 300 *
378 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
379 card->ext_csd.hc_erase_size =
380 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
382 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
385 * There are two boot regions of equal size, defined in
388 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
389 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
390 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
391 mmc_part_add(card, part_size,
392 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
394 MMC_BLK_DATA_AREA_BOOT);
399 card->ext_csd.raw_hc_erase_gap_size =
400 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
401 card->ext_csd.raw_sec_trim_mult =
402 ext_csd[EXT_CSD_SEC_TRIM_MULT];
403 card->ext_csd.raw_sec_erase_mult =
404 ext_csd[EXT_CSD_SEC_ERASE_MULT];
405 card->ext_csd.raw_sec_feature_support =
406 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
407 card->ext_csd.raw_trim_mult =
408 ext_csd[EXT_CSD_TRIM_MULT];
409 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
410 if (card->ext_csd.rev >= 4) {
412 * Enhanced area feature support -- check whether the eMMC
413 * card has the Enhanced area enabled. If so, export enhanced
414 * area offset and size to user by adding sysfs interface.
416 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
417 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
419 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
421 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
423 card->ext_csd.enhanced_area_en = 1;
425 * calculate the enhanced data area offset, in bytes
427 card->ext_csd.enhanced_area_offset =
428 (ext_csd[139] << 24) + (ext_csd[138] << 16) +
429 (ext_csd[137] << 8) + ext_csd[136];
430 if (mmc_card_blockaddr(card))
431 card->ext_csd.enhanced_area_offset <<= 9;
433 * calculate the enhanced data area size, in kilobytes
435 card->ext_csd.enhanced_area_size =
436 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
438 card->ext_csd.enhanced_area_size *=
439 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
440 card->ext_csd.enhanced_area_size <<= 9;
443 * If the enhanced area is not enabled, disable these
446 card->ext_csd.enhanced_area_offset = -EINVAL;
447 card->ext_csd.enhanced_area_size = -EINVAL;
451 * General purpose partition feature support --
452 * If ext_csd has the size of general purpose partitions,
453 * set size, part_cfg, partition name in mmc_part.
455 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
456 EXT_CSD_PART_SUPPORT_PART_EN) {
457 if (card->ext_csd.enhanced_area_en != 1) {
459 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
461 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
463 card->ext_csd.enhanced_area_en = 1;
466 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
467 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
468 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
469 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
472 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
474 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
476 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
477 part_size *= (size_t)(hc_erase_grp_sz *
479 mmc_part_add(card, part_size << 19,
480 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
482 MMC_BLK_DATA_AREA_GP);
485 card->ext_csd.sec_trim_mult =
486 ext_csd[EXT_CSD_SEC_TRIM_MULT];
487 card->ext_csd.sec_erase_mult =
488 ext_csd[EXT_CSD_SEC_ERASE_MULT];
489 card->ext_csd.sec_feature_support =
490 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
491 card->ext_csd.trim_timeout = 300 *
492 ext_csd[EXT_CSD_TRIM_MULT];
495 * Note that the call to mmc_part_add above defaults to read
496 * only. If this default assumption is changed, the call must
497 * take into account the value of boot_locked below.
499 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
500 card->ext_csd.boot_ro_lockable = true;
502 /* Save power class values */
503 card->ext_csd.raw_pwr_cl_52_195 =
504 ext_csd[EXT_CSD_PWR_CL_52_195];
505 card->ext_csd.raw_pwr_cl_26_195 =
506 ext_csd[EXT_CSD_PWR_CL_26_195];
507 card->ext_csd.raw_pwr_cl_52_360 =
508 ext_csd[EXT_CSD_PWR_CL_52_360];
509 card->ext_csd.raw_pwr_cl_26_360 =
510 ext_csd[EXT_CSD_PWR_CL_26_360];
511 card->ext_csd.raw_pwr_cl_200_195 =
512 ext_csd[EXT_CSD_PWR_CL_200_195];
513 card->ext_csd.raw_pwr_cl_200_360 =
514 ext_csd[EXT_CSD_PWR_CL_200_360];
515 card->ext_csd.raw_pwr_cl_ddr_52_195 =
516 ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
517 card->ext_csd.raw_pwr_cl_ddr_52_360 =
518 ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
519 card->ext_csd.raw_pwr_cl_ddr_200_360 =
520 ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
523 if (card->ext_csd.rev >= 5) {
524 /* Adjust production date as per JEDEC JESD84-B451 */
525 if (card->cid.year < 2010)
526 card->cid.year += 16;
528 /* check whether the eMMC card supports BKOPS */
529 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
530 card->ext_csd.bkops = 1;
531 card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN];
532 card->ext_csd.raw_bkops_status =
533 ext_csd[EXT_CSD_BKOPS_STATUS];
534 if (!card->ext_csd.bkops_en)
535 pr_info("%s: BKOPS_EN bit is not set\n",
536 mmc_hostname(card->host));
539 /* check whether the eMMC card supports HPI */
540 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
541 card->ext_csd.hpi = 1;
542 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
543 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
545 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
547 * Indicate the maximum timeout to close
548 * a command interrupted by HPI
550 card->ext_csd.out_of_int_time =
551 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
554 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
555 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
558 * RPMB regions are defined in multiples of 128K.
560 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
561 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
562 mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
563 EXT_CSD_PART_CONFIG_ACC_RPMB,
565 MMC_BLK_DATA_AREA_RPMB);
569 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
570 if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
571 card->erased_byte = 0xFF;
573 card->erased_byte = 0x0;
575 /* eMMC v4.5 or later */
576 if (card->ext_csd.rev >= 6) {
577 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
579 card->ext_csd.generic_cmd6_time = 10 *
580 ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
581 card->ext_csd.power_off_longtime = 10 *
582 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
584 card->ext_csd.cache_size =
585 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
586 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
587 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
588 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
590 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
591 card->ext_csd.data_sector_size = 4096;
593 card->ext_csd.data_sector_size = 512;
595 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
596 (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
597 card->ext_csd.data_tag_unit_size =
598 ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
599 (card->ext_csd.data_sector_size);
601 card->ext_csd.data_tag_unit_size = 0;
604 card->ext_csd.max_packed_writes =
605 ext_csd[EXT_CSD_MAX_PACKED_WRITES];
606 card->ext_csd.max_packed_reads =
607 ext_csd[EXT_CSD_MAX_PACKED_READS];
609 card->ext_csd.data_sector_size = 512;
616 static inline void mmc_free_ext_csd(u8 *ext_csd)
622 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
627 if (bus_width == MMC_BUS_WIDTH_1)
630 err = mmc_get_ext_csd(card, &bw_ext_csd);
632 if (err || bw_ext_csd == NULL) {
637 /* only compare read only fields */
638 err = !((card->ext_csd.raw_partition_support ==
639 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
640 (card->ext_csd.raw_erased_mem_count ==
641 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
642 (card->ext_csd.rev ==
643 bw_ext_csd[EXT_CSD_REV]) &&
644 (card->ext_csd.raw_ext_csd_structure ==
645 bw_ext_csd[EXT_CSD_STRUCTURE]) &&
646 (card->ext_csd.raw_card_type ==
647 bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
648 (card->ext_csd.raw_s_a_timeout ==
649 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
650 (card->ext_csd.raw_hc_erase_gap_size ==
651 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
652 (card->ext_csd.raw_erase_timeout_mult ==
653 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
654 (card->ext_csd.raw_hc_erase_grp_size ==
655 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
656 (card->ext_csd.raw_sec_trim_mult ==
657 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
658 (card->ext_csd.raw_sec_erase_mult ==
659 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
660 (card->ext_csd.raw_sec_feature_support ==
661 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
662 (card->ext_csd.raw_trim_mult ==
663 bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
664 (card->ext_csd.raw_sectors[0] ==
665 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
666 (card->ext_csd.raw_sectors[1] ==
667 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
668 (card->ext_csd.raw_sectors[2] ==
669 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
670 (card->ext_csd.raw_sectors[3] ==
671 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
672 (card->ext_csd.raw_pwr_cl_52_195 ==
673 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
674 (card->ext_csd.raw_pwr_cl_26_195 ==
675 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
676 (card->ext_csd.raw_pwr_cl_52_360 ==
677 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
678 (card->ext_csd.raw_pwr_cl_26_360 ==
679 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
680 (card->ext_csd.raw_pwr_cl_200_195 ==
681 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
682 (card->ext_csd.raw_pwr_cl_200_360 ==
683 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
684 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
685 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
686 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
687 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
688 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
689 bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
695 mmc_free_ext_csd(bw_ext_csd);
699 static ssize_t mmc_boot_info_show(struct device *dev,
700 struct device_attribute *attr, char *buf)
702 char *boot_partition[8] = {
703 "Device not boot enabled",
704 "Boot partition 1 enabled",
705 "Boot partition 2 enabled",
710 "User area enabled for boot"};
712 char *bus_width[4] = {
713 "x1 (sdr) or x4 (ddr) bus width in boot operation mode",
714 "x4 (sdr/ddr) bus width in boot operation mode",
715 "x8 (sdr/ddr) bus width in boot operation mode",
718 char *boot_mode[4] = {
719 "Use single data rate + backward compatible timings in boot operation",
720 "Use single data rate + high speed timings in boot operation mode",
721 "Use dual data rate in boot operation",
729 struct mmc_card *card = container_of(dev, struct mmc_card, dev);
731 /* read it again because user may change it */
732 mmc_claim_host(card->host);
733 err = mmc_get_ext_csd(card, &ext_csd);
734 mmc_release_host(card->host);
735 if (err || !ext_csd) {
736 pr_err("%s: failed to get ext_csd, err=%d\n",
737 mmc_hostname(card->host),
742 mmc_read_ext_csd(card, ext_csd);
743 mmc_free_ext_csd(ext_csd);
745 partition = (card->ext_csd.boot_config >> 3) & 0x7;
746 width = card->ext_csd.boot_bus_width & 0x3;
747 mode = (card->ext_csd.boot_bus_width >> 3) & 0x3;
750 "boot_info:0x%02x;\n"
751 " ALT_BOOT_MODE:%x - %s\n"
752 " DDR_BOOT_MODE:%x - %s\n"
753 " HS_BOOTMODE:%x - %s\n"
755 "boot_partition:0x%02x;\n"
756 " BOOT_ACK:%x - %s\n"
757 " BOOT_PARTITION-ENABLE: %x - %s\n"
759 " BOOT_MODE:%x - %s\n"
760 " RESET_BOOT_BUS_WIDTH:%x - %s\n"
761 " BOOT_BUS_WIDTH:%x - %s\n",
763 card->ext_csd.boot_info,
764 !!(card->ext_csd.boot_info & 0x1),
765 (card->ext_csd.boot_info & 0x1) ?
766 "Supports alternate boot method" :
767 "Does not support alternate boot method",
768 !!(card->ext_csd.boot_info & 0x2),
769 (card->ext_csd.boot_info & 0x2) ?
770 "Supports alternate dual data rate during boot" :
771 "Does not support dual data rate during boot",
772 !!(card->ext_csd.boot_info & 0x4),
773 (card->ext_csd.boot_info & 0x4) ?
774 "Supports high speed timing during boot" :
775 "Does not support high speed timing during boot",
777 card->ext_csd.boot_size * 128,
779 card->ext_csd.boot_config,
780 !!(card->ext_csd.boot_config & 0x40),
781 (card->ext_csd.boot_config & 0x40) ?
782 "Boot acknowledge sent during boot operation" :
783 "No boot acknowledge sent",
785 boot_partition[partition],
787 card->ext_csd.boot_bus_width,
790 !!(card->ext_csd.boot_bus_width & 0x4),
791 (card->ext_csd.boot_bus_width & 0x4) ?
792 "Retain boot bus width and boot mode after boot operation" :
793 "Reset bus width to x1, single data rate and backward"
794 "compatible timings after boot operation",
799 /* set up boot partitions */
801 setup_boot_partitions(struct device *dev, struct device_attribute *attr,
802 const char *buf, size_t count)
806 u8 *ext_csd, boot_config;
807 struct mmc_command cmd;
808 struct mmc_card *card = container_of(dev, struct mmc_card, dev);
812 sscanf(buf, "%d\n", &part);
814 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) {
815 pr_err("%s: invalid mmc version" \
816 " mmc version is below version 4!)\n",
817 mmc_hostname(card->host));
821 /* it's a normal SD/MMC but user request to configure boot partition */
822 if (card->ext_csd.boot_size <= 0) {
823 pr_err("%s: fail to send SWITCH command to card " \
824 "to update boot_config of the EXT_CSD!\n",
825 mmc_hostname(card->host));
830 * partition must be -
832 * 1 - boot partition 1
833 * 2 - boot partition 2
834 * DO NOT switch the partitions that used to be accessed
837 if (part & EXT_CSD_BOOT_PARTITION_ACCESS_MASK) {
838 pr_err("%s: DO NOT switch the partitions that used to be\n" \
839 " accessed in OS layer HERE. please following the\n" \
840 " guidance of Documentation/mmc/mmc-dev-parts.txt.\n",
841 mmc_hostname(card->host));
845 ext_csd = kmalloc(512, GFP_KERNEL);
847 pr_err("%s: could not allocate a buffer to " \
848 "receive the ext_csd.\n", mmc_hostname(card->host));
852 mmc_claim_host(card->host);
853 err = mmc_send_ext_csd(card, ext_csd);
855 pr_err("%s: unable to read EXT_CSD.\n",
856 mmc_hostname(card->host));
860 /* enable the boot partition in boot mode */
862 * 0x00 - disable boot enable.
863 * 0x08 - boot partition 1 is enabled for boot.
864 * 0x10 - boot partition 2 is enabled for boot.
865 * 0x38 - User area is enabled for boot.
867 switch (part & EXT_CSD_BOOT_PARTITION_ENABLE_MASK) {
869 boot_config = (ext_csd[EXT_CSD_PART_CONFIG]
870 & ~EXT_CSD_BOOT_PARTITION_ENABLE_MASK
871 & ~EXT_CSD_BOOT_ACK_ENABLE);
873 case EXT_CSD_BOOT_PARTITION_PART1:
874 boot_config = ((ext_csd[EXT_CSD_PART_CONFIG]
875 & ~EXT_CSD_BOOT_PARTITION_ENABLE_MASK)
876 | EXT_CSD_BOOT_PARTITION_PART1
877 | EXT_CSD_BOOT_ACK_ENABLE);
879 case EXT_CSD_BOOT_PARTITION_PART2:
880 boot_config = ((ext_csd[EXT_CSD_PART_CONFIG]
881 & ~EXT_CSD_BOOT_PARTITION_ENABLE_MASK)
882 | EXT_CSD_BOOT_PARTITION_PART2
883 | EXT_CSD_BOOT_ACK_ENABLE);
885 case EXT_CSD_BOOT_PARTITION_ENABLE_MASK:
886 boot_config = ((ext_csd[EXT_CSD_PART_CONFIG]
887 | EXT_CSD_BOOT_PARTITION_ENABLE_MASK)
888 & ~EXT_CSD_BOOT_ACK_ENABLE);
891 pr_err("%s: wrong boot config parameter" \
892 " 00 (disable boot), 08 (enable boot1)," \
893 "16 (enable boot2), 56 (User area)\n",
894 mmc_hostname(card->host));
899 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
900 EXT_CSD_PART_CONFIG, boot_config, card->ext_csd.part_time);
902 pr_err("%s: fail to send SWITCH command to card " \
903 "to update boot_config of the EXT_CSD!\n",
904 mmc_hostname(card->host));
908 /* waiting for the card to finish the busy state */
910 memset(&cmd, 0, sizeof(struct mmc_command));
912 cmd.opcode = MMC_SEND_STATUS;
913 cmd.arg = card->rca << 16;
914 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
916 err = mmc_wait_for_cmd(card->host, &cmd, 0);
917 if (err || busy > 100) {
918 pr_err("%s: failed to wait for" \
919 "the busy state to end.\n",
920 mmc_hostname(card->host));
924 if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {
925 pr_info("%s: card is in busy state" \
926 "pls wait for busy state to end.\n",
927 mmc_hostname(card->host));
930 } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
932 /* Now check whether it works */
933 err = mmc_send_ext_csd(card, ext_csd);
935 pr_err("%s: %d unable to re-read EXT_CSD.\n",
936 mmc_hostname(card->host), err);
940 card->ext_csd.boot_config = ext_csd[EXT_CSD_PART_CONFIG];
943 mmc_release_host(card->host);
951 /* configure the boot bus */
953 setup_boot_bus(struct device *dev, struct device_attribute *attr,
954 const char *buf, size_t count)
957 u32 boot_bus, new_bus;
959 struct mmc_command cmd;
960 struct mmc_card *card = container_of(dev, struct mmc_card, dev);
964 sscanf(buf, "%d\n", &boot_bus);
966 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) {
967 pr_err("%s: invalid mmc version" \
968 " mmc version is below version 4!)\n",
969 mmc_hostname(card->host));
973 /* it's a normal SD/MMC but user request to configure boot bus */
974 if (card->ext_csd.boot_size <= 0) {
975 pr_err("%s: this is a normal SD/MMC card" \
976 " but you request to configure boot bus !\n",
977 mmc_hostname(card->host));
981 ext_csd = kmalloc(512, GFP_KERNEL);
983 pr_err("%s: could not allocate a buffer to " \
984 "receive the ext_csd.\n", mmc_hostname(card->host));
988 mmc_claim_host(card->host);
989 err = mmc_send_ext_csd(card, ext_csd);
991 pr_err("%s: unable to read EXT_CSD.\n",
992 mmc_hostname(card->host));
996 /* Configure the boot bus width when boot partition is enabled */
997 if (((boot_bus & EXT_CSD_BOOT_BUS_WIDTH_MODE_MASK) >> 3) > 2
998 || (boot_bus & EXT_CSD_BOOT_BUS_WIDTH_WIDTH_MASK) > 2
999 || (boot_bus & ~EXT_CSD_BOOT_BUS_WIDTH_MASK) > 0) {
1000 pr_err("%s: Invalid inputs!\n",
1001 mmc_hostname(card->host));
1006 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1007 EXT_CSD_BOOT_BUS_WIDTH, boot_bus, card->ext_csd.part_time);
1009 pr_err("%s: fail to send SWITCH command to card " \
1010 "to update boot_config of the EXT_CSD!\n",
1011 mmc_hostname(card->host));
1015 /* waiting for the card to finish the busy state */
1017 memset(&cmd, 0, sizeof(struct mmc_command));
1019 cmd.opcode = MMC_SEND_STATUS;
1020 cmd.arg = card->rca << 16;
1021 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1023 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1024 if (err || busy > 100) {
1025 pr_err("%s: failed to wait for" \
1026 "the busy state to end.\n",
1027 mmc_hostname(card->host));
1031 if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {
1032 pr_info("%s: card is in busy state" \
1033 "pls wait for busy state to end.\n",
1034 mmc_hostname(card->host));
1037 } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
1039 /* Now check whether it works */
1040 err = mmc_send_ext_csd(card, ext_csd);
1042 pr_err("%s: %d unable to re-read EXT_CSD.\n",
1043 mmc_hostname(card->host), err);
1047 new_bus = ext_csd[EXT_CSD_BOOT_BUS_WIDTH];
1048 if (boot_bus != new_bus) {
1049 pr_err("%s: after SWITCH, current boot bus mode %d" \
1050 " is not same as requested bus mode %d!\n",
1051 mmc_hostname(card->host), new_bus, boot_bus);
1054 card->ext_csd.boot_bus_width = ext_csd[EXT_CSD_BOOT_BUS_WIDTH];
1057 mmc_release_host(card->host);
1058 mmc_free_ext_csd(ext_csd);
1065 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
1066 card->raw_cid[2], card->raw_cid[3]);
1067 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
1068 card->raw_csd[2], card->raw_csd[3]);
1069 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
1070 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
1071 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
1072 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
1073 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
1074 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
1075 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
1076 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
1077 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
1078 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
1079 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
1080 card->ext_csd.enhanced_area_offset);
1081 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
1082 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
1083 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
1084 DEVICE_ATTR(boot_info, S_IRUGO, mmc_boot_info_show, NULL);
1085 DEVICE_ATTR(boot_config, S_IWUGO, NULL, setup_boot_partitions);
1086 DEVICE_ATTR(boot_bus_config, S_IWUGO, NULL, setup_boot_bus);
1088 static struct attribute *mmc_std_attrs[] = {
1091 &dev_attr_date.attr,
1092 &dev_attr_erase_size.attr,
1093 &dev_attr_preferred_erase_size.attr,
1094 &dev_attr_fwrev.attr,
1095 &dev_attr_hwrev.attr,
1096 &dev_attr_manfid.attr,
1097 &dev_attr_name.attr,
1098 &dev_attr_oemid.attr,
1100 &dev_attr_serial.attr,
1101 &dev_attr_enhanced_area_offset.attr,
1102 &dev_attr_enhanced_area_size.attr,
1103 &dev_attr_raw_rpmb_size_mult.attr,
1104 &dev_attr_rel_sectors.attr,
1105 &dev_attr_boot_info.attr,
1106 &dev_attr_boot_config.attr,
1107 &dev_attr_boot_bus_config.attr,
1110 ATTRIBUTE_GROUPS(mmc_std);
1112 static struct device_type mmc_type = {
1113 .groups = mmc_std_groups,
1117 * Select the PowerClass for the current bus width
1118 * If power class is defined for 4/8 bit bus in the
1119 * extended CSD register, select it by executing the
1120 * mmc_switch command.
1122 static int __mmc_select_powerclass(struct mmc_card *card,
1123 unsigned int bus_width)
1125 struct mmc_host *host = card->host;
1126 struct mmc_ext_csd *ext_csd = &card->ext_csd;
1127 unsigned int pwrclass_val = 0;
1130 /* Power class selection is supported for versions >= 4.0 */
1131 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
1134 /* Power class values are defined only for 4/8 bit bus */
1135 if (bus_width == EXT_CSD_BUS_WIDTH_1)
1138 switch (1 << host->ios.vdd) {
1139 case MMC_VDD_165_195:
1140 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
1141 pwrclass_val = ext_csd->raw_pwr_cl_26_195;
1142 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
1143 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
1144 ext_csd->raw_pwr_cl_52_195 :
1145 ext_csd->raw_pwr_cl_ddr_52_195;
1146 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
1147 pwrclass_val = ext_csd->raw_pwr_cl_200_195;
1158 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
1159 pwrclass_val = ext_csd->raw_pwr_cl_26_360;
1160 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
1161 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
1162 ext_csd->raw_pwr_cl_52_360 :
1163 ext_csd->raw_pwr_cl_ddr_52_360;
1164 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
1165 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
1166 ext_csd->raw_pwr_cl_ddr_200_360 :
1167 ext_csd->raw_pwr_cl_200_360;
1170 pr_warning("%s: Voltage range not supported "
1171 "for power class.\n", mmc_hostname(host));
1175 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
1176 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
1177 EXT_CSD_PWR_CL_8BIT_SHIFT;
1179 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
1180 EXT_CSD_PWR_CL_4BIT_SHIFT;
1182 /* If the power class is different from the default value */
1183 if (pwrclass_val > 0) {
1184 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1185 EXT_CSD_POWER_CLASS,
1187 card->ext_csd.generic_cmd6_time);
1193 static int mmc_select_powerclass(struct mmc_card *card)
1195 struct mmc_host *host = card->host;
1196 u32 bus_width, ext_csd_bits;
1199 /* Power class selection is supported for versions >= 4.0 */
1200 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
1203 bus_width = host->ios.bus_width;
1204 /* Power class values are defined only for 4/8 bit bus */
1205 if (bus_width == MMC_BUS_WIDTH_1)
1208 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
1210 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1211 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1213 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1214 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
1216 err = __mmc_select_powerclass(card, ext_csd_bits);
1218 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
1219 mmc_hostname(host), 1 << bus_width, ddr);
1225 * Set the bus speed for the selected speed mode.
1227 static void mmc_set_bus_speed(struct mmc_card *card)
1229 unsigned int max_dtr = (unsigned int)-1;
1231 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
1232 max_dtr > card->ext_csd.hs200_max_dtr)
1233 max_dtr = card->ext_csd.hs200_max_dtr;
1234 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
1235 max_dtr = card->ext_csd.hs_max_dtr;
1236 else if (max_dtr > card->csd.max_dtr)
1237 max_dtr = card->csd.max_dtr;
1239 mmc_set_clock(card->host, max_dtr);
1243 * Select the bus width amoung 4-bit and 8-bit(SDR).
1244 * If the bus width is changed successfully, return the selected width value.
1245 * Zero is returned instead of error value if the wide width is not supported.
1247 static int mmc_select_bus_width(struct mmc_card *card)
1249 static unsigned ext_csd_bits[] = {
1250 EXT_CSD_BUS_WIDTH_8,
1251 EXT_CSD_BUS_WIDTH_4,
1253 static unsigned bus_widths[] = {
1257 struct mmc_host *host = card->host;
1258 unsigned idx, bus_width = 0;
1261 if ((card->csd.mmca_vsn < CSD_SPEC_VER_4) &&
1262 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
1265 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
1268 * Unlike SD, MMC cards dont have a configuration register to notify
1269 * supported bus width. So bus test command should be run to identify
1270 * the supported bus width or compare the ext csd values of current
1271 * bus width and ext csd values of 1 bit mode read earlier.
1273 for (; idx < ARRAY_SIZE(bus_widths); idx++) {
1275 * Host is capable of 8bit transfer, then switch
1276 * the device to work in 8bit transfer mode. If the
1277 * mmc switch command returns error then switch to
1278 * 4bit transfer mode. On success set the corresponding
1279 * bus width on the host.
1281 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1284 card->ext_csd.generic_cmd6_time);
1288 bus_width = bus_widths[idx];
1289 mmc_set_bus_width(host, bus_width);
1292 * If controller can't handle bus width test,
1293 * compare ext_csd previously read in 1 bit mode
1294 * against ext_csd at new bus width
1296 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
1297 err = mmc_compare_ext_csds(card, bus_width);
1299 err = mmc_bus_test(card, bus_width);
1305 pr_warn("%s: switch to bus width %d failed\n",
1306 mmc_hostname(host), ext_csd_bits[idx]);
1314 * Switch to the high-speed mode
1316 static int mmc_select_hs(struct mmc_card *card)
1320 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1321 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1322 card->ext_csd.generic_cmd6_time,
1325 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1331 * Activate wide bus and DDR if supported.
1333 static int mmc_select_hs_ddr(struct mmc_card *card)
1335 struct mmc_host *host = card->host;
1336 u32 bus_width, ext_csd_bits;
1339 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
1342 bus_width = host->ios.bus_width;
1343 if (bus_width == MMC_BUS_WIDTH_1)
1346 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1347 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1349 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1352 card->ext_csd.generic_cmd6_time);
1354 pr_warn("%s: switch to bus width %d ddr failed\n",
1355 mmc_hostname(host), 1 << bus_width);
1360 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1363 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1365 * 1.8V vccq at 3.3V core voltage (vcc) is not required
1366 * in the JEDEC spec for DDR.
1368 * Do not force change in vccq since we are obviously
1369 * working and no change to vccq is needed.
1371 * WARNING: eMMC rules are NOT the same as SD DDR
1373 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
1374 err = __mmc_set_signal_voltage(host,
1375 MMC_SIGNAL_VOLTAGE_120);
1380 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1385 static int mmc_select_hs400(struct mmc_card *card)
1387 struct mmc_host *host = card->host;
1391 * HS400 mode requires 8-bit bus width
1393 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1394 host->ios.bus_width == MMC_BUS_WIDTH_8))
1398 * Before switching to dual data rate operation for HS400,
1399 * it is required to convert from HS200 mode to HS mode.
1401 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1402 mmc_set_bus_speed(card);
1404 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1405 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1406 card->ext_csd.generic_cmd6_time,
1409 pr_warn("%s: switch to high-speed from hs200 failed, err:%d\n",
1410 mmc_hostname(host), err);
1414 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1416 EXT_CSD_DDR_BUS_WIDTH_8,
1417 card->ext_csd.generic_cmd6_time);
1419 pr_warn("%s: switch to bus width for hs400 failed, err:%d\n",
1420 mmc_hostname(host), err);
1424 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1425 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400,
1426 card->ext_csd.generic_cmd6_time,
1429 pr_warn("%s: switch to hs400 failed, err:%d\n",
1430 mmc_hostname(host), err);
1434 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1435 mmc_set_bus_speed(card);
1441 * For device supporting HS200 mode, the following sequence
1442 * should be done before executing the tuning process.
1443 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1444 * 2. switch to HS200 mode
1445 * 3. set the clock to > 52Mhz and <=200MHz
1447 static int mmc_select_hs200(struct mmc_card *card)
1449 struct mmc_host *host = card->host;
1452 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1453 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1455 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1456 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1458 /* If fails try again during next card power cycle */
1463 * Set the bus width(4 or 8) with host's support and
1464 * switch to HS200 mode if bus width is set successfully.
1466 err = mmc_select_bus_width(card);
1467 if (!IS_ERR_VALUE(err)) {
1468 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1469 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200,
1470 card->ext_csd.generic_cmd6_time,
1473 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1480 * Activate High Speed or HS200 mode if supported.
1482 static int mmc_select_timing(struct mmc_card *card)
1486 if ((card->csd.mmca_vsn < CSD_SPEC_VER_4 &&
1487 card->ext_csd.hs_max_dtr == 0))
1490 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
1491 err = mmc_select_hs200(card);
1492 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1493 err = mmc_select_hs(card);
1495 if (err && err != -EBADMSG)
1499 pr_warn("%s: switch to %s failed\n",
1500 mmc_card_hs(card) ? "high-speed" :
1501 (mmc_card_hs200(card) ? "hs200" : ""),
1502 mmc_hostname(card->host));
1508 * Set the bus speed to the selected bus timing.
1509 * If timing is not selected, backward compatible is the default.
1511 mmc_set_bus_speed(card);
1516 * Execute tuning sequence to seek the proper bus operating
1517 * conditions for HS200 and HS400, which sends CMD21 to the device.
1519 static int mmc_hs200_tuning(struct mmc_card *card)
1521 struct mmc_host *host = card->host;
1525 * Timing should be adjusted to the HS400 target
1526 * operation frequency for tuning process
1528 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1529 host->ios.bus_width == MMC_BUS_WIDTH_8)
1530 if (host->ops->prepare_hs400_tuning)
1531 host->ops->prepare_hs400_tuning(host, &host->ios);
1533 if (host->ops->execute_tuning) {
1534 mmc_host_clk_hold(host);
1535 err = host->ops->execute_tuning(host,
1536 MMC_SEND_TUNING_BLOCK_HS200);
1537 mmc_host_clk_release(host);
1540 pr_warn("%s: tuning execution failed\n",
1541 mmc_hostname(host));
1548 * Handle the detection and initialisation of a card.
1550 * In the case of a resume, "oldcard" will contain the card
1551 * we're trying to reinitialise.
1553 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1554 struct mmc_card *oldcard)
1556 struct mmc_card *card;
1563 WARN_ON(!host->claimed);
1565 /* Set correct bus mode for MMC before attempting init */
1566 if (!mmc_host_is_spi(host))
1567 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1570 * Since we're changing the OCR value, we seem to
1571 * need to tell some cards to go back to the idle
1572 * state. We wait 1ms to give cards time to
1574 * mmc_go_idle is needed for eMMC that are asleep
1578 /* The extra bit indicates that we support high capacity */
1579 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1584 * For SPI, enable CRC as appropriate.
1586 if (mmc_host_is_spi(host)) {
1587 err = mmc_spi_set_crc(host, use_spi_crc);
1593 * Fetch CID from card.
1595 if (mmc_host_is_spi(host))
1596 err = mmc_send_cid(host, cid);
1598 err = mmc_all_send_cid(host, cid);
1603 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1611 * Allocate card structure.
1613 card = mmc_alloc_card(host, &mmc_type);
1615 err = PTR_ERR(card);
1620 card->type = MMC_TYPE_MMC;
1622 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1626 * For native busses: set card RCA and quit open drain mode.
1628 if (!mmc_host_is_spi(host)) {
1629 err = mmc_set_relative_addr(card);
1633 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1638 * Fetch CSD from card.
1640 err = mmc_send_csd(card, card->raw_csd);
1644 err = mmc_decode_csd(card);
1647 err = mmc_decode_cid(card);
1653 * Select card, as all following commands rely on that.
1655 if (!mmc_host_is_spi(host)) {
1656 err = mmc_select_card(card);
1663 * Fetch and process extended CSD.
1666 err = mmc_get_ext_csd(card, &ext_csd);
1669 err = mmc_read_ext_csd(card, ext_csd);
1673 /* If doing byte addressing, check if required to do sector
1674 * addressing. Handle the case of <2GB cards needing sector
1675 * addressing. See section 8.1 JEDEC Standard JED84-A441;
1676 * ocr register has bit 30 set for sector addressing.
1678 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
1679 mmc_card_set_blockaddr(card);
1681 /* Erase size depends on CSD and Extended CSD */
1682 mmc_set_erase_size(card);
1686 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
1687 * bit. This bit will be lost every time after a reset or power off.
1689 if (card->ext_csd.enhanced_area_en ||
1690 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
1691 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1692 EXT_CSD_ERASE_GROUP_DEF, 1,
1693 card->ext_csd.generic_cmd6_time);
1695 if (err && err != -EBADMSG)
1701 * Just disable enhanced area off & sz
1702 * will try to enable ERASE_GROUP_DEF
1703 * during next time reinit
1705 card->ext_csd.enhanced_area_offset = -EINVAL;
1706 card->ext_csd.enhanced_area_size = -EINVAL;
1708 card->ext_csd.erase_group_def = 1;
1710 * enable ERASE_GRP_DEF successfully.
1711 * This will affect the erase size, so
1712 * here need to reset erase size
1714 mmc_set_erase_size(card);
1719 * Ensure eMMC user default partition is enabled
1721 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1722 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1723 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1724 card->ext_csd.part_config,
1725 card->ext_csd.part_time);
1726 if (err && err != -EBADMSG)
1731 * Enable power_off_notification byte in the ext_csd register
1733 if (card->ext_csd.rev >= 6) {
1734 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1735 EXT_CSD_POWER_OFF_NOTIFICATION,
1737 card->ext_csd.generic_cmd6_time);
1738 if (err && err != -EBADMSG)
1742 * The err can be -EBADMSG or 0,
1743 * so check for success and update the flag
1746 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1750 * Select timing interface
1752 err = mmc_select_timing(card);
1756 if (mmc_card_hs200(card)) {
1757 err = mmc_hs200_tuning(card);
1761 err = mmc_select_hs400(card);
1764 } else if (mmc_card_hs(card)) {
1765 /* Select the desired bus width optionally */
1766 err = mmc_select_bus_width(card);
1767 if (!IS_ERR_VALUE(err)) {
1768 err = mmc_select_hs_ddr(card);
1775 * Choose the power class with selected bus interface
1777 mmc_select_powerclass(card);
1780 * Enable HPI feature (if supported)
1782 if (card->ext_csd.hpi) {
1783 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1784 EXT_CSD_HPI_MGMT, 1,
1785 card->ext_csd.generic_cmd6_time);
1786 if (err && err != -EBADMSG)
1789 pr_warning("%s: Enabling HPI failed\n",
1790 mmc_hostname(card->host));
1793 card->ext_csd.hpi_en = 1;
1797 * If cache size is higher than 0, this indicates
1798 * the existence of cache and it can be turned on.
1800 if (card->ext_csd.cache_size > 0) {
1801 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1802 EXT_CSD_CACHE_CTRL, 1,
1803 card->ext_csd.generic_cmd6_time);
1804 if (err && err != -EBADMSG)
1808 * Only if no error, cache is turned on successfully.
1811 pr_warning("%s: Cache is supported, "
1812 "but failed to turn on (%d)\n",
1813 mmc_hostname(card->host), err);
1814 card->ext_csd.cache_ctrl = 0;
1817 card->ext_csd.cache_ctrl = 1;
1822 * The mandatory minimum values are defined for packed command.
1825 if (card->ext_csd.max_packed_writes >= 3 &&
1826 card->ext_csd.max_packed_reads >= 5 &&
1827 host->caps2 & MMC_CAP2_PACKED_CMD) {
1828 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1829 EXT_CSD_EXP_EVENTS_CTRL,
1830 EXT_CSD_PACKED_EVENT_EN,
1831 card->ext_csd.generic_cmd6_time);
1832 if (err && err != -EBADMSG)
1835 pr_warn("%s: Enabling packed event failed\n",
1836 mmc_hostname(card->host));
1837 card->ext_csd.packed_event_en = 0;
1840 card->ext_csd.packed_event_en = 1;
1847 mmc_free_ext_csd(ext_csd);
1852 mmc_remove_card(card);
1854 mmc_free_ext_csd(ext_csd);
1859 static int mmc_can_sleep(struct mmc_card *card)
1861 return (card && card->ext_csd.rev >= 3);
1864 static int mmc_sleep(struct mmc_host *host)
1866 struct mmc_command cmd = {0};
1867 struct mmc_card *card = host->card;
1868 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1871 err = mmc_deselect_cards(host);
1875 cmd.opcode = MMC_SLEEP_AWAKE;
1876 cmd.arg = card->rca << 16;
1880 * If the max_busy_timeout of the host is specified, validate it against
1881 * the sleep cmd timeout. A failure means we need to prevent the host
1882 * from doing hw busy detection, which is done by converting to a R1
1883 * response instead of a R1B.
1885 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1886 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1888 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1889 cmd.busy_timeout = timeout_ms;
1892 err = mmc_wait_for_cmd(host, &cmd, 0);
1897 * If the host does not wait while the card signals busy, then we will
1898 * will have to wait the sleep/awake timeout. Note, we cannot use the
1899 * SEND_STATUS command to poll the status because that command (and most
1900 * others) is invalid while the card sleeps.
1902 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1903 mmc_delay(timeout_ms);
1908 static int mmc_can_poweroff_notify(const struct mmc_card *card)
1911 mmc_card_mmc(card) &&
1912 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1915 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1917 unsigned int timeout = card->ext_csd.generic_cmd6_time;
1920 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1921 if (notify_type == EXT_CSD_POWER_OFF_LONG)
1922 timeout = card->ext_csd.power_off_longtime;
1924 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1925 EXT_CSD_POWER_OFF_NOTIFICATION,
1926 notify_type, timeout, true, false, false);
1928 pr_err("%s: Power Off Notification timed out, %u\n",
1929 mmc_hostname(card->host), timeout);
1931 /* Disable the power off notification after the switch operation. */
1932 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1938 * Host is being removed. Free up the current card.
1940 static void mmc_remove(struct mmc_host *host)
1943 BUG_ON(!host->card);
1945 mmc_remove_card(host->card);
1950 * Card detection - card is alive.
1952 static int mmc_alive(struct mmc_host *host)
1954 return mmc_send_status(host->card, NULL);
1958 * Card detection callback from host.
1960 static void mmc_detect(struct mmc_host *host)
1965 BUG_ON(!host->card);
1967 mmc_get_card(host->card);
1970 * Just check if our card has been removed.
1972 err = _mmc_detect_card_removed(host);
1974 mmc_put_card(host->card);
1979 mmc_claim_host(host);
1980 mmc_detach_bus(host);
1981 mmc_power_off(host);
1982 mmc_release_host(host);
1986 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
1989 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1990 EXT_CSD_POWER_OFF_LONG;
1993 BUG_ON(!host->card);
1995 mmc_claim_host(host);
1997 if (mmc_card_suspended(host->card))
2000 if (mmc_card_doing_bkops(host->card)) {
2001 err = mmc_stop_bkops(host->card);
2006 err = mmc_flush_cache(host->card);
2010 if (mmc_can_poweroff_notify(host->card) &&
2011 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
2012 err = mmc_poweroff_notify(host->card, notify_type);
2013 else if (mmc_can_sleep(host->card))
2014 err = mmc_sleep(host);
2015 else if (!mmc_host_is_spi(host))
2016 err = mmc_deselect_cards(host);
2019 mmc_power_off(host);
2020 mmc_card_set_suspended(host->card);
2023 mmc_release_host(host);
2030 static int mmc_suspend(struct mmc_host *host)
2034 err = _mmc_suspend(host, true);
2036 pm_runtime_disable(&host->card->dev);
2037 pm_runtime_set_suspended(&host->card->dev);
2044 * This function tries to determine if the same card is still present
2045 * and, if so, restore all state to it.
2047 static int _mmc_resume(struct mmc_host *host)
2052 BUG_ON(!host->card);
2054 mmc_claim_host(host);
2056 if (!mmc_card_suspended(host->card))
2059 mmc_power_up(host, host->card->ocr);
2060 err = mmc_init_card(host, host->card->ocr, host->card);
2061 mmc_card_clr_suspended(host->card);
2064 mmc_release_host(host);
2071 static int mmc_shutdown(struct mmc_host *host)
2076 * In a specific case for poweroff notify, we need to resume the card
2077 * before we can shutdown it properly.
2079 if (mmc_can_poweroff_notify(host->card) &&
2080 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
2081 err = _mmc_resume(host);
2084 err = _mmc_suspend(host, false);
2090 * Callback for resume.
2092 static int mmc_resume(struct mmc_host *host)
2096 if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
2097 err = _mmc_resume(host);
2098 pm_runtime_set_active(&host->card->dev);
2099 pm_runtime_mark_last_busy(&host->card->dev);
2101 pm_runtime_enable(&host->card->dev);
2107 * Callback for runtime_suspend.
2109 static int mmc_runtime_suspend(struct mmc_host *host)
2113 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
2116 err = _mmc_suspend(host, true);
2118 pr_err("%s: error %d doing aggessive suspend\n",
2119 mmc_hostname(host), err);
2125 * Callback for runtime_resume.
2127 static int mmc_runtime_resume(struct mmc_host *host)
2131 if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
2134 err = _mmc_resume(host);
2136 pr_err("%s: error %d doing aggessive resume\n",
2137 mmc_hostname(host), err);
2142 static int mmc_power_restore(struct mmc_host *host)
2146 mmc_claim_host(host);
2147 ret = mmc_init_card(host, host->card->ocr, host->card);
2148 mmc_release_host(host);
2153 static const struct mmc_bus_ops mmc_ops = {
2154 .remove = mmc_remove,
2155 .detect = mmc_detect,
2156 .suspend = mmc_suspend,
2157 .resume = mmc_resume,
2158 .runtime_suspend = mmc_runtime_suspend,
2159 .runtime_resume = mmc_runtime_resume,
2160 .power_restore = mmc_power_restore,
2162 .shutdown = mmc_shutdown,
2166 * Starting point for MMC card init.
2168 int mmc_attach_mmc(struct mmc_host *host)
2174 WARN_ON(!host->claimed);
2176 /* Set correct bus mode for MMC before attempting attach */
2177 if (!mmc_host_is_spi(host))
2178 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
2180 err = mmc_send_op_cond(host, 0, &ocr);
2184 mmc_attach_bus(host, &mmc_ops);
2185 if (host->ocr_avail_mmc)
2186 host->ocr_avail = host->ocr_avail_mmc;
2189 * We need to get OCR a different way for SPI.
2191 if (mmc_host_is_spi(host)) {
2192 err = mmc_spi_read_ocr(host, 1, &ocr);
2197 rocr = mmc_select_voltage(host, ocr);
2200 * Can we support the voltage of the card?
2208 * Detect and init the card.
2210 err = mmc_init_card(host, rocr, NULL);
2214 mmc_release_host(host);
2215 err = mmc_add_card(host->card);
2216 mmc_claim_host(host);
2223 mmc_release_host(host);
2224 mmc_remove_card(host->card);
2225 mmc_claim_host(host);
2228 mmc_detach_bus(host);
2230 pr_err("%s: error %d whilst initialising MMC card\n",
2231 mmc_hostname(host), err);