2 * linux/drivers/mmc/core/sd.c
4 * Copyright (C) 2003-2004 Russell King, All Rights Reserved.
5 * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
6 * Copyright (C) 2005-2007 Pierre Ossman, 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/sizes.h>
15 #include <linux/slab.h>
16 #include <linux/stat.h>
17 #include <linux/pm_runtime.h>
19 #include <linux/mmc/host.h>
20 #include <linux/mmc/card.h>
21 #include <linux/mmc/mmc.h>
22 #include <linux/mmc/sd.h>
30 static const unsigned int tran_exp
[] = {
31 10000, 100000, 1000000, 10000000,
35 static const unsigned char tran_mant
[] = {
36 0, 10, 12, 13, 15, 20, 25, 30,
37 35, 40, 45, 50, 55, 60, 70, 80,
40 static const unsigned int tacc_exp
[] = {
41 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
44 static const unsigned int tacc_mant
[] = {
45 0, 10, 12, 13, 15, 20, 25, 30,
46 35, 40, 45, 50, 55, 60, 70, 80,
49 static const unsigned int sd_au_size
[] = {
50 0, SZ_16K
/ 512, SZ_32K
/ 512, SZ_64K
/ 512,
51 SZ_128K
/ 512, SZ_256K
/ 512, SZ_512K
/ 512, SZ_1M
/ 512,
52 SZ_2M
/ 512, SZ_4M
/ 512, SZ_8M
/ 512, (SZ_8M
+ SZ_4M
) / 512,
53 SZ_16M
/ 512, (SZ_16M
+ SZ_8M
) / 512, SZ_32M
/ 512, SZ_64M
/ 512,
56 #define UNSTUFF_BITS(resp,start,size) \
58 const int __size = size; \
59 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
60 const int __off = 3 - ((start) / 32); \
61 const int __shft = (start) & 31; \
64 __res = resp[__off] >> __shft; \
65 if (__size + __shft > 32) \
66 __res |= resp[__off-1] << ((32 - __shft) % 32); \
71 * Given the decoded CSD structure, decode the raw CID to our CID structure.
73 void mmc_decode_cid(struct mmc_card
*card
)
75 u32
*resp
= card
->raw_cid
;
77 memset(&card
->cid
, 0, sizeof(struct mmc_cid
));
80 * SD doesn't currently have a version field so we will
81 * have to assume we can parse this.
83 card
->cid
.manfid
= UNSTUFF_BITS(resp
, 120, 8);
84 card
->cid
.oemid
= UNSTUFF_BITS(resp
, 104, 16);
85 card
->cid
.prod_name
[0] = UNSTUFF_BITS(resp
, 96, 8);
86 card
->cid
.prod_name
[1] = UNSTUFF_BITS(resp
, 88, 8);
87 card
->cid
.prod_name
[2] = UNSTUFF_BITS(resp
, 80, 8);
88 card
->cid
.prod_name
[3] = UNSTUFF_BITS(resp
, 72, 8);
89 card
->cid
.prod_name
[4] = UNSTUFF_BITS(resp
, 64, 8);
90 card
->cid
.hwrev
= UNSTUFF_BITS(resp
, 60, 4);
91 card
->cid
.fwrev
= UNSTUFF_BITS(resp
, 56, 4);
92 card
->cid
.serial
= UNSTUFF_BITS(resp
, 24, 32);
93 card
->cid
.year
= UNSTUFF_BITS(resp
, 12, 8);
94 card
->cid
.month
= UNSTUFF_BITS(resp
, 8, 4);
96 card
->cid
.year
+= 2000; /* SD cards year offset */
100 * Given a 128-bit response, decode to our card CSD structure.
102 static int mmc_decode_csd(struct mmc_card
*card
)
104 struct mmc_csd
*csd
= &card
->csd
;
105 unsigned int e
, m
, csd_struct
;
106 u32
*resp
= card
->raw_csd
;
108 csd_struct
= UNSTUFF_BITS(resp
, 126, 2);
110 switch (csd_struct
) {
112 m
= UNSTUFF_BITS(resp
, 115, 4);
113 e
= UNSTUFF_BITS(resp
, 112, 3);
114 csd
->tacc_ns
= (tacc_exp
[e
] * tacc_mant
[m
] + 9) / 10;
115 csd
->tacc_clks
= UNSTUFF_BITS(resp
, 104, 8) * 100;
117 m
= UNSTUFF_BITS(resp
, 99, 4);
118 e
= UNSTUFF_BITS(resp
, 96, 3);
119 csd
->max_dtr
= tran_exp
[e
] * tran_mant
[m
];
120 csd
->cmdclass
= UNSTUFF_BITS(resp
, 84, 12);
122 e
= UNSTUFF_BITS(resp
, 47, 3);
123 m
= UNSTUFF_BITS(resp
, 62, 12);
124 csd
->capacity
= (1 + m
) << (e
+ 2);
126 csd
->read_blkbits
= UNSTUFF_BITS(resp
, 80, 4);
127 csd
->read_partial
= UNSTUFF_BITS(resp
, 79, 1);
128 csd
->write_misalign
= UNSTUFF_BITS(resp
, 78, 1);
129 csd
->read_misalign
= UNSTUFF_BITS(resp
, 77, 1);
130 csd
->dsr_imp
= UNSTUFF_BITS(resp
, 76, 1);
131 csd
->r2w_factor
= UNSTUFF_BITS(resp
, 26, 3);
132 csd
->write_blkbits
= UNSTUFF_BITS(resp
, 22, 4);
133 csd
->write_partial
= UNSTUFF_BITS(resp
, 21, 1);
135 if (UNSTUFF_BITS(resp
, 46, 1)) {
137 } else if (csd
->write_blkbits
>= 9) {
138 csd
->erase_size
= UNSTUFF_BITS(resp
, 39, 7) + 1;
139 csd
->erase_size
<<= csd
->write_blkbits
- 9;
144 * This is a block-addressed SDHC or SDXC card. Most
145 * interesting fields are unused and have fixed
146 * values. To avoid getting tripped by buggy cards,
147 * we assume those fixed values ourselves.
149 mmc_card_set_blockaddr(card
);
151 csd
->tacc_ns
= 0; /* Unused */
152 csd
->tacc_clks
= 0; /* Unused */
154 m
= UNSTUFF_BITS(resp
, 99, 4);
155 e
= UNSTUFF_BITS(resp
, 96, 3);
156 csd
->max_dtr
= tran_exp
[e
] * tran_mant
[m
];
157 csd
->cmdclass
= UNSTUFF_BITS(resp
, 84, 12);
158 csd
->c_size
= UNSTUFF_BITS(resp
, 48, 22);
160 /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
161 if (csd
->c_size
>= 0xFFFF)
162 mmc_card_set_ext_capacity(card
);
164 m
= UNSTUFF_BITS(resp
, 48, 22);
165 csd
->capacity
= (1 + m
) << 10;
167 csd
->read_blkbits
= 9;
168 csd
->read_partial
= 0;
169 csd
->write_misalign
= 0;
170 csd
->read_misalign
= 0;
171 csd
->r2w_factor
= 4; /* Unused */
172 csd
->write_blkbits
= 9;
173 csd
->write_partial
= 0;
177 pr_err("%s: unrecognised CSD structure version %d\n",
178 mmc_hostname(card
->host
), csd_struct
);
182 card
->erase_size
= csd
->erase_size
;
188 * Given a 64-bit response, decode to our card SCR structure.
190 static int mmc_decode_scr(struct mmc_card
*card
)
192 struct sd_scr
*scr
= &card
->scr
;
193 unsigned int scr_struct
;
196 resp
[3] = card
->raw_scr
[1];
197 resp
[2] = card
->raw_scr
[0];
199 scr_struct
= UNSTUFF_BITS(resp
, 60, 4);
200 if (scr_struct
!= 0) {
201 pr_err("%s: unrecognised SCR structure version %d\n",
202 mmc_hostname(card
->host
), scr_struct
);
206 scr
->sda_vsn
= UNSTUFF_BITS(resp
, 56, 4);
207 scr
->bus_widths
= UNSTUFF_BITS(resp
, 48, 4);
208 if (scr
->sda_vsn
== SCR_SPEC_VER_2
)
209 /* Check if Physical Layer Spec v3.0 is supported */
210 scr
->sda_spec3
= UNSTUFF_BITS(resp
, 47, 1);
212 if (UNSTUFF_BITS(resp
, 55, 1))
213 card
->erased_byte
= 0xFF;
215 card
->erased_byte
= 0x0;
218 scr
->cmds
= UNSTUFF_BITS(resp
, 32, 2);
223 * Fetch and process SD Status register.
225 static int mmc_read_ssr(struct mmc_card
*card
)
227 unsigned int au
, es
, et
, eo
;
231 if (!(card
->csd
.cmdclass
& CCC_APP_SPEC
)) {
232 pr_warn("%s: card lacks mandatory SD Status function\n",
233 mmc_hostname(card
->host
));
237 ssr
= kmalloc(64, GFP_KERNEL
);
241 err
= mmc_app_sd_status(card
, ssr
);
243 pr_warn("%s: problem reading SD Status register\n",
244 mmc_hostname(card
->host
));
249 for (i
= 0; i
< 16; i
++)
250 ssr
[i
] = be32_to_cpu(ssr
[i
]);
253 * UNSTUFF_BITS only works with four u32s so we have to offset the
254 * bitfield positions accordingly.
256 au
= UNSTUFF_BITS(ssr
, 428 - 384, 4);
258 if (au
<= 9 || card
->scr
.sda_spec3
) {
259 card
->ssr
.au
= sd_au_size
[au
];
260 es
= UNSTUFF_BITS(ssr
, 408 - 384, 16);
261 et
= UNSTUFF_BITS(ssr
, 402 - 384, 6);
263 eo
= UNSTUFF_BITS(ssr
, 400 - 384, 2);
264 card
->ssr
.erase_timeout
= (et
* 1000) / es
;
265 card
->ssr
.erase_offset
= eo
* 1000;
268 pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
269 mmc_hostname(card
->host
));
278 * Fetches and decodes switch information
280 static int mmc_read_switch(struct mmc_card
*card
)
285 if (card
->scr
.sda_vsn
< SCR_SPEC_VER_1
)
288 if (!(card
->csd
.cmdclass
& CCC_SWITCH
)) {
289 pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
290 mmc_hostname(card
->host
));
296 status
= kmalloc(64, GFP_KERNEL
);
298 pr_err("%s: could not allocate a buffer for "
299 "switch capabilities.\n",
300 mmc_hostname(card
->host
));
305 * Find out the card's support bits with a mode 0 operation.
306 * The argument does not matter, as the support bits do not
307 * change with the arguments.
309 err
= mmc_sd_switch(card
, 0, 0, 0, status
);
312 * If the host or the card can't do the switch,
313 * fail more gracefully.
315 if (err
!= -EINVAL
&& err
!= -ENOSYS
&& err
!= -EFAULT
)
318 pr_warn("%s: problem reading Bus Speed modes\n",
319 mmc_hostname(card
->host
));
325 if (status
[13] & SD_MODE_HIGH_SPEED
)
326 card
->sw_caps
.hs_max_dtr
= HIGH_SPEED_MAX_DTR
;
328 if (card
->scr
.sda_spec3
) {
329 card
->sw_caps
.sd3_bus_mode
= status
[13];
330 /* Driver Strengths supported by the card */
331 card
->sw_caps
.sd3_drv_type
= status
[9];
341 * Test if the card supports high-speed mode and, if so, switch to it.
343 int mmc_sd_switch_hs(struct mmc_card
*card
)
348 if (card
->scr
.sda_vsn
< SCR_SPEC_VER_1
)
351 if (!(card
->csd
.cmdclass
& CCC_SWITCH
))
354 if (!(card
->host
->caps
& MMC_CAP_SD_HIGHSPEED
))
357 if (card
->sw_caps
.hs_max_dtr
== 0)
362 status
= kmalloc(64, GFP_KERNEL
);
364 pr_err("%s: could not allocate a buffer for "
365 "switch capabilities.\n", mmc_hostname(card
->host
));
369 err
= mmc_sd_switch(card
, 1, 0, 1, status
);
373 if ((status
[16] & 0xF) != 1) {
374 pr_warn("%s: Problem switching card into high-speed mode!\n",
375 mmc_hostname(card
->host
));
387 static int sd_select_driver_type(struct mmc_card
*card
, u8
*status
)
389 int host_drv_type
= SD_DRIVER_TYPE_B
;
390 int card_drv_type
= SD_DRIVER_TYPE_B
;
395 * If the host doesn't support any of the Driver Types A,C or D,
396 * or there is no board specific handler then default Driver
399 if (!(card
->host
->caps
& (MMC_CAP_DRIVER_TYPE_A
| MMC_CAP_DRIVER_TYPE_C
400 | MMC_CAP_DRIVER_TYPE_D
)))
403 if (!card
->host
->ops
->select_drive_strength
)
406 if (card
->host
->caps
& MMC_CAP_DRIVER_TYPE_A
)
407 host_drv_type
|= SD_DRIVER_TYPE_A
;
409 if (card
->host
->caps
& MMC_CAP_DRIVER_TYPE_C
)
410 host_drv_type
|= SD_DRIVER_TYPE_C
;
412 if (card
->host
->caps
& MMC_CAP_DRIVER_TYPE_D
)
413 host_drv_type
|= SD_DRIVER_TYPE_D
;
415 if (card
->sw_caps
.sd3_drv_type
& SD_DRIVER_TYPE_A
)
416 card_drv_type
|= SD_DRIVER_TYPE_A
;
418 if (card
->sw_caps
.sd3_drv_type
& SD_DRIVER_TYPE_C
)
419 card_drv_type
|= SD_DRIVER_TYPE_C
;
421 if (card
->sw_caps
.sd3_drv_type
& SD_DRIVER_TYPE_D
)
422 card_drv_type
|= SD_DRIVER_TYPE_D
;
425 * The drive strength that the hardware can support
426 * depends on the board design. Pass the appropriate
427 * information and let the hardware specific code
428 * return what is possible given the options
430 mmc_host_clk_hold(card
->host
);
431 drive_strength
= card
->host
->ops
->select_drive_strength(
432 card
->sw_caps
.uhs_max_dtr
,
433 host_drv_type
, card_drv_type
);
434 mmc_host_clk_release(card
->host
);
436 err
= mmc_sd_switch(card
, 1, 2, drive_strength
, status
);
440 if ((status
[15] & 0xF) != drive_strength
) {
441 pr_warn("%s: Problem setting drive strength!\n",
442 mmc_hostname(card
->host
));
446 mmc_set_driver_type(card
->host
, drive_strength
);
451 static void sd_update_bus_speed_mode(struct mmc_card
*card
)
454 * If the host doesn't support any of the UHS-I modes, fallback on
457 if (!mmc_host_uhs(card
->host
)) {
458 card
->sd_bus_speed
= 0;
462 if ((card
->host
->caps
& MMC_CAP_UHS_SDR104
) &&
463 (card
->sw_caps
.sd3_bus_mode
& SD_MODE_UHS_SDR104
)) {
464 card
->sd_bus_speed
= UHS_SDR104_BUS_SPEED
;
465 } else if ((card
->host
->caps
& MMC_CAP_UHS_DDR50
) &&
466 (card
->sw_caps
.sd3_bus_mode
& SD_MODE_UHS_DDR50
)) {
467 card
->sd_bus_speed
= UHS_DDR50_BUS_SPEED
;
468 } else if ((card
->host
->caps
& (MMC_CAP_UHS_SDR104
|
469 MMC_CAP_UHS_SDR50
)) && (card
->sw_caps
.sd3_bus_mode
&
470 SD_MODE_UHS_SDR50
)) {
471 card
->sd_bus_speed
= UHS_SDR50_BUS_SPEED
;
472 } else if ((card
->host
->caps
& (MMC_CAP_UHS_SDR104
|
473 MMC_CAP_UHS_SDR50
| MMC_CAP_UHS_SDR25
)) &&
474 (card
->sw_caps
.sd3_bus_mode
& SD_MODE_UHS_SDR25
)) {
475 card
->sd_bus_speed
= UHS_SDR25_BUS_SPEED
;
476 } else if ((card
->host
->caps
& (MMC_CAP_UHS_SDR104
|
477 MMC_CAP_UHS_SDR50
| MMC_CAP_UHS_SDR25
|
478 MMC_CAP_UHS_SDR12
)) && (card
->sw_caps
.sd3_bus_mode
&
479 SD_MODE_UHS_SDR12
)) {
480 card
->sd_bus_speed
= UHS_SDR12_BUS_SPEED
;
484 static int sd_set_bus_speed_mode(struct mmc_card
*card
, u8
*status
)
487 unsigned int timing
= 0;
489 switch (card
->sd_bus_speed
) {
490 case UHS_SDR104_BUS_SPEED
:
491 timing
= MMC_TIMING_UHS_SDR104
;
492 card
->sw_caps
.uhs_max_dtr
= UHS_SDR104_MAX_DTR
;
494 case UHS_DDR50_BUS_SPEED
:
495 timing
= MMC_TIMING_UHS_DDR50
;
496 card
->sw_caps
.uhs_max_dtr
= UHS_DDR50_MAX_DTR
;
498 case UHS_SDR50_BUS_SPEED
:
499 timing
= MMC_TIMING_UHS_SDR50
;
500 card
->sw_caps
.uhs_max_dtr
= UHS_SDR50_MAX_DTR
;
502 case UHS_SDR25_BUS_SPEED
:
503 timing
= MMC_TIMING_UHS_SDR25
;
504 card
->sw_caps
.uhs_max_dtr
= UHS_SDR25_MAX_DTR
;
506 case UHS_SDR12_BUS_SPEED
:
507 timing
= MMC_TIMING_UHS_SDR12
;
508 card
->sw_caps
.uhs_max_dtr
= UHS_SDR12_MAX_DTR
;
514 err
= mmc_sd_switch(card
, 1, 0, card
->sd_bus_speed
, status
);
518 if ((status
[16] & 0xF) != card
->sd_bus_speed
)
519 pr_warn("%s: Problem setting bus speed mode!\n",
520 mmc_hostname(card
->host
));
522 mmc_set_timing(card
->host
, timing
);
523 mmc_set_clock(card
->host
, card
->sw_caps
.uhs_max_dtr
);
529 /* Get host's max current setting at its current voltage */
530 static u32
sd_get_host_max_current(struct mmc_host
*host
)
532 u32 voltage
, max_current
;
534 voltage
= 1 << host
->ios
.vdd
;
536 case MMC_VDD_165_195
:
537 max_current
= host
->max_current_180
;
541 max_current
= host
->max_current_300
;
545 max_current
= host
->max_current_330
;
554 static int sd_set_current_limit(struct mmc_card
*card
, u8
*status
)
556 int current_limit
= SD_SET_CURRENT_NO_CHANGE
;
561 * Current limit switch is only defined for SDR50, SDR104, and DDR50
562 * bus speed modes. For other bus speed modes, we do not change the
565 if ((card
->sd_bus_speed
!= UHS_SDR50_BUS_SPEED
) &&
566 (card
->sd_bus_speed
!= UHS_SDR104_BUS_SPEED
) &&
567 (card
->sd_bus_speed
!= UHS_DDR50_BUS_SPEED
))
571 * Host has different current capabilities when operating at
572 * different voltages, so find out its max current first.
574 max_current
= sd_get_host_max_current(card
->host
);
577 * We only check host's capability here, if we set a limit that is
578 * higher than the card's maximum current, the card will be using its
579 * maximum current, e.g. if the card's maximum current is 300ma, and
580 * when we set current limit to 200ma, the card will draw 200ma, and
581 * when we set current limit to 400/600/800ma, the card will draw its
582 * maximum 300ma from the host.
584 if (max_current
>= 800)
585 current_limit
= SD_SET_CURRENT_LIMIT_800
;
586 else if (max_current
>= 600)
587 current_limit
= SD_SET_CURRENT_LIMIT_600
;
588 else if (max_current
>= 400)
589 current_limit
= SD_SET_CURRENT_LIMIT_400
;
590 else if (max_current
>= 200)
591 current_limit
= SD_SET_CURRENT_LIMIT_200
;
593 if (current_limit
!= SD_SET_CURRENT_NO_CHANGE
) {
594 err
= mmc_sd_switch(card
, 1, 3, current_limit
, status
);
598 if (((status
[15] >> 4) & 0x0F) != current_limit
)
599 pr_warn("%s: Problem setting current limit!\n",
600 mmc_hostname(card
->host
));
608 * UHS-I specific initialization procedure
610 static int mmc_sd_init_uhs_card(struct mmc_card
*card
)
615 if (!card
->scr
.sda_spec3
)
618 if (!(card
->csd
.cmdclass
& CCC_SWITCH
))
621 status
= kmalloc(64, GFP_KERNEL
);
623 pr_err("%s: could not allocate a buffer for "
624 "switch capabilities.\n", mmc_hostname(card
->host
));
628 /* Set 4-bit bus width */
629 if ((card
->host
->caps
& MMC_CAP_4_BIT_DATA
) &&
630 (card
->scr
.bus_widths
& SD_SCR_BUS_WIDTH_4
)) {
631 err
= mmc_app_set_bus_width(card
, MMC_BUS_WIDTH_4
);
635 mmc_set_bus_width(card
->host
, MMC_BUS_WIDTH_4
);
639 * Select the bus speed mode depending on host
640 * and card capability.
642 sd_update_bus_speed_mode(card
);
644 /* Set the driver strength for the card */
645 err
= sd_select_driver_type(card
, status
);
649 /* Set current limit for the card */
650 err
= sd_set_current_limit(card
, status
);
654 /* Set bus speed mode of the card */
655 err
= sd_set_bus_speed_mode(card
, status
);
660 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
661 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
663 if (!mmc_host_is_spi(card
->host
) &&
664 (card
->sd_bus_speed
== UHS_SDR50_BUS_SPEED
||
665 card
->sd_bus_speed
== UHS_SDR104_BUS_SPEED
))
666 err
= mmc_execute_tuning(card
);
673 MMC_DEV_ATTR(cid
, "%08x%08x%08x%08x\n", card
->raw_cid
[0], card
->raw_cid
[1],
674 card
->raw_cid
[2], card
->raw_cid
[3]);
675 MMC_DEV_ATTR(csd
, "%08x%08x%08x%08x\n", card
->raw_csd
[0], card
->raw_csd
[1],
676 card
->raw_csd
[2], card
->raw_csd
[3]);
677 MMC_DEV_ATTR(scr
, "%08x%08x\n", card
->raw_scr
[0], card
->raw_scr
[1]);
678 MMC_DEV_ATTR(date
, "%02d/%04d\n", card
->cid
.month
, card
->cid
.year
);
679 MMC_DEV_ATTR(erase_size
, "%u\n", card
->erase_size
<< 9);
680 MMC_DEV_ATTR(preferred_erase_size
, "%u\n", card
->pref_erase
<< 9);
681 MMC_DEV_ATTR(fwrev
, "0x%x\n", card
->cid
.fwrev
);
682 MMC_DEV_ATTR(hwrev
, "0x%x\n", card
->cid
.hwrev
);
683 MMC_DEV_ATTR(manfid
, "0x%06x\n", card
->cid
.manfid
);
684 MMC_DEV_ATTR(name
, "%s\n", card
->cid
.prod_name
);
685 MMC_DEV_ATTR(oemid
, "0x%04x\n", card
->cid
.oemid
);
686 MMC_DEV_ATTR(serial
, "0x%08x\n", card
->cid
.serial
);
689 static struct attribute
*sd_std_attrs
[] = {
694 &dev_attr_erase_size
.attr
,
695 &dev_attr_preferred_erase_size
.attr
,
696 &dev_attr_fwrev
.attr
,
697 &dev_attr_hwrev
.attr
,
698 &dev_attr_manfid
.attr
,
700 &dev_attr_oemid
.attr
,
701 &dev_attr_serial
.attr
,
704 ATTRIBUTE_GROUPS(sd_std
);
706 struct device_type sd_type
= {
707 .groups
= sd_std_groups
,
711 * Fetch CID from card.
713 int mmc_sd_get_cid(struct mmc_host
*host
, u32 ocr
, u32
*cid
, u32
*rocr
)
723 pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host
));
727 * Since we're changing the OCR value, we seem to
728 * need to tell some cards to go back to the idle
729 * state. We wait 1ms to give cards time to
735 * If SD_SEND_IF_COND indicates an SD 2.0
736 * compliant card and we should set bit 30
737 * of the ocr to indicate that we can handle
738 * block-addressed SDHC cards.
740 err
= mmc_send_if_cond(host
, ocr
);
745 * If the host supports one of UHS-I modes, request the card
746 * to switch to 1.8V signaling level. If the card has failed
747 * repeatedly to switch however, skip this.
749 if (retries
&& mmc_host_uhs(host
))
753 * If the host can supply more than 150mA at current voltage,
754 * XPC should be set to 1.
756 max_current
= sd_get_host_max_current(host
);
757 if (max_current
> 150)
760 err
= mmc_send_app_op_cond(host
, ocr
, rocr
);
765 * In case CCS and S18A in the response is set, start Signal Voltage
766 * Switch procedure. SPI mode doesn't support CMD11.
768 if (!mmc_host_is_spi(host
) && rocr
&&
769 ((*rocr
& 0x41000000) == 0x41000000)) {
770 err
= mmc_set_signal_voltage(host
, MMC_SIGNAL_VOLTAGE_180
,
772 if (err
== -EAGAIN
) {
781 if (mmc_host_is_spi(host
))
782 err
= mmc_send_cid(host
, cid
);
784 err
= mmc_all_send_cid(host
, cid
);
789 int mmc_sd_get_csd(struct mmc_host
*host
, struct mmc_card
*card
)
794 * Fetch CSD from card.
796 err
= mmc_send_csd(card
, card
->raw_csd
);
800 err
= mmc_decode_csd(card
);
807 static int mmc_sd_get_ro(struct mmc_host
*host
)
812 * Some systems don't feature a write-protect pin and don't need one.
813 * E.g. because they only have micro-SD card slot. For those systems
814 * assume that the SD card is always read-write.
816 if (host
->caps2
& MMC_CAP2_NO_WRITE_PROTECT
)
819 if (!host
->ops
->get_ro
)
822 mmc_host_clk_hold(host
);
823 ro
= host
->ops
->get_ro(host
);
824 mmc_host_clk_release(host
);
829 int mmc_sd_setup_card(struct mmc_host
*host
, struct mmc_card
*card
,
836 * Fetch SCR from card.
838 err
= mmc_app_send_scr(card
, card
->raw_scr
);
842 err
= mmc_decode_scr(card
);
847 * Fetch and process SD Status register.
849 err
= mmc_read_ssr(card
);
853 /* Erase init depends on CSD and SSR */
854 mmc_init_erase(card
);
857 * Fetch switch information from card.
859 err
= mmc_read_switch(card
);
865 * For SPI, enable CRC as appropriate.
866 * This CRC enable is located AFTER the reading of the
867 * card registers because some SDHC cards are not able
868 * to provide valid CRCs for non-512-byte blocks.
870 if (mmc_host_is_spi(host
)) {
871 err
= mmc_spi_set_crc(host
, use_spi_crc
);
877 * Check if read-only switch is active.
880 int ro
= mmc_sd_get_ro(host
);
883 pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
886 mmc_card_set_readonly(card
);
893 unsigned mmc_sd_get_max_clock(struct mmc_card
*card
)
895 unsigned max_dtr
= (unsigned int)-1;
897 if (mmc_card_hs(card
)) {
898 if (max_dtr
> card
->sw_caps
.hs_max_dtr
)
899 max_dtr
= card
->sw_caps
.hs_max_dtr
;
900 } else if (max_dtr
> card
->csd
.max_dtr
) {
901 max_dtr
= card
->csd
.max_dtr
;
908 * Handle the detection and initialisation of a card.
910 * In the case of a resume, "oldcard" will contain the card
911 * we're trying to reinitialise.
913 static int mmc_sd_init_card(struct mmc_host
*host
, u32 ocr
,
914 struct mmc_card
*oldcard
)
916 struct mmc_card
*card
;
922 WARN_ON(!host
->claimed
);
924 err
= mmc_sd_get_cid(host
, ocr
, cid
, &rocr
);
929 if (memcmp(cid
, oldcard
->raw_cid
, sizeof(cid
)) != 0)
935 * Allocate card structure.
937 card
= mmc_alloc_card(host
, &sd_type
);
939 return PTR_ERR(card
);
942 card
->type
= MMC_TYPE_SD
;
943 memcpy(card
->raw_cid
, cid
, sizeof(card
->raw_cid
));
947 * Call the optional HC's init_card function to handle quirks.
949 if (host
->ops
->init_card
)
950 host
->ops
->init_card(host
, card
);
953 * For native busses: get card RCA and quit open drain mode.
955 if (!mmc_host_is_spi(host
)) {
956 err
= mmc_send_relative_addr(host
, &card
->rca
);
962 err
= mmc_sd_get_csd(host
, card
);
966 mmc_decode_cid(card
);
970 * handling only for cards supporting DSR and hosts requesting
973 if (card
->csd
.dsr_imp
&& host
->dsr_req
)
977 * Select card, as all following commands rely on that.
979 if (!mmc_host_is_spi(host
)) {
980 err
= mmc_select_card(card
);
985 err
= mmc_sd_setup_card(host
, card
, oldcard
!= NULL
);
989 /* Initialization sequence for UHS-I cards */
990 if (rocr
& SD_ROCR_S18A
) {
991 err
= mmc_sd_init_uhs_card(card
);
996 * Attempt to change to high-speed (if supported)
998 err
= mmc_sd_switch_hs(card
);
1000 mmc_set_timing(card
->host
, MMC_TIMING_SD_HS
);
1007 mmc_set_clock(host
, mmc_sd_get_max_clock(card
));
1010 * Switch to wider bus (if supported).
1012 if ((host
->caps
& MMC_CAP_4_BIT_DATA
) &&
1013 (card
->scr
.bus_widths
& SD_SCR_BUS_WIDTH_4
)) {
1014 err
= mmc_app_set_bus_width(card
, MMC_BUS_WIDTH_4
);
1018 mmc_set_bus_width(host
, MMC_BUS_WIDTH_4
);
1027 mmc_remove_card(card
);
1033 * Host is being removed. Free up the current card.
1035 static void mmc_sd_remove(struct mmc_host
*host
)
1038 BUG_ON(!host
->card
);
1040 mmc_remove_card(host
->card
);
1045 * Card detection - card is alive.
1047 static int mmc_sd_alive(struct mmc_host
*host
)
1049 return mmc_send_status(host
->card
, NULL
);
1053 * Card detection callback from host.
1055 static void mmc_sd_detect(struct mmc_host
*host
)
1060 BUG_ON(!host
->card
);
1062 mmc_get_card(host
->card
);
1065 * Just check if our card has been removed.
1067 err
= _mmc_detect_card_removed(host
);
1069 mmc_put_card(host
->card
);
1072 mmc_sd_remove(host
);
1074 mmc_claim_host(host
);
1075 mmc_detach_bus(host
);
1076 mmc_power_off(host
);
1077 mmc_release_host(host
);
1081 static int _mmc_sd_suspend(struct mmc_host
*host
)
1086 BUG_ON(!host
->card
);
1088 mmc_claim_host(host
);
1090 if (mmc_card_suspended(host
->card
))
1093 if (!mmc_host_is_spi(host
))
1094 err
= mmc_deselect_cards(host
);
1097 mmc_power_off(host
);
1098 mmc_card_set_suspended(host
->card
);
1102 mmc_release_host(host
);
1107 * Callback for suspend
1109 static int mmc_sd_suspend(struct mmc_host
*host
)
1113 err
= _mmc_sd_suspend(host
);
1115 pm_runtime_disable(&host
->card
->dev
);
1116 pm_runtime_set_suspended(&host
->card
->dev
);
1123 * This function tries to determine if the same card is still present
1124 * and, if so, restore all state to it.
1126 static int _mmc_sd_resume(struct mmc_host
*host
)
1131 BUG_ON(!host
->card
);
1133 mmc_claim_host(host
);
1135 if (!mmc_card_suspended(host
->card
))
1138 mmc_power_up(host
, host
->card
->ocr
);
1139 err
= mmc_sd_init_card(host
, host
->card
->ocr
, host
->card
);
1140 mmc_card_clr_suspended(host
->card
);
1143 mmc_release_host(host
);
1148 * Callback for resume
1150 static int mmc_sd_resume(struct mmc_host
*host
)
1154 if (!(host
->caps
& MMC_CAP_RUNTIME_RESUME
)) {
1155 err
= _mmc_sd_resume(host
);
1156 pm_runtime_set_active(&host
->card
->dev
);
1157 pm_runtime_mark_last_busy(&host
->card
->dev
);
1159 pm_runtime_enable(&host
->card
->dev
);
1165 * Callback for runtime_suspend.
1167 static int mmc_sd_runtime_suspend(struct mmc_host
*host
)
1171 if (!(host
->caps
& MMC_CAP_AGGRESSIVE_PM
))
1174 err
= _mmc_sd_suspend(host
);
1176 pr_err("%s: error %d doing aggressive suspend\n",
1177 mmc_hostname(host
), err
);
1183 * Callback for runtime_resume.
1185 static int mmc_sd_runtime_resume(struct mmc_host
*host
)
1189 if (!(host
->caps
& (MMC_CAP_AGGRESSIVE_PM
| MMC_CAP_RUNTIME_RESUME
)))
1192 err
= _mmc_sd_resume(host
);
1194 pr_err("%s: error %d doing aggressive resume\n",
1195 mmc_hostname(host
), err
);
1200 static int mmc_sd_power_restore(struct mmc_host
*host
)
1204 mmc_claim_host(host
);
1205 ret
= mmc_sd_init_card(host
, host
->card
->ocr
, host
->card
);
1206 mmc_release_host(host
);
1211 static int mmc_sd_reset(struct mmc_host
*host
)
1213 mmc_power_cycle(host
, host
->card
->ocr
);
1214 return mmc_sd_power_restore(host
);
1217 static const struct mmc_bus_ops mmc_sd_ops
= {
1218 .remove
= mmc_sd_remove
,
1219 .detect
= mmc_sd_detect
,
1220 .runtime_suspend
= mmc_sd_runtime_suspend
,
1221 .runtime_resume
= mmc_sd_runtime_resume
,
1222 .suspend
= mmc_sd_suspend
,
1223 .resume
= mmc_sd_resume
,
1224 .power_restore
= mmc_sd_power_restore
,
1225 .alive
= mmc_sd_alive
,
1226 .shutdown
= mmc_sd_suspend
,
1227 .reset
= mmc_sd_reset
,
1231 * Starting point for SD card init.
1233 int mmc_attach_sd(struct mmc_host
*host
)
1239 WARN_ON(!host
->claimed
);
1241 err
= mmc_send_app_op_cond(host
, 0, &ocr
);
1245 mmc_attach_bus(host
, &mmc_sd_ops
);
1246 if (host
->ocr_avail_sd
)
1247 host
->ocr_avail
= host
->ocr_avail_sd
;
1250 * We need to get OCR a different way for SPI.
1252 if (mmc_host_is_spi(host
)) {
1255 err
= mmc_spi_read_ocr(host
, 0, &ocr
);
1260 rocr
= mmc_select_voltage(host
, ocr
);
1263 * Can we support the voltage(s) of the card(s)?
1271 * Detect and init the card.
1273 err
= mmc_sd_init_card(host
, rocr
, NULL
);
1277 mmc_release_host(host
);
1278 err
= mmc_add_card(host
->card
);
1279 mmc_claim_host(host
);
1286 mmc_release_host(host
);
1287 mmc_remove_card(host
->card
);
1289 mmc_claim_host(host
);
1291 mmc_detach_bus(host
);
1293 pr_err("%s: error %d whilst initialising SD card\n",
1294 mmc_hostname(host
), err
);