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>
17 #include <linux/mmc/host.h>
18 #include <linux/mmc/card.h>
19 #include <linux/mmc/mmc.h>
26 static const unsigned int tran_exp
[] = {
27 10000, 100000, 1000000, 10000000,
31 static const unsigned char tran_mant
[] = {
32 0, 10, 12, 13, 15, 20, 25, 30,
33 35, 40, 45, 50, 55, 60, 70, 80,
36 static const unsigned int tacc_exp
[] = {
37 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
40 static const unsigned int tacc_mant
[] = {
41 0, 10, 12, 13, 15, 20, 25, 30,
42 35, 40, 45, 50, 55, 60, 70, 80,
45 #define UNSTUFF_BITS(resp,start,size) \
47 const int __size = size; \
48 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
49 const int __off = 3 - ((start) / 32); \
50 const int __shft = (start) & 31; \
53 __res = resp[__off] >> __shft; \
54 if (__size + __shft > 32) \
55 __res |= resp[__off-1] << ((32 - __shft) % 32); \
60 * Given the decoded CSD structure, decode the raw CID to our CID structure.
62 static int mmc_decode_cid(struct mmc_card
*card
)
64 u32
*resp
= card
->raw_cid
;
67 * The selection of the format here is based upon published
68 * specs from sandisk and from what people have reported.
70 switch (card
->csd
.mmca_vsn
) {
71 case 0: /* MMC v1.0 - v1.2 */
72 case 1: /* MMC v1.4 */
73 card
->cid
.manfid
= UNSTUFF_BITS(resp
, 104, 24);
74 card
->cid
.prod_name
[0] = UNSTUFF_BITS(resp
, 96, 8);
75 card
->cid
.prod_name
[1] = UNSTUFF_BITS(resp
, 88, 8);
76 card
->cid
.prod_name
[2] = UNSTUFF_BITS(resp
, 80, 8);
77 card
->cid
.prod_name
[3] = UNSTUFF_BITS(resp
, 72, 8);
78 card
->cid
.prod_name
[4] = UNSTUFF_BITS(resp
, 64, 8);
79 card
->cid
.prod_name
[5] = UNSTUFF_BITS(resp
, 56, 8);
80 card
->cid
.prod_name
[6] = UNSTUFF_BITS(resp
, 48, 8);
81 card
->cid
.hwrev
= UNSTUFF_BITS(resp
, 44, 4);
82 card
->cid
.fwrev
= UNSTUFF_BITS(resp
, 40, 4);
83 card
->cid
.serial
= UNSTUFF_BITS(resp
, 16, 24);
84 card
->cid
.month
= UNSTUFF_BITS(resp
, 12, 4);
85 card
->cid
.year
= UNSTUFF_BITS(resp
, 8, 4) + 1997;
88 case 2: /* MMC v2.0 - v2.2 */
89 case 3: /* MMC v3.1 - v3.3 */
91 card
->cid
.manfid
= UNSTUFF_BITS(resp
, 120, 8);
92 card
->cid
.oemid
= UNSTUFF_BITS(resp
, 104, 16);
93 card
->cid
.prod_name
[0] = UNSTUFF_BITS(resp
, 96, 8);
94 card
->cid
.prod_name
[1] = UNSTUFF_BITS(resp
, 88, 8);
95 card
->cid
.prod_name
[2] = UNSTUFF_BITS(resp
, 80, 8);
96 card
->cid
.prod_name
[3] = UNSTUFF_BITS(resp
, 72, 8);
97 card
->cid
.prod_name
[4] = UNSTUFF_BITS(resp
, 64, 8);
98 card
->cid
.prod_name
[5] = UNSTUFF_BITS(resp
, 56, 8);
99 card
->cid
.serial
= UNSTUFF_BITS(resp
, 16, 32);
100 card
->cid
.month
= UNSTUFF_BITS(resp
, 12, 4);
101 card
->cid
.year
= UNSTUFF_BITS(resp
, 8, 4) + 1997;
105 pr_err("%s: card has unknown MMCA version %d\n",
106 mmc_hostname(card
->host
), card
->csd
.mmca_vsn
);
113 static void mmc_set_erase_size(struct mmc_card
*card
)
115 if (card
->ext_csd
.erase_group_def
& 1)
116 card
->erase_size
= card
->ext_csd
.hc_erase_size
;
118 card
->erase_size
= card
->csd
.erase_size
;
120 mmc_init_erase(card
);
124 * Given a 128-bit response, decode to our card CSD structure.
126 static int mmc_decode_csd(struct mmc_card
*card
)
128 struct mmc_csd
*csd
= &card
->csd
;
129 unsigned int e
, m
, a
, b
;
130 u32
*resp
= card
->raw_csd
;
133 * We only understand CSD structure v1.1 and v1.2.
134 * v1.2 has extra information in bits 15, 11 and 10.
135 * We also support eMMC v4.4 & v4.41.
137 csd
->structure
= UNSTUFF_BITS(resp
, 126, 2);
138 if (csd
->structure
== 0) {
139 pr_err("%s: unrecognised CSD structure version %d\n",
140 mmc_hostname(card
->host
), csd
->structure
);
144 csd
->mmca_vsn
= UNSTUFF_BITS(resp
, 122, 4);
145 m
= UNSTUFF_BITS(resp
, 115, 4);
146 e
= UNSTUFF_BITS(resp
, 112, 3);
147 csd
->tacc_ns
= (tacc_exp
[e
] * tacc_mant
[m
] + 9) / 10;
148 csd
->tacc_clks
= UNSTUFF_BITS(resp
, 104, 8) * 100;
150 m
= UNSTUFF_BITS(resp
, 99, 4);
151 e
= UNSTUFF_BITS(resp
, 96, 3);
152 csd
->max_dtr
= tran_exp
[e
] * tran_mant
[m
];
153 csd
->cmdclass
= UNSTUFF_BITS(resp
, 84, 12);
155 e
= UNSTUFF_BITS(resp
, 47, 3);
156 m
= UNSTUFF_BITS(resp
, 62, 12);
157 csd
->capacity
= (1 + m
) << (e
+ 2);
159 csd
->read_blkbits
= UNSTUFF_BITS(resp
, 80, 4);
160 csd
->read_partial
= UNSTUFF_BITS(resp
, 79, 1);
161 csd
->write_misalign
= UNSTUFF_BITS(resp
, 78, 1);
162 csd
->read_misalign
= UNSTUFF_BITS(resp
, 77, 1);
163 csd
->r2w_factor
= UNSTUFF_BITS(resp
, 26, 3);
164 csd
->write_blkbits
= UNSTUFF_BITS(resp
, 22, 4);
165 csd
->write_partial
= UNSTUFF_BITS(resp
, 21, 1);
167 if (csd
->write_blkbits
>= 9) {
168 a
= UNSTUFF_BITS(resp
, 42, 5);
169 b
= UNSTUFF_BITS(resp
, 37, 5);
170 csd
->erase_size
= (a
+ 1) * (b
+ 1);
171 csd
->erase_size
<<= csd
->write_blkbits
- 9;
180 static int mmc_get_ext_csd(struct mmc_card
*card
, u8
**new_ext_csd
)
186 BUG_ON(!new_ext_csd
);
190 if (card
->csd
.mmca_vsn
< CSD_SPEC_VER_4
)
194 * As the ext_csd is so large and mostly unused, we don't store the
195 * raw block in mmc_card.
197 ext_csd
= kmalloc(512, GFP_KERNEL
);
199 pr_err("%s: could not allocate a buffer to "
200 "receive the ext_csd.\n", mmc_hostname(card
->host
));
204 err
= mmc_send_ext_csd(card
, ext_csd
);
209 /* If the host or the card can't do the switch,
210 * fail more gracefully. */
217 * High capacity cards should have this "magic" size
218 * stored in their CSD.
220 if (card
->csd
.capacity
== (4096 * 512)) {
221 pr_err("%s: unable to read EXT_CSD "
222 "on a possible high capacity card. "
223 "Card will be ignored.\n",
224 mmc_hostname(card
->host
));
226 pr_warning("%s: unable to read "
227 "EXT_CSD, performance might "
229 mmc_hostname(card
->host
));
233 *new_ext_csd
= ext_csd
;
238 static void mmc_select_card_type(struct mmc_card
*card
)
240 struct mmc_host
*host
= card
->host
;
241 u8 card_type
= card
->ext_csd
.raw_card_type
& EXT_CSD_CARD_TYPE_MASK
;
242 unsigned int caps
= host
->caps
, caps2
= host
->caps2
;
243 unsigned int hs_max_dtr
= 0;
245 if (card_type
& EXT_CSD_CARD_TYPE_26
)
246 hs_max_dtr
= MMC_HIGH_26_MAX_DTR
;
248 if (caps
& MMC_CAP_MMC_HIGHSPEED
&&
249 card_type
& EXT_CSD_CARD_TYPE_52
)
250 hs_max_dtr
= MMC_HIGH_52_MAX_DTR
;
252 if ((caps
& MMC_CAP_1_8V_DDR
&&
253 card_type
& EXT_CSD_CARD_TYPE_DDR_1_8V
) ||
254 (caps
& MMC_CAP_1_2V_DDR
&&
255 card_type
& EXT_CSD_CARD_TYPE_DDR_1_2V
))
256 hs_max_dtr
= MMC_HIGH_DDR_MAX_DTR
;
258 if ((caps2
& MMC_CAP2_HS200_1_8V_SDR
&&
259 card_type
& EXT_CSD_CARD_TYPE_SDR_1_8V
) ||
260 (caps2
& MMC_CAP2_HS200_1_2V_SDR
&&
261 card_type
& EXT_CSD_CARD_TYPE_SDR_1_2V
))
262 hs_max_dtr
= MMC_HS200_MAX_DTR
;
264 card
->ext_csd
.hs_max_dtr
= hs_max_dtr
;
265 card
->ext_csd
.card_type
= card_type
;
269 * Decode extended CSD.
271 static int mmc_read_ext_csd(struct mmc_card
*card
, u8
*ext_csd
)
274 unsigned int part_size
;
275 u8 hc_erase_grp_sz
= 0, hc_wp_grp_sz
= 0;
282 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
283 card
->ext_csd
.raw_ext_csd_structure
= ext_csd
[EXT_CSD_STRUCTURE
];
284 if (card
->csd
.structure
== 3) {
285 if (card
->ext_csd
.raw_ext_csd_structure
> 2) {
286 pr_err("%s: unrecognised EXT_CSD structure "
287 "version %d\n", mmc_hostname(card
->host
),
288 card
->ext_csd
.raw_ext_csd_structure
);
294 card
->ext_csd
.rev
= ext_csd
[EXT_CSD_REV
];
295 if (card
->ext_csd
.rev
> 6) {
296 pr_err("%s: unrecognised EXT_CSD revision %d\n",
297 mmc_hostname(card
->host
), card
->ext_csd
.rev
);
302 card
->ext_csd
.raw_sectors
[0] = ext_csd
[EXT_CSD_SEC_CNT
+ 0];
303 card
->ext_csd
.raw_sectors
[1] = ext_csd
[EXT_CSD_SEC_CNT
+ 1];
304 card
->ext_csd
.raw_sectors
[2] = ext_csd
[EXT_CSD_SEC_CNT
+ 2];
305 card
->ext_csd
.raw_sectors
[3] = ext_csd
[EXT_CSD_SEC_CNT
+ 3];
306 if (card
->ext_csd
.rev
>= 2) {
307 card
->ext_csd
.sectors
=
308 ext_csd
[EXT_CSD_SEC_CNT
+ 0] << 0 |
309 ext_csd
[EXT_CSD_SEC_CNT
+ 1] << 8 |
310 ext_csd
[EXT_CSD_SEC_CNT
+ 2] << 16 |
311 ext_csd
[EXT_CSD_SEC_CNT
+ 3] << 24;
313 /* Cards with density > 2GiB are sector addressed */
314 if (card
->ext_csd
.sectors
> (2u * 1024 * 1024 * 1024) / 512)
315 mmc_card_set_blockaddr(card
);
318 card
->ext_csd
.raw_card_type
= ext_csd
[EXT_CSD_CARD_TYPE
];
319 mmc_select_card_type(card
);
321 card
->ext_csd
.raw_s_a_timeout
= ext_csd
[EXT_CSD_S_A_TIMEOUT
];
322 card
->ext_csd
.raw_erase_timeout_mult
=
323 ext_csd
[EXT_CSD_ERASE_TIMEOUT_MULT
];
324 card
->ext_csd
.raw_hc_erase_grp_size
=
325 ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
];
326 if (card
->ext_csd
.rev
>= 3) {
327 u8 sa_shift
= ext_csd
[EXT_CSD_S_A_TIMEOUT
];
328 card
->ext_csd
.part_config
= ext_csd
[EXT_CSD_PART_CONFIG
];
330 /* EXT_CSD value is in units of 10ms, but we store in ms */
331 card
->ext_csd
.part_time
= 10 * ext_csd
[EXT_CSD_PART_SWITCH_TIME
];
333 /* Sleep / awake timeout in 100ns units */
334 if (sa_shift
> 0 && sa_shift
<= 0x17)
335 card
->ext_csd
.sa_timeout
=
336 1 << ext_csd
[EXT_CSD_S_A_TIMEOUT
];
337 card
->ext_csd
.erase_group_def
=
338 ext_csd
[EXT_CSD_ERASE_GROUP_DEF
];
339 card
->ext_csd
.hc_erase_timeout
= 300 *
340 ext_csd
[EXT_CSD_ERASE_TIMEOUT_MULT
];
341 card
->ext_csd
.hc_erase_size
=
342 ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
] << 10;
344 card
->ext_csd
.rel_sectors
= ext_csd
[EXT_CSD_REL_WR_SEC_C
];
347 * There are two boot regions of equal size, defined in
350 if (ext_csd
[EXT_CSD_BOOT_MULT
] && mmc_boot_partition_access(card
->host
)) {
351 for (idx
= 0; idx
< MMC_NUM_BOOT_PARTITION
; idx
++) {
352 part_size
= ext_csd
[EXT_CSD_BOOT_MULT
] << 17;
353 mmc_part_add(card
, part_size
,
354 EXT_CSD_PART_CONFIG_ACC_BOOT0
+ idx
,
356 MMC_BLK_DATA_AREA_BOOT
);
361 card
->ext_csd
.raw_hc_erase_gap_size
=
362 ext_csd
[EXT_CSD_HC_WP_GRP_SIZE
];
363 card
->ext_csd
.raw_sec_trim_mult
=
364 ext_csd
[EXT_CSD_SEC_TRIM_MULT
];
365 card
->ext_csd
.raw_sec_erase_mult
=
366 ext_csd
[EXT_CSD_SEC_ERASE_MULT
];
367 card
->ext_csd
.raw_sec_feature_support
=
368 ext_csd
[EXT_CSD_SEC_FEATURE_SUPPORT
];
369 card
->ext_csd
.raw_trim_mult
=
370 ext_csd
[EXT_CSD_TRIM_MULT
];
371 if (card
->ext_csd
.rev
>= 4) {
373 * Enhanced area feature support -- check whether the eMMC
374 * card has the Enhanced area enabled. If so, export enhanced
375 * area offset and size to user by adding sysfs interface.
377 card
->ext_csd
.raw_partition_support
= ext_csd
[EXT_CSD_PARTITION_SUPPORT
];
378 if ((ext_csd
[EXT_CSD_PARTITION_SUPPORT
] & 0x2) &&
379 (ext_csd
[EXT_CSD_PARTITION_ATTRIBUTE
] & 0x1)) {
381 ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
];
383 ext_csd
[EXT_CSD_HC_WP_GRP_SIZE
];
385 card
->ext_csd
.enhanced_area_en
= 1;
387 * calculate the enhanced data area offset, in bytes
389 card
->ext_csd
.enhanced_area_offset
=
390 (ext_csd
[139] << 24) + (ext_csd
[138] << 16) +
391 (ext_csd
[137] << 8) + ext_csd
[136];
392 if (mmc_card_blockaddr(card
))
393 card
->ext_csd
.enhanced_area_offset
<<= 9;
395 * calculate the enhanced data area size, in kilobytes
397 card
->ext_csd
.enhanced_area_size
=
398 (ext_csd
[142] << 16) + (ext_csd
[141] << 8) +
400 card
->ext_csd
.enhanced_area_size
*=
401 (size_t)(hc_erase_grp_sz
* hc_wp_grp_sz
);
402 card
->ext_csd
.enhanced_area_size
<<= 9;
405 * If the enhanced area is not enabled, disable these
408 card
->ext_csd
.enhanced_area_offset
= -EINVAL
;
409 card
->ext_csd
.enhanced_area_size
= -EINVAL
;
413 * General purpose partition feature support --
414 * If ext_csd has the size of general purpose partitions,
415 * set size, part_cfg, partition name in mmc_part.
417 if (ext_csd
[EXT_CSD_PARTITION_SUPPORT
] &
418 EXT_CSD_PART_SUPPORT_PART_EN
) {
419 if (card
->ext_csd
.enhanced_area_en
!= 1) {
421 ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
];
423 ext_csd
[EXT_CSD_HC_WP_GRP_SIZE
];
425 card
->ext_csd
.enhanced_area_en
= 1;
428 for (idx
= 0; idx
< MMC_NUM_GP_PARTITION
; idx
++) {
429 if (!ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3] &&
430 !ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3 + 1] &&
431 !ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3 + 2])
434 (ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3 + 2]
436 (ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3 + 1]
438 ext_csd
[EXT_CSD_GP_SIZE_MULT
+ idx
* 3];
439 part_size
*= (size_t)(hc_erase_grp_sz
*
441 mmc_part_add(card
, part_size
<< 19,
442 EXT_CSD_PART_CONFIG_ACC_GP0
+ idx
,
444 MMC_BLK_DATA_AREA_GP
);
447 card
->ext_csd
.sec_trim_mult
=
448 ext_csd
[EXT_CSD_SEC_TRIM_MULT
];
449 card
->ext_csd
.sec_erase_mult
=
450 ext_csd
[EXT_CSD_SEC_ERASE_MULT
];
451 card
->ext_csd
.sec_feature_support
=
452 ext_csd
[EXT_CSD_SEC_FEATURE_SUPPORT
];
453 card
->ext_csd
.trim_timeout
= 300 *
454 ext_csd
[EXT_CSD_TRIM_MULT
];
457 * Note that the call to mmc_part_add above defaults to read
458 * only. If this default assumption is changed, the call must
459 * take into account the value of boot_locked below.
461 card
->ext_csd
.boot_ro_lock
= ext_csd
[EXT_CSD_BOOT_WP
];
462 card
->ext_csd
.boot_ro_lockable
= true;
465 if (card
->ext_csd
.rev
>= 5) {
466 /* check whether the eMMC card supports HPI */
467 if (ext_csd
[EXT_CSD_HPI_FEATURES
] & 0x1) {
468 card
->ext_csd
.hpi
= 1;
469 if (ext_csd
[EXT_CSD_HPI_FEATURES
] & 0x2)
470 card
->ext_csd
.hpi_cmd
= MMC_STOP_TRANSMISSION
;
472 card
->ext_csd
.hpi_cmd
= MMC_SEND_STATUS
;
474 * Indicate the maximum timeout to close
475 * a command interrupted by HPI
477 card
->ext_csd
.out_of_int_time
=
478 ext_csd
[EXT_CSD_OUT_OF_INTERRUPT_TIME
] * 10;
481 card
->ext_csd
.rel_param
= ext_csd
[EXT_CSD_WR_REL_PARAM
];
482 card
->ext_csd
.rst_n_function
= ext_csd
[EXT_CSD_RST_N_FUNCTION
];
485 card
->ext_csd
.raw_erased_mem_count
= ext_csd
[EXT_CSD_ERASED_MEM_CONT
];
486 if (ext_csd
[EXT_CSD_ERASED_MEM_CONT
])
487 card
->erased_byte
= 0xFF;
489 card
->erased_byte
= 0x0;
491 /* eMMC v4.5 or later */
492 if (card
->ext_csd
.rev
>= 6) {
493 card
->ext_csd
.feature_support
|= MMC_DISCARD_FEATURE
;
495 card
->ext_csd
.generic_cmd6_time
= 10 *
496 ext_csd
[EXT_CSD_GENERIC_CMD6_TIME
];
497 card
->ext_csd
.power_off_longtime
= 10 *
498 ext_csd
[EXT_CSD_POWER_OFF_LONG_TIME
];
500 card
->ext_csd
.cache_size
=
501 ext_csd
[EXT_CSD_CACHE_SIZE
+ 0] << 0 |
502 ext_csd
[EXT_CSD_CACHE_SIZE
+ 1] << 8 |
503 ext_csd
[EXT_CSD_CACHE_SIZE
+ 2] << 16 |
504 ext_csd
[EXT_CSD_CACHE_SIZE
+ 3] << 24;
506 if (ext_csd
[EXT_CSD_DATA_SECTOR_SIZE
] == 1)
507 card
->ext_csd
.data_sector_size
= 4096;
509 card
->ext_csd
.data_sector_size
= 512;
511 if ((ext_csd
[EXT_CSD_DATA_TAG_SUPPORT
] & 1) &&
512 (ext_csd
[EXT_CSD_TAG_UNIT_SIZE
] <= 8)) {
513 card
->ext_csd
.data_tag_unit_size
=
514 ((unsigned int) 1 << ext_csd
[EXT_CSD_TAG_UNIT_SIZE
]) *
515 (card
->ext_csd
.data_sector_size
);
517 card
->ext_csd
.data_tag_unit_size
= 0;
520 card
->ext_csd
.data_sector_size
= 512;
527 static inline void mmc_free_ext_csd(u8
*ext_csd
)
533 static int mmc_compare_ext_csds(struct mmc_card
*card
, unsigned bus_width
)
538 if (bus_width
== MMC_BUS_WIDTH_1
)
541 err
= mmc_get_ext_csd(card
, &bw_ext_csd
);
543 if (err
|| bw_ext_csd
== NULL
) {
548 /* only compare read only fields */
549 err
= !((card
->ext_csd
.raw_partition_support
==
550 bw_ext_csd
[EXT_CSD_PARTITION_SUPPORT
]) &&
551 (card
->ext_csd
.raw_erased_mem_count
==
552 bw_ext_csd
[EXT_CSD_ERASED_MEM_CONT
]) &&
553 (card
->ext_csd
.rev
==
554 bw_ext_csd
[EXT_CSD_REV
]) &&
555 (card
->ext_csd
.raw_ext_csd_structure
==
556 bw_ext_csd
[EXT_CSD_STRUCTURE
]) &&
557 (card
->ext_csd
.raw_card_type
==
558 bw_ext_csd
[EXT_CSD_CARD_TYPE
]) &&
559 (card
->ext_csd
.raw_s_a_timeout
==
560 bw_ext_csd
[EXT_CSD_S_A_TIMEOUT
]) &&
561 (card
->ext_csd
.raw_hc_erase_gap_size
==
562 bw_ext_csd
[EXT_CSD_HC_WP_GRP_SIZE
]) &&
563 (card
->ext_csd
.raw_erase_timeout_mult
==
564 bw_ext_csd
[EXT_CSD_ERASE_TIMEOUT_MULT
]) &&
565 (card
->ext_csd
.raw_hc_erase_grp_size
==
566 bw_ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
]) &&
567 (card
->ext_csd
.raw_sec_trim_mult
==
568 bw_ext_csd
[EXT_CSD_SEC_TRIM_MULT
]) &&
569 (card
->ext_csd
.raw_sec_erase_mult
==
570 bw_ext_csd
[EXT_CSD_SEC_ERASE_MULT
]) &&
571 (card
->ext_csd
.raw_sec_feature_support
==
572 bw_ext_csd
[EXT_CSD_SEC_FEATURE_SUPPORT
]) &&
573 (card
->ext_csd
.raw_trim_mult
==
574 bw_ext_csd
[EXT_CSD_TRIM_MULT
]) &&
575 (card
->ext_csd
.raw_sectors
[0] ==
576 bw_ext_csd
[EXT_CSD_SEC_CNT
+ 0]) &&
577 (card
->ext_csd
.raw_sectors
[1] ==
578 bw_ext_csd
[EXT_CSD_SEC_CNT
+ 1]) &&
579 (card
->ext_csd
.raw_sectors
[2] ==
580 bw_ext_csd
[EXT_CSD_SEC_CNT
+ 2]) &&
581 (card
->ext_csd
.raw_sectors
[3] ==
582 bw_ext_csd
[EXT_CSD_SEC_CNT
+ 3]));
587 mmc_free_ext_csd(bw_ext_csd
);
591 MMC_DEV_ATTR(cid
, "%08x%08x%08x%08x\n", card
->raw_cid
[0], card
->raw_cid
[1],
592 card
->raw_cid
[2], card
->raw_cid
[3]);
593 MMC_DEV_ATTR(csd
, "%08x%08x%08x%08x\n", card
->raw_csd
[0], card
->raw_csd
[1],
594 card
->raw_csd
[2], card
->raw_csd
[3]);
595 MMC_DEV_ATTR(date
, "%02d/%04d\n", card
->cid
.month
, card
->cid
.year
);
596 MMC_DEV_ATTR(erase_size
, "%u\n", card
->erase_size
<< 9);
597 MMC_DEV_ATTR(preferred_erase_size
, "%u\n", card
->pref_erase
<< 9);
598 MMC_DEV_ATTR(fwrev
, "0x%x\n", card
->cid
.fwrev
);
599 MMC_DEV_ATTR(hwrev
, "0x%x\n", card
->cid
.hwrev
);
600 MMC_DEV_ATTR(manfid
, "0x%06x\n", card
->cid
.manfid
);
601 MMC_DEV_ATTR(name
, "%s\n", card
->cid
.prod_name
);
602 MMC_DEV_ATTR(oemid
, "0x%04x\n", card
->cid
.oemid
);
603 MMC_DEV_ATTR(serial
, "0x%08x\n", card
->cid
.serial
);
604 MMC_DEV_ATTR(enhanced_area_offset
, "%llu\n",
605 card
->ext_csd
.enhanced_area_offset
);
606 MMC_DEV_ATTR(enhanced_area_size
, "%u\n", card
->ext_csd
.enhanced_area_size
);
608 static struct attribute
*mmc_std_attrs
[] = {
612 &dev_attr_erase_size
.attr
,
613 &dev_attr_preferred_erase_size
.attr
,
614 &dev_attr_fwrev
.attr
,
615 &dev_attr_hwrev
.attr
,
616 &dev_attr_manfid
.attr
,
618 &dev_attr_oemid
.attr
,
619 &dev_attr_serial
.attr
,
620 &dev_attr_enhanced_area_offset
.attr
,
621 &dev_attr_enhanced_area_size
.attr
,
625 static struct attribute_group mmc_std_attr_group
= {
626 .attrs
= mmc_std_attrs
,
629 static const struct attribute_group
*mmc_attr_groups
[] = {
634 static struct device_type mmc_type
= {
635 .groups
= mmc_attr_groups
,
639 * Select the PowerClass for the current bus width
640 * If power class is defined for 4/8 bit bus in the
641 * extended CSD register, select it by executing the
642 * mmc_switch command.
644 static int mmc_select_powerclass(struct mmc_card
*card
,
645 unsigned int bus_width
, u8
*ext_csd
)
648 unsigned int pwrclass_val
;
649 unsigned int index
= 0;
650 struct mmc_host
*host
;
660 /* Power class selection is supported for versions >= 4.0 */
661 if (card
->csd
.mmca_vsn
< CSD_SPEC_VER_4
)
664 /* Power class values are defined only for 4/8 bit bus */
665 if (bus_width
== EXT_CSD_BUS_WIDTH_1
)
668 switch (1 << host
->ios
.vdd
) {
669 case MMC_VDD_165_195
:
670 if (host
->ios
.clock
<= 26000000)
671 index
= EXT_CSD_PWR_CL_26_195
;
672 else if (host
->ios
.clock
<= 52000000)
673 index
= (bus_width
<= EXT_CSD_BUS_WIDTH_8
) ?
674 EXT_CSD_PWR_CL_52_195
:
675 EXT_CSD_PWR_CL_DDR_52_195
;
676 else if (host
->ios
.clock
<= 200000000)
677 index
= EXT_CSD_PWR_CL_200_195
;
688 if (host
->ios
.clock
<= 26000000)
689 index
= EXT_CSD_PWR_CL_26_360
;
690 else if (host
->ios
.clock
<= 52000000)
691 index
= (bus_width
<= EXT_CSD_BUS_WIDTH_8
) ?
692 EXT_CSD_PWR_CL_52_360
:
693 EXT_CSD_PWR_CL_DDR_52_360
;
694 else if (host
->ios
.clock
<= 200000000)
695 index
= EXT_CSD_PWR_CL_200_360
;
698 pr_warning("%s: Voltage range not supported "
699 "for power class.\n", mmc_hostname(host
));
703 pwrclass_val
= ext_csd
[index
];
705 if (bus_width
& (EXT_CSD_BUS_WIDTH_8
| EXT_CSD_DDR_BUS_WIDTH_8
))
706 pwrclass_val
= (pwrclass_val
& EXT_CSD_PWR_CL_8BIT_MASK
) >>
707 EXT_CSD_PWR_CL_8BIT_SHIFT
;
709 pwrclass_val
= (pwrclass_val
& EXT_CSD_PWR_CL_4BIT_MASK
) >>
710 EXT_CSD_PWR_CL_4BIT_SHIFT
;
712 /* If the power class is different from the default value */
713 if (pwrclass_val
> 0) {
714 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
717 card
->ext_csd
.generic_cmd6_time
);
721 pr_err("%s: power class selection for ext_csd_bus_width %d"
722 " failed\n", mmc_hostname(card
->host
), bus_width
);
728 * Selects the desired buswidth and switch to the HS200 mode
729 * if bus width set without error
731 static int mmc_select_hs200(struct mmc_card
*card
)
733 int idx
, err
= -EINVAL
;
734 struct mmc_host
*host
;
735 static unsigned ext_csd_bits
[] = {
739 static unsigned bus_widths
[] = {
748 if (card
->ext_csd
.card_type
& EXT_CSD_CARD_TYPE_SDR_1_2V
&&
749 host
->caps2
& MMC_CAP2_HS200_1_2V_SDR
)
750 err
= mmc_set_signal_voltage(host
, MMC_SIGNAL_VOLTAGE_120
, 0);
752 if (err
&& card
->ext_csd
.card_type
& EXT_CSD_CARD_TYPE_SDR_1_8V
&&
753 host
->caps2
& MMC_CAP2_HS200_1_8V_SDR
)
754 err
= mmc_set_signal_voltage(host
, MMC_SIGNAL_VOLTAGE_180
, 0);
756 /* If fails try again during next card power cycle */
760 idx
= (host
->caps
& MMC_CAP_8_BIT_DATA
) ? 1 : 0;
763 * Unlike SD, MMC cards dont have a configuration register to notify
764 * supported bus width. So bus test command should be run to identify
765 * the supported bus width or compare the ext csd values of current
766 * bus width and ext csd values of 1 bit mode read earlier.
768 for (; idx
>= 0; idx
--) {
771 * Host is capable of 8bit transfer, then switch
772 * the device to work in 8bit transfer mode. If the
773 * mmc switch command returns error then switch to
774 * 4bit transfer mode. On success set the corresponding
775 * bus width on the host.
777 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
780 card
->ext_csd
.generic_cmd6_time
);
784 mmc_set_bus_width(card
->host
, bus_widths
[idx
]);
786 if (!(host
->caps
& MMC_CAP_BUS_WIDTH_TEST
))
787 err
= mmc_compare_ext_csds(card
, bus_widths
[idx
]);
789 err
= mmc_bus_test(card
, bus_widths
[idx
]);
794 /* switch to HS200 mode if bus width set successfully */
796 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
797 EXT_CSD_HS_TIMING
, 2, 0);
803 * Handle the detection and initialisation of a card.
805 * In the case of a resume, "oldcard" will contain the card
806 * we're trying to reinitialise.
808 static int mmc_init_card(struct mmc_host
*host
, u32 ocr
,
809 struct mmc_card
*oldcard
)
811 struct mmc_card
*card
;
814 unsigned int max_dtr
;
819 WARN_ON(!host
->claimed
);
821 /* Set correct bus mode for MMC before attempting init */
822 if (!mmc_host_is_spi(host
))
823 mmc_set_bus_mode(host
, MMC_BUSMODE_OPENDRAIN
);
825 /* Initialization should be done at 3.3 V I/O voltage. */
826 mmc_set_signal_voltage(host
, MMC_SIGNAL_VOLTAGE_330
, 0);
829 * Since we're changing the OCR value, we seem to
830 * need to tell some cards to go back to the idle
831 * state. We wait 1ms to give cards time to
833 * mmc_go_idle is needed for eMMC that are asleep
837 /* The extra bit indicates that we support high capacity */
838 err
= mmc_send_op_cond(host
, ocr
| (1 << 30), &rocr
);
843 * For SPI, enable CRC as appropriate.
845 if (mmc_host_is_spi(host
)) {
846 err
= mmc_spi_set_crc(host
, use_spi_crc
);
852 * Fetch CID from card.
854 if (mmc_host_is_spi(host
))
855 err
= mmc_send_cid(host
, cid
);
857 err
= mmc_all_send_cid(host
, cid
);
862 if (memcmp(cid
, oldcard
->raw_cid
, sizeof(cid
)) != 0) {
870 * Allocate card structure.
872 card
= mmc_alloc_card(host
, &mmc_type
);
878 card
->type
= MMC_TYPE_MMC
;
880 memcpy(card
->raw_cid
, cid
, sizeof(card
->raw_cid
));
884 * For native busses: set card RCA and quit open drain mode.
886 if (!mmc_host_is_spi(host
)) {
887 err
= mmc_set_relative_addr(card
);
891 mmc_set_bus_mode(host
, MMC_BUSMODE_PUSHPULL
);
896 * Fetch CSD from card.
898 err
= mmc_send_csd(card
, card
->raw_csd
);
902 err
= mmc_decode_csd(card
);
905 err
= mmc_decode_cid(card
);
911 * Select card, as all following commands rely on that.
913 if (!mmc_host_is_spi(host
)) {
914 err
= mmc_select_card(card
);
921 * Fetch and process extended CSD.
924 err
= mmc_get_ext_csd(card
, &ext_csd
);
927 err
= mmc_read_ext_csd(card
, ext_csd
);
931 /* If doing byte addressing, check if required to do sector
932 * addressing. Handle the case of <2GB cards needing sector
933 * addressing. See section 8.1 JEDEC Standard JED84-A441;
934 * ocr register has bit 30 set for sector addressing.
936 if (!(mmc_card_blockaddr(card
)) && (rocr
& (1<<30)))
937 mmc_card_set_blockaddr(card
);
939 /* Erase size depends on CSD and Extended CSD */
940 mmc_set_erase_size(card
);
944 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
945 * bit. This bit will be lost every time after a reset or power off.
947 if (card
->ext_csd
.enhanced_area_en
||
948 (card
->ext_csd
.rev
>= 3 && (host
->caps2
& MMC_CAP2_HC_ERASE_SZ
))) {
949 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
950 EXT_CSD_ERASE_GROUP_DEF
, 1,
951 card
->ext_csd
.generic_cmd6_time
);
953 if (err
&& err
!= -EBADMSG
)
959 * Just disable enhanced area off & sz
960 * will try to enable ERASE_GROUP_DEF
961 * during next time reinit
963 card
->ext_csd
.enhanced_area_offset
= -EINVAL
;
964 card
->ext_csd
.enhanced_area_size
= -EINVAL
;
966 card
->ext_csd
.erase_group_def
= 1;
968 * enable ERASE_GRP_DEF successfully.
969 * This will affect the erase size, so
970 * here need to reset erase size
972 mmc_set_erase_size(card
);
977 * Ensure eMMC user default partition is enabled
979 if (card
->ext_csd
.part_config
& EXT_CSD_PART_CONFIG_ACC_MASK
) {
980 card
->ext_csd
.part_config
&= ~EXT_CSD_PART_CONFIG_ACC_MASK
;
981 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
, EXT_CSD_PART_CONFIG
,
982 card
->ext_csd
.part_config
,
983 card
->ext_csd
.part_time
);
984 if (err
&& err
!= -EBADMSG
)
989 * If the host supports the power_off_notify capability then
990 * set the notification byte in the ext_csd register of device
992 if ((host
->caps2
& MMC_CAP2_POWEROFF_NOTIFY
) &&
993 (card
->ext_csd
.rev
>= 6)) {
994 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
995 EXT_CSD_POWER_OFF_NOTIFICATION
,
997 card
->ext_csd
.generic_cmd6_time
);
998 if (err
&& err
!= -EBADMSG
)
1002 * The err can be -EBADMSG or 0,
1003 * so check for success and update the flag
1006 card
->poweroff_notify_state
= MMC_POWERED_ON
;
1010 * Activate high speed (if supported)
1012 if (card
->ext_csd
.hs_max_dtr
!= 0) {
1014 if (card
->ext_csd
.hs_max_dtr
> 52000000 &&
1015 host
->caps2
& MMC_CAP2_HS200
)
1016 err
= mmc_select_hs200(card
);
1017 else if (host
->caps
& MMC_CAP_MMC_HIGHSPEED
)
1018 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
1019 EXT_CSD_HS_TIMING
, 1,
1020 card
->ext_csd
.generic_cmd6_time
);
1022 if (err
&& err
!= -EBADMSG
)
1026 pr_warning("%s: switch to highspeed failed\n",
1027 mmc_hostname(card
->host
));
1030 if (card
->ext_csd
.hs_max_dtr
> 52000000 &&
1031 host
->caps2
& MMC_CAP2_HS200
) {
1032 mmc_card_set_hs200(card
);
1033 mmc_set_timing(card
->host
,
1034 MMC_TIMING_MMC_HS200
);
1036 mmc_card_set_highspeed(card
);
1037 mmc_set_timing(card
->host
, MMC_TIMING_MMC_HS
);
1043 * Compute bus speed.
1045 max_dtr
= (unsigned int)-1;
1047 if (mmc_card_highspeed(card
) || mmc_card_hs200(card
)) {
1048 if (max_dtr
> card
->ext_csd
.hs_max_dtr
)
1049 max_dtr
= card
->ext_csd
.hs_max_dtr
;
1050 } else if (max_dtr
> card
->csd
.max_dtr
) {
1051 max_dtr
= card
->csd
.max_dtr
;
1054 mmc_set_clock(host
, max_dtr
);
1057 * Indicate DDR mode (if supported).
1059 if (mmc_card_highspeed(card
)) {
1060 if ((card
->ext_csd
.card_type
& EXT_CSD_CARD_TYPE_DDR_1_8V
)
1061 && ((host
->caps
& (MMC_CAP_1_8V_DDR
|
1063 == (MMC_CAP_1_8V_DDR
| MMC_CAP_UHS_DDR50
)))
1064 ddr
= MMC_1_8V_DDR_MODE
;
1065 else if ((card
->ext_csd
.card_type
& EXT_CSD_CARD_TYPE_DDR_1_2V
)
1066 && ((host
->caps
& (MMC_CAP_1_2V_DDR
|
1068 == (MMC_CAP_1_2V_DDR
| MMC_CAP_UHS_DDR50
)))
1069 ddr
= MMC_1_2V_DDR_MODE
;
1073 * Indicate HS200 SDR mode (if supported).
1075 if (mmc_card_hs200(card
)) {
1077 u32 bus_width
= card
->host
->ios
.bus_width
;
1080 * For devices supporting HS200 mode, the bus width has
1081 * to be set before executing the tuning function. If
1082 * set before tuning, then device will respond with CRC
1083 * errors for responses on CMD line. So for HS200 the
1085 * 1. set bus width 4bit / 8 bit (1 bit not supported)
1086 * 2. switch to HS200 mode
1087 * 3. set the clock to > 52Mhz <=200MHz and
1088 * 4. execute tuning for HS200
1090 if ((host
->caps2
& MMC_CAP2_HS200
) &&
1091 card
->host
->ops
->execute_tuning
) {
1092 mmc_host_clk_hold(card
->host
);
1093 err
= card
->host
->ops
->execute_tuning(card
->host
,
1094 MMC_SEND_TUNING_BLOCK_HS200
);
1095 mmc_host_clk_release(card
->host
);
1098 pr_warning("%s: tuning execution failed\n",
1099 mmc_hostname(card
->host
));
1103 ext_csd_bits
= (bus_width
== MMC_BUS_WIDTH_8
) ?
1104 EXT_CSD_BUS_WIDTH_8
: EXT_CSD_BUS_WIDTH_4
;
1105 err
= mmc_select_powerclass(card
, ext_csd_bits
, ext_csd
);
1111 * Activate wide bus and DDR (if supported).
1113 if (!mmc_card_hs200(card
) &&
1114 (card
->csd
.mmca_vsn
>= CSD_SPEC_VER_4
) &&
1115 (host
->caps
& (MMC_CAP_4_BIT_DATA
| MMC_CAP_8_BIT_DATA
))) {
1116 static unsigned ext_csd_bits
[][2] = {
1117 { EXT_CSD_BUS_WIDTH_8
, EXT_CSD_DDR_BUS_WIDTH_8
},
1118 { EXT_CSD_BUS_WIDTH_4
, EXT_CSD_DDR_BUS_WIDTH_4
},
1119 { EXT_CSD_BUS_WIDTH_1
, EXT_CSD_BUS_WIDTH_1
},
1121 static unsigned bus_widths
[] = {
1126 unsigned idx
, bus_width
= 0;
1128 if (host
->caps
& MMC_CAP_8_BIT_DATA
)
1132 for (; idx
< ARRAY_SIZE(bus_widths
); idx
++) {
1133 bus_width
= bus_widths
[idx
];
1134 if (bus_width
== MMC_BUS_WIDTH_1
)
1135 ddr
= 0; /* no DDR for 1-bit width */
1136 err
= mmc_select_powerclass(card
, ext_csd_bits
[idx
][0],
1141 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
1143 ext_csd_bits
[idx
][0],
1144 card
->ext_csd
.generic_cmd6_time
);
1146 mmc_set_bus_width(card
->host
, bus_width
);
1149 * If controller can't handle bus width test,
1150 * compare ext_csd previously read in 1 bit mode
1151 * against ext_csd at new bus width
1153 if (!(host
->caps
& MMC_CAP_BUS_WIDTH_TEST
))
1154 err
= mmc_compare_ext_csds(card
,
1157 err
= mmc_bus_test(card
, bus_width
);
1164 err
= mmc_select_powerclass(card
, ext_csd_bits
[idx
][1],
1169 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
1171 ext_csd_bits
[idx
][1],
1172 card
->ext_csd
.generic_cmd6_time
);
1175 pr_warning("%s: switch to bus width %d ddr %d "
1176 "failed\n", mmc_hostname(card
->host
),
1177 1 << bus_width
, ddr
);
1181 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1184 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1186 * 1.8V vccq at 3.3V core voltage (vcc) is not required
1187 * in the JEDEC spec for DDR.
1189 * Do not force change in vccq since we are obviously
1190 * working and no change to vccq is needed.
1192 * WARNING: eMMC rules are NOT the same as SD DDR
1194 if (ddr
== MMC_1_2V_DDR_MODE
) {
1195 err
= mmc_set_signal_voltage(host
,
1196 MMC_SIGNAL_VOLTAGE_120
, 0);
1200 mmc_card_set_ddr_mode(card
);
1201 mmc_set_timing(card
->host
, MMC_TIMING_UHS_DDR50
);
1202 mmc_set_bus_width(card
->host
, bus_width
);
1207 * Enable HPI feature (if supported)
1209 if (card
->ext_csd
.hpi
) {
1210 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
1211 EXT_CSD_HPI_MGMT
, 1,
1212 card
->ext_csd
.generic_cmd6_time
);
1213 if (err
&& err
!= -EBADMSG
)
1216 pr_warning("%s: Enabling HPI failed\n",
1217 mmc_hostname(card
->host
));
1220 card
->ext_csd
.hpi_en
= 1;
1224 * If cache size is higher than 0, this indicates
1225 * the existence of cache and it can be turned on.
1227 if ((host
->caps2
& MMC_CAP2_CACHE_CTRL
) &&
1228 card
->ext_csd
.cache_size
> 0) {
1229 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
1230 EXT_CSD_CACHE_CTRL
, 1,
1231 card
->ext_csd
.generic_cmd6_time
);
1232 if (err
&& err
!= -EBADMSG
)
1236 * Only if no error, cache is turned on successfully.
1239 pr_warning("%s: Cache is supported, "
1240 "but failed to turn on (%d)\n",
1241 mmc_hostname(card
->host
), err
);
1242 card
->ext_csd
.cache_ctrl
= 0;
1245 card
->ext_csd
.cache_ctrl
= 1;
1252 mmc_free_ext_csd(ext_csd
);
1257 mmc_remove_card(card
);
1259 mmc_free_ext_csd(ext_csd
);
1265 * Host is being removed. Free up the current card.
1267 static void mmc_remove(struct mmc_host
*host
)
1270 BUG_ON(!host
->card
);
1272 mmc_remove_card(host
->card
);
1277 * Card detection - card is alive.
1279 static int mmc_alive(struct mmc_host
*host
)
1281 return mmc_send_status(host
->card
, NULL
);
1285 * Card detection callback from host.
1287 static void mmc_detect(struct mmc_host
*host
)
1292 BUG_ON(!host
->card
);
1294 mmc_claim_host(host
);
1297 * Just check if our card has been removed.
1299 err
= _mmc_detect_card_removed(host
);
1301 mmc_release_host(host
);
1306 mmc_claim_host(host
);
1307 mmc_detach_bus(host
);
1308 mmc_power_off(host
);
1309 mmc_release_host(host
);
1314 * Suspend callback from host.
1316 static int mmc_suspend(struct mmc_host
*host
)
1321 BUG_ON(!host
->card
);
1323 mmc_claim_host(host
);
1324 if (mmc_card_can_sleep(host
)) {
1325 err
= mmc_card_sleep(host
);
1327 mmc_card_set_sleep(host
->card
);
1328 } else if (!mmc_host_is_spi(host
))
1329 err
= mmc_deselect_cards(host
);
1330 host
->card
->state
&= ~(MMC_STATE_HIGHSPEED
| MMC_STATE_HIGHSPEED_200
);
1331 mmc_release_host(host
);
1337 * Resume callback from host.
1339 * This function tries to determine if the same card is still present
1340 * and, if so, restore all state to it.
1342 static int mmc_resume(struct mmc_host
*host
)
1347 BUG_ON(!host
->card
);
1349 mmc_claim_host(host
);
1350 if (mmc_card_is_sleep(host
->card
)) {
1351 err
= mmc_card_awake(host
);
1352 mmc_card_clr_sleep(host
->card
);
1354 err
= mmc_init_card(host
, host
->ocr
, host
->card
);
1355 mmc_release_host(host
);
1360 static int mmc_power_restore(struct mmc_host
*host
)
1364 host
->card
->state
&= ~(MMC_STATE_HIGHSPEED
| MMC_STATE_HIGHSPEED_200
);
1365 mmc_card_clr_sleep(host
->card
);
1366 mmc_claim_host(host
);
1367 ret
= mmc_init_card(host
, host
->ocr
, host
->card
);
1368 mmc_release_host(host
);
1373 static int mmc_sleep(struct mmc_host
*host
)
1375 struct mmc_card
*card
= host
->card
;
1378 if (card
&& card
->ext_csd
.rev
>= 3) {
1379 err
= mmc_card_sleepawake(host
, 1);
1381 pr_debug("%s: Error %d while putting card into sleep",
1382 mmc_hostname(host
), err
);
1388 static int mmc_awake(struct mmc_host
*host
)
1390 struct mmc_card
*card
= host
->card
;
1393 if (card
&& card
->ext_csd
.rev
>= 3) {
1394 err
= mmc_card_sleepawake(host
, 0);
1396 pr_debug("%s: Error %d while awaking sleeping card",
1397 mmc_hostname(host
), err
);
1403 static const struct mmc_bus_ops mmc_ops
= {
1406 .remove
= mmc_remove
,
1407 .detect
= mmc_detect
,
1410 .power_restore
= mmc_power_restore
,
1414 static const struct mmc_bus_ops mmc_ops_unsafe
= {
1417 .remove
= mmc_remove
,
1418 .detect
= mmc_detect
,
1419 .suspend
= mmc_suspend
,
1420 .resume
= mmc_resume
,
1421 .power_restore
= mmc_power_restore
,
1425 static void mmc_attach_bus_ops(struct mmc_host
*host
)
1427 const struct mmc_bus_ops
*bus_ops
;
1429 if (!mmc_card_is_removable(host
))
1430 bus_ops
= &mmc_ops_unsafe
;
1433 mmc_attach_bus(host
, bus_ops
);
1437 * Starting point for MMC card init.
1439 int mmc_attach_mmc(struct mmc_host
*host
)
1445 WARN_ON(!host
->claimed
);
1447 /* Set correct bus mode for MMC before attempting attach */
1448 if (!mmc_host_is_spi(host
))
1449 mmc_set_bus_mode(host
, MMC_BUSMODE_OPENDRAIN
);
1451 err
= mmc_send_op_cond(host
, 0, &ocr
);
1455 mmc_attach_bus_ops(host
);
1456 if (host
->ocr_avail_mmc
)
1457 host
->ocr_avail
= host
->ocr_avail_mmc
;
1460 * We need to get OCR a different way for SPI.
1462 if (mmc_host_is_spi(host
)) {
1463 err
= mmc_spi_read_ocr(host
, 1, &ocr
);
1469 * Sanity check the voltages that the card claims to
1473 pr_warning("%s: card claims to support voltages "
1474 "below the defined range. These will be ignored.\n",
1475 mmc_hostname(host
));
1479 host
->ocr
= mmc_select_voltage(host
, ocr
);
1482 * Can we support the voltage of the card?
1490 * Detect and init the card.
1492 err
= mmc_init_card(host
, host
->ocr
, NULL
);
1496 mmc_release_host(host
);
1497 err
= mmc_add_card(host
->card
);
1498 mmc_claim_host(host
);
1505 mmc_release_host(host
);
1506 mmc_remove_card(host
->card
);
1507 mmc_claim_host(host
);
1510 mmc_detach_bus(host
);
1512 pr_err("%s: error %d whilst initialising MMC card\n",
1513 mmc_hostname(host
), err
);