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->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
166 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
167 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
168 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
170 if (csd->write_blkbits >= 9) {
171 a = UNSTUFF_BITS(resp, 42, 5);
172 b = UNSTUFF_BITS(resp, 37, 5);
173 csd->erase_size = (a + 1) * (b + 1);
174 csd->erase_size <<= csd->write_blkbits - 9;
183 static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
189 BUG_ON(!new_ext_csd);
193 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
197 * As the ext_csd is so large and mostly unused, we don't store the
198 * raw block in mmc_card.
200 ext_csd = kmalloc(512, GFP_KERNEL);
202 pr_err("%s: could not allocate a buffer to "
203 "receive the ext_csd.\n", mmc_hostname(card->host));
207 err = mmc_send_ext_csd(card, ext_csd);
212 /* If the host or the card can't do the switch,
213 * fail more gracefully. */
220 * High capacity cards should have this "magic" size
221 * stored in their CSD.
223 if (card->csd.capacity == (4096 * 512)) {
224 pr_err("%s: unable to read EXT_CSD "
225 "on a possible high capacity card. "
226 "Card will be ignored.\n",
227 mmc_hostname(card->host));
229 pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
230 mmc_hostname(card->host));
234 *new_ext_csd = ext_csd;
239 static void mmc_select_card_type(struct mmc_card *card)
241 struct mmc_host *host = card->host;
242 u8 card_type = card->ext_csd.raw_card_type;
243 u32 caps = host->caps, caps2 = host->caps2;
244 unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
245 unsigned int avail_type = 0;
247 if (caps & MMC_CAP_MMC_HIGHSPEED &&
248 card_type & EXT_CSD_CARD_TYPE_HS_26) {
249 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
250 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
253 if (caps & MMC_CAP_MMC_HIGHSPEED &&
254 card_type & EXT_CSD_CARD_TYPE_HS_52) {
255 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
256 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
259 if (caps & MMC_CAP_1_8V_DDR &&
260 card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
261 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
262 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
265 if (caps & MMC_CAP_1_2V_DDR &&
266 card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
267 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
268 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
271 if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
272 card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
273 hs200_max_dtr = MMC_HS200_MAX_DTR;
274 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
277 if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
278 card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
279 hs200_max_dtr = MMC_HS200_MAX_DTR;
280 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
283 if (caps2 & MMC_CAP2_HS400_1_8V &&
284 card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
285 hs200_max_dtr = MMC_HS200_MAX_DTR;
286 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
289 if (caps2 & MMC_CAP2_HS400_1_2V &&
290 card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
291 hs200_max_dtr = MMC_HS200_MAX_DTR;
292 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
295 card->ext_csd.hs_max_dtr = hs_max_dtr;
296 card->ext_csd.hs200_max_dtr = hs200_max_dtr;
297 card->mmc_avail_type = avail_type;
300 static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
302 u8 hc_erase_grp_sz, hc_wp_grp_sz;
305 * Disable these attributes by default
307 card->ext_csd.enhanced_area_offset = -EINVAL;
308 card->ext_csd.enhanced_area_size = -EINVAL;
311 * Enhanced area feature support -- check whether the eMMC
312 * card has the Enhanced area enabled. If so, export enhanced
313 * area offset and size to user by adding sysfs interface.
315 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
316 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
317 if (card->ext_csd.partition_setting_completed) {
319 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
321 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
324 * calculate the enhanced data area offset, in bytes
326 card->ext_csd.enhanced_area_offset =
327 (ext_csd[139] << 24) + (ext_csd[138] << 16) +
328 (ext_csd[137] << 8) + ext_csd[136];
329 if (mmc_card_blockaddr(card))
330 card->ext_csd.enhanced_area_offset <<= 9;
332 * calculate the enhanced data area size, in kilobytes
334 card->ext_csd.enhanced_area_size =
335 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
337 card->ext_csd.enhanced_area_size *=
338 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
339 card->ext_csd.enhanced_area_size <<= 9;
341 pr_warn("%s: defines enhanced area without partition setting complete\n",
342 mmc_hostname(card->host));
347 static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
350 u8 hc_erase_grp_sz, hc_wp_grp_sz;
351 unsigned int part_size;
354 * General purpose partition feature support --
355 * If ext_csd has the size of general purpose partitions,
356 * set size, part_cfg, partition name in mmc_part.
358 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
359 EXT_CSD_PART_SUPPORT_PART_EN) {
361 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
363 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
365 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
366 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
367 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
368 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
370 if (card->ext_csd.partition_setting_completed == 0) {
371 pr_warn("%s: has partition size defined without partition complete\n",
372 mmc_hostname(card->host));
376 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
378 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
380 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
381 part_size *= (size_t)(hc_erase_grp_sz *
383 mmc_part_add(card, part_size << 19,
384 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
386 MMC_BLK_DATA_AREA_GP);
392 * Decode extended CSD.
394 static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
397 unsigned int part_size;
404 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
405 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
406 if (card->csd.structure == 3) {
407 if (card->ext_csd.raw_ext_csd_structure > 2) {
408 pr_err("%s: unrecognised EXT_CSD structure "
409 "version %d\n", mmc_hostname(card->host),
410 card->ext_csd.raw_ext_csd_structure);
417 * The EXT_CSD format is meant to be forward compatible. As long
418 * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
419 * are authorized, see JEDEC JESD84-B50 section B.8.
421 card->ext_csd.rev = ext_csd[EXT_CSD_REV];
423 card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
424 card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
425 card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
426 card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
427 if (card->ext_csd.rev >= 2) {
428 card->ext_csd.sectors =
429 ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
430 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
431 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
432 ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
434 /* Cards with density > 2GiB are sector addressed */
435 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
436 mmc_card_set_blockaddr(card);
439 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
440 mmc_select_card_type(card);
442 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
443 card->ext_csd.raw_erase_timeout_mult =
444 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
445 card->ext_csd.raw_hc_erase_grp_size =
446 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
447 if (card->ext_csd.rev >= 3) {
448 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
449 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
451 /* EXT_CSD value is in units of 10ms, but we store in ms */
452 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
454 /* Sleep / awake timeout in 100ns units */
455 if (sa_shift > 0 && sa_shift <= 0x17)
456 card->ext_csd.sa_timeout =
457 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
458 card->ext_csd.erase_group_def =
459 ext_csd[EXT_CSD_ERASE_GROUP_DEF];
460 card->ext_csd.hc_erase_timeout = 300 *
461 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
462 card->ext_csd.hc_erase_size =
463 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
465 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
468 * There are two boot regions of equal size, defined in
471 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
472 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
473 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
474 mmc_part_add(card, part_size,
475 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
477 MMC_BLK_DATA_AREA_BOOT);
482 card->ext_csd.raw_hc_erase_gap_size =
483 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
484 card->ext_csd.raw_sec_trim_mult =
485 ext_csd[EXT_CSD_SEC_TRIM_MULT];
486 card->ext_csd.raw_sec_erase_mult =
487 ext_csd[EXT_CSD_SEC_ERASE_MULT];
488 card->ext_csd.raw_sec_feature_support =
489 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
490 card->ext_csd.raw_trim_mult =
491 ext_csd[EXT_CSD_TRIM_MULT];
492 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
493 if (card->ext_csd.rev >= 4) {
494 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
495 EXT_CSD_PART_SETTING_COMPLETED)
496 card->ext_csd.partition_setting_completed = 1;
498 card->ext_csd.partition_setting_completed = 0;
500 mmc_manage_enhanced_area(card, ext_csd);
502 mmc_manage_gp_partitions(card, ext_csd);
504 card->ext_csd.sec_trim_mult =
505 ext_csd[EXT_CSD_SEC_TRIM_MULT];
506 card->ext_csd.sec_erase_mult =
507 ext_csd[EXT_CSD_SEC_ERASE_MULT];
508 card->ext_csd.sec_feature_support =
509 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
510 card->ext_csd.trim_timeout = 300 *
511 ext_csd[EXT_CSD_TRIM_MULT];
514 * Note that the call to mmc_part_add above defaults to read
515 * only. If this default assumption is changed, the call must
516 * take into account the value of boot_locked below.
518 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
519 card->ext_csd.boot_ro_lockable = true;
521 /* Save power class values */
522 card->ext_csd.raw_pwr_cl_52_195 =
523 ext_csd[EXT_CSD_PWR_CL_52_195];
524 card->ext_csd.raw_pwr_cl_26_195 =
525 ext_csd[EXT_CSD_PWR_CL_26_195];
526 card->ext_csd.raw_pwr_cl_52_360 =
527 ext_csd[EXT_CSD_PWR_CL_52_360];
528 card->ext_csd.raw_pwr_cl_26_360 =
529 ext_csd[EXT_CSD_PWR_CL_26_360];
530 card->ext_csd.raw_pwr_cl_200_195 =
531 ext_csd[EXT_CSD_PWR_CL_200_195];
532 card->ext_csd.raw_pwr_cl_200_360 =
533 ext_csd[EXT_CSD_PWR_CL_200_360];
534 card->ext_csd.raw_pwr_cl_ddr_52_195 =
535 ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
536 card->ext_csd.raw_pwr_cl_ddr_52_360 =
537 ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
538 card->ext_csd.raw_pwr_cl_ddr_200_360 =
539 ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
542 if (card->ext_csd.rev >= 5) {
543 /* Adjust production date as per JEDEC JESD84-B451 */
544 if (card->cid.year < 2010)
545 card->cid.year += 16;
547 /* check whether the eMMC card supports BKOPS */
548 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
549 card->ext_csd.bkops = 1;
550 card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN];
551 card->ext_csd.raw_bkops_status =
552 ext_csd[EXT_CSD_BKOPS_STATUS];
553 if (!card->ext_csd.bkops_en)
554 pr_info("%s: BKOPS_EN bit is not set\n",
555 mmc_hostname(card->host));
558 /* check whether the eMMC card supports HPI */
559 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
560 card->ext_csd.hpi = 1;
561 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
562 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
564 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
566 * Indicate the maximum timeout to close
567 * a command interrupted by HPI
569 card->ext_csd.out_of_int_time =
570 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
573 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
574 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
577 * RPMB regions are defined in multiples of 128K.
579 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
580 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
581 mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
582 EXT_CSD_PART_CONFIG_ACC_RPMB,
584 MMC_BLK_DATA_AREA_RPMB);
588 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
589 if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
590 card->erased_byte = 0xFF;
592 card->erased_byte = 0x0;
594 /* eMMC v4.5 or later */
595 if (card->ext_csd.rev >= 6) {
596 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
598 card->ext_csd.generic_cmd6_time = 10 *
599 ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
600 card->ext_csd.power_off_longtime = 10 *
601 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
603 card->ext_csd.cache_size =
604 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
605 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
606 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
607 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
609 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
610 card->ext_csd.data_sector_size = 4096;
612 card->ext_csd.data_sector_size = 512;
614 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
615 (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
616 card->ext_csd.data_tag_unit_size =
617 ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
618 (card->ext_csd.data_sector_size);
620 card->ext_csd.data_tag_unit_size = 0;
623 card->ext_csd.max_packed_writes =
624 ext_csd[EXT_CSD_MAX_PACKED_WRITES];
625 card->ext_csd.max_packed_reads =
626 ext_csd[EXT_CSD_MAX_PACKED_READS];
628 card->ext_csd.data_sector_size = 512;
631 /* eMMC v5 or later */
632 if (card->ext_csd.rev >= 7) {
633 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
635 card->ext_csd.ffu_capable =
636 (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
637 !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
643 static inline void mmc_free_ext_csd(u8 *ext_csd)
649 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
654 if (bus_width == MMC_BUS_WIDTH_1)
657 err = mmc_get_ext_csd(card, &bw_ext_csd);
659 if (err || bw_ext_csd == NULL) {
664 /* only compare read only fields */
665 err = !((card->ext_csd.raw_partition_support ==
666 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
667 (card->ext_csd.raw_erased_mem_count ==
668 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
669 (card->ext_csd.rev ==
670 bw_ext_csd[EXT_CSD_REV]) &&
671 (card->ext_csd.raw_ext_csd_structure ==
672 bw_ext_csd[EXT_CSD_STRUCTURE]) &&
673 (card->ext_csd.raw_card_type ==
674 bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
675 (card->ext_csd.raw_s_a_timeout ==
676 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
677 (card->ext_csd.raw_hc_erase_gap_size ==
678 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
679 (card->ext_csd.raw_erase_timeout_mult ==
680 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
681 (card->ext_csd.raw_hc_erase_grp_size ==
682 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
683 (card->ext_csd.raw_sec_trim_mult ==
684 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
685 (card->ext_csd.raw_sec_erase_mult ==
686 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
687 (card->ext_csd.raw_sec_feature_support ==
688 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
689 (card->ext_csd.raw_trim_mult ==
690 bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
691 (card->ext_csd.raw_sectors[0] ==
692 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
693 (card->ext_csd.raw_sectors[1] ==
694 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
695 (card->ext_csd.raw_sectors[2] ==
696 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
697 (card->ext_csd.raw_sectors[3] ==
698 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
699 (card->ext_csd.raw_pwr_cl_52_195 ==
700 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
701 (card->ext_csd.raw_pwr_cl_26_195 ==
702 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
703 (card->ext_csd.raw_pwr_cl_52_360 ==
704 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
705 (card->ext_csd.raw_pwr_cl_26_360 ==
706 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
707 (card->ext_csd.raw_pwr_cl_200_195 ==
708 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
709 (card->ext_csd.raw_pwr_cl_200_360 ==
710 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
711 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
712 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
713 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
714 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
715 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
716 bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
722 mmc_free_ext_csd(bw_ext_csd);
726 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
727 card->raw_cid[2], card->raw_cid[3]);
728 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
729 card->raw_csd[2], card->raw_csd[3]);
730 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
731 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
732 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
733 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
734 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
735 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
736 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
737 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
738 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
739 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
740 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
741 card->ext_csd.enhanced_area_offset);
742 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
743 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
744 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
746 static ssize_t mmc_fwrev_show(struct device *dev,
747 struct device_attribute *attr,
750 struct mmc_card *card = mmc_dev_to_card(dev);
752 if (card->ext_csd.rev < 7) {
753 return sprintf(buf, "0x%x\n", card->cid.fwrev);
755 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
756 card->ext_csd.fwrev);
760 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
762 static struct attribute *mmc_std_attrs[] = {
766 &dev_attr_erase_size.attr,
767 &dev_attr_preferred_erase_size.attr,
768 &dev_attr_fwrev.attr,
769 &dev_attr_ffu_capable.attr,
770 &dev_attr_hwrev.attr,
771 &dev_attr_manfid.attr,
773 &dev_attr_oemid.attr,
775 &dev_attr_serial.attr,
776 &dev_attr_enhanced_area_offset.attr,
777 &dev_attr_enhanced_area_size.attr,
778 &dev_attr_raw_rpmb_size_mult.attr,
779 &dev_attr_rel_sectors.attr,
782 ATTRIBUTE_GROUPS(mmc_std);
784 static struct device_type mmc_type = {
785 .groups = mmc_std_groups,
789 * Select the PowerClass for the current bus width
790 * If power class is defined for 4/8 bit bus in the
791 * extended CSD register, select it by executing the
792 * mmc_switch command.
794 static int __mmc_select_powerclass(struct mmc_card *card,
795 unsigned int bus_width)
797 struct mmc_host *host = card->host;
798 struct mmc_ext_csd *ext_csd = &card->ext_csd;
799 unsigned int pwrclass_val = 0;
802 /* Power class selection is supported for versions >= 4.0 */
803 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
806 /* Power class values are defined only for 4/8 bit bus */
807 if (bus_width == EXT_CSD_BUS_WIDTH_1)
810 switch (1 << host->ios.vdd) {
811 case MMC_VDD_165_195:
812 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
813 pwrclass_val = ext_csd->raw_pwr_cl_26_195;
814 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
815 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
816 ext_csd->raw_pwr_cl_52_195 :
817 ext_csd->raw_pwr_cl_ddr_52_195;
818 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
819 pwrclass_val = ext_csd->raw_pwr_cl_200_195;
830 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
831 pwrclass_val = ext_csd->raw_pwr_cl_26_360;
832 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
833 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
834 ext_csd->raw_pwr_cl_52_360 :
835 ext_csd->raw_pwr_cl_ddr_52_360;
836 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
837 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
838 ext_csd->raw_pwr_cl_ddr_200_360 :
839 ext_csd->raw_pwr_cl_200_360;
842 pr_warn("%s: Voltage range not supported for power class\n",
847 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
848 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
849 EXT_CSD_PWR_CL_8BIT_SHIFT;
851 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
852 EXT_CSD_PWR_CL_4BIT_SHIFT;
854 /* If the power class is different from the default value */
855 if (pwrclass_val > 0) {
856 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
859 card->ext_csd.generic_cmd6_time);
865 static int mmc_select_powerclass(struct mmc_card *card)
867 struct mmc_host *host = card->host;
868 u32 bus_width, ext_csd_bits;
871 /* Power class selection is supported for versions >= 4.0 */
872 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
875 bus_width = host->ios.bus_width;
876 /* Power class values are defined only for 4/8 bit bus */
877 if (bus_width == MMC_BUS_WIDTH_1)
880 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
882 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
883 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
885 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
886 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
888 err = __mmc_select_powerclass(card, ext_csd_bits);
890 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
891 mmc_hostname(host), 1 << bus_width, ddr);
897 * Set the bus speed for the selected speed mode.
899 static void mmc_set_bus_speed(struct mmc_card *card)
901 unsigned int max_dtr = (unsigned int)-1;
903 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
904 max_dtr > card->ext_csd.hs200_max_dtr)
905 max_dtr = card->ext_csd.hs200_max_dtr;
906 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
907 max_dtr = card->ext_csd.hs_max_dtr;
908 else if (max_dtr > card->csd.max_dtr)
909 max_dtr = card->csd.max_dtr;
911 mmc_set_clock(card->host, max_dtr);
915 * Select the bus width amoung 4-bit and 8-bit(SDR).
916 * If the bus width is changed successfully, return the selected width value.
917 * Zero is returned instead of error value if the wide width is not supported.
919 static int mmc_select_bus_width(struct mmc_card *card)
921 static unsigned ext_csd_bits[] = {
925 static unsigned bus_widths[] = {
929 struct mmc_host *host = card->host;
930 unsigned idx, bus_width = 0;
933 if ((card->csd.mmca_vsn < CSD_SPEC_VER_4) &&
934 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
937 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
940 * Unlike SD, MMC cards dont have a configuration register to notify
941 * supported bus width. So bus test command should be run to identify
942 * the supported bus width or compare the ext csd values of current
943 * bus width and ext csd values of 1 bit mode read earlier.
945 for (; idx < ARRAY_SIZE(bus_widths); idx++) {
947 * Host is capable of 8bit transfer, then switch
948 * the device to work in 8bit transfer mode. If the
949 * mmc switch command returns error then switch to
950 * 4bit transfer mode. On success set the corresponding
951 * bus width on the host.
953 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
956 card->ext_csd.generic_cmd6_time);
960 bus_width = bus_widths[idx];
961 mmc_set_bus_width(host, bus_width);
964 * If controller can't handle bus width test,
965 * compare ext_csd previously read in 1 bit mode
966 * against ext_csd at new bus width
968 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
969 err = mmc_compare_ext_csds(card, bus_width);
971 err = mmc_bus_test(card, bus_width);
977 pr_warn("%s: switch to bus width %d failed\n",
978 mmc_hostname(host), ext_csd_bits[idx]);
986 * Switch to the high-speed mode
988 static int mmc_select_hs(struct mmc_card *card)
992 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
993 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
994 card->ext_csd.generic_cmd6_time,
997 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1003 * Activate wide bus and DDR if supported.
1005 static int mmc_select_hs_ddr(struct mmc_card *card)
1007 struct mmc_host *host = card->host;
1008 u32 bus_width, ext_csd_bits;
1011 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
1014 bus_width = host->ios.bus_width;
1015 if (bus_width == MMC_BUS_WIDTH_1)
1018 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1019 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1021 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1024 card->ext_csd.generic_cmd6_time);
1026 pr_err("%s: switch to bus width %d ddr failed\n",
1027 mmc_hostname(host), 1 << bus_width);
1032 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1035 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1037 * 1.8V vccq at 3.3V core voltage (vcc) is not required
1038 * in the JEDEC spec for DDR.
1040 * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1041 * host controller can support this, like some of the SDHCI
1042 * controller which connect to an eMMC device. Some of these
1043 * host controller still needs to use 1.8v vccq for supporting
1046 * So the sequence will be:
1047 * if (host and device can both support 1.2v IO)
1049 * else if (host and device can both support 1.8v IO)
1051 * so if host and device can only support 3.3v IO, this is the
1054 * WARNING: eMMC rules are NOT the same as SD DDR
1057 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
1058 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1060 if (err && (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V))
1061 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1063 /* make sure vccq is 3.3v after switching disaster */
1065 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1068 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1073 static int mmc_select_hs400(struct mmc_card *card)
1075 struct mmc_host *host = card->host;
1079 * HS400 mode requires 8-bit bus width
1081 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1082 host->ios.bus_width == MMC_BUS_WIDTH_8))
1086 * Before switching to dual data rate operation for HS400,
1087 * it is required to convert from HS200 mode to HS mode.
1089 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1090 mmc_set_bus_speed(card);
1092 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1093 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1094 card->ext_csd.generic_cmd6_time,
1097 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
1098 mmc_hostname(host), err);
1102 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1104 EXT_CSD_DDR_BUS_WIDTH_8,
1105 card->ext_csd.generic_cmd6_time);
1107 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
1108 mmc_hostname(host), err);
1112 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1113 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400,
1114 card->ext_csd.generic_cmd6_time,
1117 pr_err("%s: switch to hs400 failed, err:%d\n",
1118 mmc_hostname(host), err);
1122 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1123 mmc_set_bus_speed(card);
1129 * For device supporting HS200 mode, the following sequence
1130 * should be done before executing the tuning process.
1131 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1132 * 2. switch to HS200 mode
1133 * 3. set the clock to > 52Mhz and <=200MHz
1135 static int mmc_select_hs200(struct mmc_card *card)
1137 struct mmc_host *host = card->host;
1140 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1141 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1143 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1144 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1146 /* If fails try again during next card power cycle */
1151 * Set the bus width(4 or 8) with host's support and
1152 * switch to HS200 mode if bus width is set successfully.
1154 err = mmc_select_bus_width(card);
1155 if (!IS_ERR_VALUE(err)) {
1156 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1157 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200,
1158 card->ext_csd.generic_cmd6_time,
1161 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1168 * Activate High Speed or HS200 mode if supported.
1170 static int mmc_select_timing(struct mmc_card *card)
1174 if ((card->csd.mmca_vsn < CSD_SPEC_VER_4 &&
1175 card->ext_csd.hs_max_dtr == 0))
1178 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
1179 err = mmc_select_hs200(card);
1180 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1181 err = mmc_select_hs(card);
1183 if (err && err != -EBADMSG)
1187 pr_warn("%s: switch to %s failed\n",
1188 mmc_card_hs(card) ? "high-speed" :
1189 (mmc_card_hs200(card) ? "hs200" : ""),
1190 mmc_hostname(card->host));
1196 * Set the bus speed to the selected bus timing.
1197 * If timing is not selected, backward compatible is the default.
1199 mmc_set_bus_speed(card);
1203 const u8 tuning_blk_pattern_4bit[MMC_TUNING_BLK_PATTERN_4BIT_SIZE] = {
1204 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
1205 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
1206 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
1207 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
1208 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
1209 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
1210 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
1211 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
1213 EXPORT_SYMBOL(tuning_blk_pattern_4bit);
1215 const u8 tuning_blk_pattern_8bit[MMC_TUNING_BLK_PATTERN_8BIT_SIZE] = {
1216 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
1217 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
1218 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
1219 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
1220 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
1221 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
1222 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
1223 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
1224 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
1225 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
1226 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
1227 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
1228 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
1229 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
1230 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
1231 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
1233 EXPORT_SYMBOL(tuning_blk_pattern_8bit);
1236 * Execute tuning sequence to seek the proper bus operating
1237 * conditions for HS200 and HS400, which sends CMD21 to the device.
1239 static int mmc_hs200_tuning(struct mmc_card *card)
1241 struct mmc_host *host = card->host;
1245 * Timing should be adjusted to the HS400 target
1246 * operation frequency for tuning process
1248 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1249 host->ios.bus_width == MMC_BUS_WIDTH_8)
1250 if (host->ops->prepare_hs400_tuning)
1251 host->ops->prepare_hs400_tuning(host, &host->ios);
1253 if (host->ops->execute_tuning) {
1254 mmc_host_clk_hold(host);
1255 err = host->ops->execute_tuning(host,
1256 MMC_SEND_TUNING_BLOCK_HS200);
1257 mmc_host_clk_release(host);
1260 pr_err("%s: tuning execution failed\n",
1261 mmc_hostname(host));
1268 * Handle the detection and initialisation of a card.
1270 * In the case of a resume, "oldcard" will contain the card
1271 * we're trying to reinitialise.
1273 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1274 struct mmc_card *oldcard)
1276 struct mmc_card *card;
1283 WARN_ON(!host->claimed);
1285 /* Set correct bus mode for MMC before attempting init */
1286 if (!mmc_host_is_spi(host))
1287 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1290 * Since we're changing the OCR value, we seem to
1291 * need to tell some cards to go back to the idle
1292 * state. We wait 1ms to give cards time to
1294 * mmc_go_idle is needed for eMMC that are asleep
1298 /* The extra bit indicates that we support high capacity */
1299 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1304 * For SPI, enable CRC as appropriate.
1306 if (mmc_host_is_spi(host)) {
1307 err = mmc_spi_set_crc(host, use_spi_crc);
1313 * Fetch CID from card.
1315 if (mmc_host_is_spi(host))
1316 err = mmc_send_cid(host, cid);
1318 err = mmc_all_send_cid(host, cid);
1323 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1331 * Allocate card structure.
1333 card = mmc_alloc_card(host, &mmc_type);
1335 err = PTR_ERR(card);
1340 card->type = MMC_TYPE_MMC;
1342 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1346 * For native busses: set card RCA and quit open drain mode.
1348 if (!mmc_host_is_spi(host)) {
1349 err = mmc_set_relative_addr(card);
1353 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1358 * Fetch CSD from card.
1360 err = mmc_send_csd(card, card->raw_csd);
1364 err = mmc_decode_csd(card);
1367 err = mmc_decode_cid(card);
1373 * handling only for cards supporting DSR and hosts requesting
1376 if (card->csd.dsr_imp && host->dsr_req)
1380 * Select card, as all following commands rely on that.
1382 if (!mmc_host_is_spi(host)) {
1383 err = mmc_select_card(card);
1390 * Fetch and process extended CSD.
1393 err = mmc_get_ext_csd(card, &ext_csd);
1396 err = mmc_read_ext_csd(card, ext_csd);
1400 /* If doing byte addressing, check if required to do sector
1401 * addressing. Handle the case of <2GB cards needing sector
1402 * addressing. See section 8.1 JEDEC Standard JED84-A441;
1403 * ocr register has bit 30 set for sector addressing.
1405 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
1406 mmc_card_set_blockaddr(card);
1408 /* Erase size depends on CSD and Extended CSD */
1409 mmc_set_erase_size(card);
1413 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
1414 * bit. This bit will be lost every time after a reset or power off.
1416 if (card->ext_csd.partition_setting_completed ||
1417 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
1418 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1419 EXT_CSD_ERASE_GROUP_DEF, 1,
1420 card->ext_csd.generic_cmd6_time);
1422 if (err && err != -EBADMSG)
1428 * Just disable enhanced area off & sz
1429 * will try to enable ERASE_GROUP_DEF
1430 * during next time reinit
1432 card->ext_csd.enhanced_area_offset = -EINVAL;
1433 card->ext_csd.enhanced_area_size = -EINVAL;
1435 card->ext_csd.erase_group_def = 1;
1437 * enable ERASE_GRP_DEF successfully.
1438 * This will affect the erase size, so
1439 * here need to reset erase size
1441 mmc_set_erase_size(card);
1446 * Ensure eMMC user default partition is enabled
1448 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1449 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1450 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1451 card->ext_csd.part_config,
1452 card->ext_csd.part_time);
1453 if (err && err != -EBADMSG)
1458 * Enable power_off_notification byte in the ext_csd register
1460 if (card->ext_csd.rev >= 6) {
1461 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1462 EXT_CSD_POWER_OFF_NOTIFICATION,
1464 card->ext_csd.generic_cmd6_time);
1465 if (err && err != -EBADMSG)
1469 * The err can be -EBADMSG or 0,
1470 * so check for success and update the flag
1473 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1477 * Select timing interface
1479 err = mmc_select_timing(card);
1483 if (mmc_card_hs200(card)) {
1484 err = mmc_hs200_tuning(card);
1488 err = mmc_select_hs400(card);
1491 } else if (mmc_card_hs(card)) {
1492 /* Select the desired bus width optionally */
1493 err = mmc_select_bus_width(card);
1494 if (!IS_ERR_VALUE(err)) {
1495 err = mmc_select_hs_ddr(card);
1502 * Choose the power class with selected bus interface
1504 mmc_select_powerclass(card);
1507 * Enable HPI feature (if supported)
1509 if (card->ext_csd.hpi) {
1510 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1511 EXT_CSD_HPI_MGMT, 1,
1512 card->ext_csd.generic_cmd6_time);
1513 if (err && err != -EBADMSG)
1516 pr_warn("%s: Enabling HPI failed\n",
1517 mmc_hostname(card->host));
1520 card->ext_csd.hpi_en = 1;
1524 * If cache size is higher than 0, this indicates
1525 * the existence of cache and it can be turned on.
1527 if (card->ext_csd.cache_size > 0) {
1528 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1529 EXT_CSD_CACHE_CTRL, 1,
1530 card->ext_csd.generic_cmd6_time);
1531 if (err && err != -EBADMSG)
1535 * Only if no error, cache is turned on successfully.
1538 pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1539 mmc_hostname(card->host), err);
1540 card->ext_csd.cache_ctrl = 0;
1543 card->ext_csd.cache_ctrl = 1;
1548 * The mandatory minimum values are defined for packed command.
1551 if (card->ext_csd.max_packed_writes >= 3 &&
1552 card->ext_csd.max_packed_reads >= 5 &&
1553 host->caps2 & MMC_CAP2_PACKED_CMD) {
1554 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1555 EXT_CSD_EXP_EVENTS_CTRL,
1556 EXT_CSD_PACKED_EVENT_EN,
1557 card->ext_csd.generic_cmd6_time);
1558 if (err && err != -EBADMSG)
1561 pr_warn("%s: Enabling packed event failed\n",
1562 mmc_hostname(card->host));
1563 card->ext_csd.packed_event_en = 0;
1566 card->ext_csd.packed_event_en = 1;
1573 mmc_free_ext_csd(ext_csd);
1578 mmc_remove_card(card);
1580 mmc_free_ext_csd(ext_csd);
1585 static int mmc_can_sleep(struct mmc_card *card)
1587 return (card && card->ext_csd.rev >= 3);
1590 static int mmc_sleep(struct mmc_host *host)
1592 struct mmc_command cmd = {0};
1593 struct mmc_card *card = host->card;
1594 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1597 err = mmc_deselect_cards(host);
1601 cmd.opcode = MMC_SLEEP_AWAKE;
1602 cmd.arg = card->rca << 16;
1606 * If the max_busy_timeout of the host is specified, validate it against
1607 * the sleep cmd timeout. A failure means we need to prevent the host
1608 * from doing hw busy detection, which is done by converting to a R1
1609 * response instead of a R1B.
1611 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1612 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1614 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1615 cmd.busy_timeout = timeout_ms;
1618 err = mmc_wait_for_cmd(host, &cmd, 0);
1623 * If the host does not wait while the card signals busy, then we will
1624 * will have to wait the sleep/awake timeout. Note, we cannot use the
1625 * SEND_STATUS command to poll the status because that command (and most
1626 * others) is invalid while the card sleeps.
1628 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1629 mmc_delay(timeout_ms);
1634 static int mmc_can_poweroff_notify(const struct mmc_card *card)
1637 mmc_card_mmc(card) &&
1638 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1641 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1643 unsigned int timeout = card->ext_csd.generic_cmd6_time;
1646 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1647 if (notify_type == EXT_CSD_POWER_OFF_LONG)
1648 timeout = card->ext_csd.power_off_longtime;
1650 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1651 EXT_CSD_POWER_OFF_NOTIFICATION,
1652 notify_type, timeout, true, false, false);
1654 pr_err("%s: Power Off Notification timed out, %u\n",
1655 mmc_hostname(card->host), timeout);
1657 /* Disable the power off notification after the switch operation. */
1658 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1664 * Host is being removed. Free up the current card.
1666 static void mmc_remove(struct mmc_host *host)
1669 BUG_ON(!host->card);
1671 mmc_remove_card(host->card);
1676 * Card detection - card is alive.
1678 static int mmc_alive(struct mmc_host *host)
1680 return mmc_send_status(host->card, NULL);
1684 * Card detection callback from host.
1686 static void mmc_detect(struct mmc_host *host)
1691 BUG_ON(!host->card);
1693 mmc_get_card(host->card);
1696 * Just check if our card has been removed.
1698 err = _mmc_detect_card_removed(host);
1700 mmc_put_card(host->card);
1705 mmc_claim_host(host);
1706 mmc_detach_bus(host);
1707 mmc_power_off(host);
1708 mmc_release_host(host);
1712 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
1715 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1716 EXT_CSD_POWER_OFF_LONG;
1719 BUG_ON(!host->card);
1721 mmc_claim_host(host);
1723 if (mmc_card_suspended(host->card))
1726 if (mmc_card_doing_bkops(host->card)) {
1727 err = mmc_stop_bkops(host->card);
1732 err = mmc_flush_cache(host->card);
1736 if (mmc_can_poweroff_notify(host->card) &&
1737 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
1738 err = mmc_poweroff_notify(host->card, notify_type);
1739 else if (mmc_can_sleep(host->card))
1740 err = mmc_sleep(host);
1741 else if (!mmc_host_is_spi(host))
1742 err = mmc_deselect_cards(host);
1745 mmc_power_off(host);
1746 mmc_card_set_suspended(host->card);
1749 mmc_release_host(host);
1756 static int mmc_suspend(struct mmc_host *host)
1760 err = _mmc_suspend(host, true);
1762 pm_runtime_disable(&host->card->dev);
1763 pm_runtime_set_suspended(&host->card->dev);
1770 * This function tries to determine if the same card is still present
1771 * and, if so, restore all state to it.
1773 static int _mmc_resume(struct mmc_host *host)
1778 BUG_ON(!host->card);
1780 mmc_claim_host(host);
1782 if (!mmc_card_suspended(host->card))
1785 mmc_power_up(host, host->card->ocr);
1786 err = mmc_init_card(host, host->card->ocr, host->card);
1787 mmc_card_clr_suspended(host->card);
1790 mmc_release_host(host);
1797 static int mmc_shutdown(struct mmc_host *host)
1802 * In a specific case for poweroff notify, we need to resume the card
1803 * before we can shutdown it properly.
1805 if (mmc_can_poweroff_notify(host->card) &&
1806 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
1807 err = _mmc_resume(host);
1810 err = _mmc_suspend(host, false);
1816 * Callback for resume.
1818 static int mmc_resume(struct mmc_host *host)
1822 if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
1823 err = _mmc_resume(host);
1824 pm_runtime_set_active(&host->card->dev);
1825 pm_runtime_mark_last_busy(&host->card->dev);
1827 pm_runtime_enable(&host->card->dev);
1833 * Callback for runtime_suspend.
1835 static int mmc_runtime_suspend(struct mmc_host *host)
1839 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1842 err = _mmc_suspend(host, true);
1844 pr_err("%s: error %d doing aggessive suspend\n",
1845 mmc_hostname(host), err);
1851 * Callback for runtime_resume.
1853 static int mmc_runtime_resume(struct mmc_host *host)
1857 if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
1860 err = _mmc_resume(host);
1862 pr_err("%s: error %d doing aggessive resume\n",
1863 mmc_hostname(host), err);
1868 static int mmc_power_restore(struct mmc_host *host)
1872 mmc_claim_host(host);
1873 ret = mmc_init_card(host, host->card->ocr, host->card);
1874 mmc_release_host(host);
1879 static const struct mmc_bus_ops mmc_ops = {
1880 .remove = mmc_remove,
1881 .detect = mmc_detect,
1882 .suspend = mmc_suspend,
1883 .resume = mmc_resume,
1884 .runtime_suspend = mmc_runtime_suspend,
1885 .runtime_resume = mmc_runtime_resume,
1886 .power_restore = mmc_power_restore,
1888 .shutdown = mmc_shutdown,
1892 * Starting point for MMC card init.
1894 int mmc_attach_mmc(struct mmc_host *host)
1900 WARN_ON(!host->claimed);
1902 /* Set correct bus mode for MMC before attempting attach */
1903 if (!mmc_host_is_spi(host))
1904 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1906 err = mmc_send_op_cond(host, 0, &ocr);
1910 mmc_attach_bus(host, &mmc_ops);
1911 if (host->ocr_avail_mmc)
1912 host->ocr_avail = host->ocr_avail_mmc;
1915 * We need to get OCR a different way for SPI.
1917 if (mmc_host_is_spi(host)) {
1918 err = mmc_spi_read_ocr(host, 1, &ocr);
1923 rocr = mmc_select_voltage(host, ocr);
1926 * Can we support the voltage of the card?
1934 * Detect and init the card.
1936 err = mmc_init_card(host, rocr, NULL);
1940 mmc_release_host(host);
1941 err = mmc_add_card(host->card);
1942 mmc_claim_host(host);
1949 mmc_release_host(host);
1950 mmc_remove_card(host->card);
1951 mmc_claim_host(host);
1954 mmc_detach_bus(host);
1956 pr_err("%s: error %d whilst initialising MMC card\n",
1957 mmc_hostname(host), err);