Branch data Line data Source code
1 : : /*
2 : : * linux/drivers/mmc/core/sd.c
3 : : *
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.
7 : : *
8 : : * This program is free software; you can redistribute it and/or modify
9 : : * it under the terms of the GNU General Public License version 2 as
10 : : * published by the Free Software Foundation.
11 : : */
12 : :
13 : : #include <linux/err.h>
14 : : #include <linux/sizes.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/stat.h>
17 : : #include <linux/pm_runtime.h>
18 : :
19 : : #include <linux/mmc/host.h>
20 : : #include <linux/mmc/card.h>
21 : : #include <linux/mmc/mmc.h>
22 : : #include <linux/mmc/sd.h>
23 : :
24 : : #include "core.h"
25 : : #include "bus.h"
26 : : #include "mmc_ops.h"
27 : : #include "sd.h"
28 : : #include "sd_ops.h"
29 : :
30 : : static const unsigned int tran_exp[] = {
31 : : 10000, 100000, 1000000, 10000000,
32 : : 0, 0, 0, 0
33 : : };
34 : :
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,
38 : : };
39 : :
40 : : static const unsigned int tacc_exp[] = {
41 : : 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
42 : : };
43 : :
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,
47 : : };
48 : :
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,
54 : : };
55 : :
56 : : #define UNSTUFF_BITS(resp,start,size) \
57 : : ({ \
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; \
62 : : u32 __res; \
63 : : \
64 : : __res = resp[__off] >> __shft; \
65 : : if (__size + __shft > 32) \
66 : : __res |= resp[__off-1] << ((32 - __shft) % 32); \
67 : : __res & __mask; \
68 : : })
69 : :
70 : : /*
71 : : * Given the decoded CSD structure, decode the raw CID to our CID structure.
72 : : */
73 : 0 : void mmc_decode_cid(struct mmc_card *card)
74 : : {
75 : : u32 *resp = card->raw_cid;
76 : :
77 : 0 : memset(&card->cid, 0, sizeof(struct mmc_cid));
78 : :
79 : : /*
80 : : * SD doesn't currently have a version field so we will
81 : : * have to assume we can parse this.
82 : : */
83 : 0 : card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
84 : 0 : card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
85 : 0 : card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
86 : 0 : card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
87 : 0 : card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
88 : 0 : card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
89 : 0 : card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
90 : 0 : card->cid.hwrev = UNSTUFF_BITS(resp, 60, 4);
91 : 0 : card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4);
92 : 0 : card->cid.serial = UNSTUFF_BITS(resp, 24, 32);
93 : 0 : card->cid.year = UNSTUFF_BITS(resp, 12, 8);
94 : 0 : card->cid.month = UNSTUFF_BITS(resp, 8, 4);
95 : :
96 : 0 : card->cid.year += 2000; /* SD cards year offset */
97 : 0 : }
98 : :
99 : : /*
100 : : * Given a 128-bit response, decode to our card CSD structure.
101 : : */
102 : 0 : static int mmc_decode_csd(struct mmc_card *card)
103 : : {
104 : : struct mmc_csd *csd = &card->csd;
105 : : unsigned int e, m, csd_struct;
106 : : u32 *resp = card->raw_csd;
107 : :
108 : 0 : csd_struct = UNSTUFF_BITS(resp, 126, 2);
109 : :
110 [ # # # ]: 0 : switch (csd_struct) {
111 : : case 0:
112 : 0 : m = UNSTUFF_BITS(resp, 115, 4);
113 : 0 : e = UNSTUFF_BITS(resp, 112, 3);
114 : 0 : csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
115 : 0 : csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
116 : :
117 : 0 : m = UNSTUFF_BITS(resp, 99, 4);
118 : 0 : e = UNSTUFF_BITS(resp, 96, 3);
119 : 0 : csd->max_dtr = tran_exp[e] * tran_mant[m];
120 : 0 : csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
121 : :
122 : 0 : e = UNSTUFF_BITS(resp, 47, 3);
123 : 0 : m = UNSTUFF_BITS(resp, 62, 12);
124 : 0 : csd->capacity = (1 + m) << (e + 2);
125 : :
126 : 0 : csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
127 : 0 : csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
128 : 0 : csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
129 : 0 : csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
130 : 0 : csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
131 : 0 : csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
132 : 0 : csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
133 : :
134 [ # # ]: 0 : if (UNSTUFF_BITS(resp, 46, 1)) {
135 : 0 : csd->erase_size = 1;
136 [ # # ]: 0 : } else if (csd->write_blkbits >= 9) {
137 : 0 : csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
138 : 0 : csd->erase_size <<= csd->write_blkbits - 9;
139 : : }
140 : : break;
141 : : case 1:
142 : : /*
143 : : * This is a block-addressed SDHC or SDXC card. Most
144 : : * interesting fields are unused and have fixed
145 : : * values. To avoid getting tripped by buggy cards,
146 : : * we assume those fixed values ourselves.
147 : : */
148 : 0 : mmc_card_set_blockaddr(card);
149 : :
150 : 0 : csd->tacc_ns = 0; /* Unused */
151 : 0 : csd->tacc_clks = 0; /* Unused */
152 : :
153 : 0 : m = UNSTUFF_BITS(resp, 99, 4);
154 : 0 : e = UNSTUFF_BITS(resp, 96, 3);
155 : 0 : csd->max_dtr = tran_exp[e] * tran_mant[m];
156 : 0 : csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
157 : 0 : csd->c_size = UNSTUFF_BITS(resp, 48, 22);
158 : :
159 : : /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
160 [ # # ]: 0 : if (csd->c_size >= 0xFFFF)
161 : 0 : mmc_card_set_ext_capacity(card);
162 : :
163 : : m = UNSTUFF_BITS(resp, 48, 22);
164 : 0 : csd->capacity = (1 + m) << 10;
165 : :
166 : 0 : csd->read_blkbits = 9;
167 : 0 : csd->read_partial = 0;
168 : 0 : csd->write_misalign = 0;
169 : 0 : csd->read_misalign = 0;
170 : 0 : csd->r2w_factor = 4; /* Unused */
171 : 0 : csd->write_blkbits = 9;
172 : 0 : csd->write_partial = 0;
173 : 0 : csd->erase_size = 1;
174 : 0 : break;
175 : : default:
176 : 0 : pr_err("%s: unrecognised CSD structure version %d\n",
177 : : mmc_hostname(card->host), csd_struct);
178 : 0 : return -EINVAL;
179 : : }
180 : :
181 : 0 : card->erase_size = csd->erase_size;
182 : :
183 : 0 : return 0;
184 : : }
185 : :
186 : : /*
187 : : * Given a 64-bit response, decode to our card SCR structure.
188 : : */
189 : 0 : static int mmc_decode_scr(struct mmc_card *card)
190 : : {
191 : : struct sd_scr *scr = &card->scr;
192 : : unsigned int scr_struct;
193 : : u32 resp[4];
194 : :
195 : : resp[3] = card->raw_scr[1];
196 : 0 : resp[2] = card->raw_scr[0];
197 : :
198 : 0 : scr_struct = UNSTUFF_BITS(resp, 60, 4);
199 [ # # ]: 0 : if (scr_struct != 0) {
200 : 0 : pr_err("%s: unrecognised SCR structure version %d\n",
201 : : mmc_hostname(card->host), scr_struct);
202 : 0 : return -EINVAL;
203 : : }
204 : :
205 : 0 : scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
206 : 0 : scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
207 [ # # ]: 0 : if (scr->sda_vsn == SCR_SPEC_VER_2)
208 : : /* Check if Physical Layer Spec v3.0 is supported */
209 : 0 : scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
210 : :
211 [ # # ]: 0 : if (UNSTUFF_BITS(resp, 55, 1))
212 : 0 : card->erased_byte = 0xFF;
213 : : else
214 : 0 : card->erased_byte = 0x0;
215 : :
216 [ # # ]: 0 : if (scr->sda_spec3)
217 : 0 : scr->cmds = UNSTUFF_BITS(resp, 32, 2);
218 : : return 0;
219 : : }
220 : :
221 : : /*
222 : : * Fetch and process SD Status register.
223 : : */
224 : 0 : static int mmc_read_ssr(struct mmc_card *card)
225 : : {
226 : : unsigned int au, es, et, eo;
227 : : int err, i;
228 : : u32 *ssr;
229 : :
230 [ # # ]: 0 : if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
231 : 0 : pr_warning("%s: card lacks mandatory SD Status "
232 : : "function.\n", mmc_hostname(card->host));
233 : 0 : return 0;
234 : : }
235 : :
236 : : ssr = kmalloc(64, GFP_KERNEL);
237 [ # # ]: 0 : if (!ssr)
238 : : return -ENOMEM;
239 : :
240 : 0 : err = mmc_app_sd_status(card, ssr);
241 [ # # ]: 0 : if (err) {
242 : 0 : pr_warning("%s: problem reading SD Status "
243 : : "register.\n", mmc_hostname(card->host));
244 : : err = 0;
245 : 0 : goto out;
246 : : }
247 : :
248 [ # # ]: 0 : for (i = 0; i < 16; i++)
249 [ # # ]: 0 : ssr[i] = be32_to_cpu(ssr[i]);
250 : :
251 : : /*
252 : : * UNSTUFF_BITS only works with four u32s so we have to offset the
253 : : * bitfield positions accordingly.
254 : : */
255 : 0 : au = UNSTUFF_BITS(ssr, 428 - 384, 4);
256 [ # # ]: 0 : if (au) {
257 [ # # ][ # # ]: 0 : if (au <= 9 || card->scr.sda_spec3) {
258 : 0 : card->ssr.au = sd_au_size[au];
259 : 0 : es = UNSTUFF_BITS(ssr, 408 - 384, 16);
260 : 0 : et = UNSTUFF_BITS(ssr, 402 - 384, 6);
261 [ # # ]: 0 : if (es && et) {
262 : 0 : eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
263 : 0 : card->ssr.erase_timeout = (et * 1000) / es;
264 : 0 : card->ssr.erase_offset = eo * 1000;
265 : : }
266 : : } else {
267 : 0 : pr_warning("%s: SD Status: Invalid Allocation Unit size.\n",
268 : : mmc_hostname(card->host));
269 : : }
270 : : }
271 : : out:
272 : 0 : kfree(ssr);
273 : 0 : return err;
274 : : }
275 : :
276 : : /*
277 : : * Fetches and decodes switch information
278 : : */
279 : 0 : static int mmc_read_switch(struct mmc_card *card)
280 : : {
281 : : int err;
282 : : u8 *status;
283 : :
284 [ # # ]: 0 : if (card->scr.sda_vsn < SCR_SPEC_VER_1)
285 : : return 0;
286 : :
287 [ # # ]: 0 : if (!(card->csd.cmdclass & CCC_SWITCH)) {
288 : 0 : pr_warning("%s: card lacks mandatory switch "
289 : : "function, performance might suffer.\n",
290 : : mmc_hostname(card->host));
291 : 0 : return 0;
292 : : }
293 : :
294 : : err = -EIO;
295 : :
296 : : status = kmalloc(64, GFP_KERNEL);
297 [ # # ]: 0 : if (!status) {
298 : 0 : pr_err("%s: could not allocate a buffer for "
299 : : "switch capabilities.\n",
300 : : mmc_hostname(card->host));
301 : 0 : return -ENOMEM;
302 : : }
303 : :
304 : : /*
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.
308 : : */
309 : 0 : err = mmc_sd_switch(card, 0, 0, 0, status);
310 [ # # ]: 0 : if (err) {
311 : : /*
312 : : * If the host or the card can't do the switch,
313 : : * fail more gracefully.
314 : : */
315 [ # # ][ # # ]: 0 : if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
316 : : goto out;
317 : :
318 : 0 : pr_warning("%s: problem reading Bus Speed modes.\n",
319 : : mmc_hostname(card->host));
320 : : err = 0;
321 : :
322 : 0 : goto out;
323 : : }
324 : :
325 [ # # ]: 0 : if (status[13] & SD_MODE_HIGH_SPEED)
326 : 0 : card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
327 : :
328 [ # # ]: 0 : if (card->scr.sda_spec3) {
329 : 0 : card->sw_caps.sd3_bus_mode = status[13];
330 : : /* Driver Strengths supported by the card */
331 : 0 : card->sw_caps.sd3_drv_type = status[9];
332 : : }
333 : :
334 : : out:
335 : 0 : kfree(status);
336 : :
337 : 0 : return err;
338 : : }
339 : :
340 : : /*
341 : : * Test if the card supports high-speed mode and, if so, switch to it.
342 : : */
343 : 0 : int mmc_sd_switch_hs(struct mmc_card *card)
344 : : {
345 : : int err;
346 : : u8 *status;
347 : :
348 [ # # ]: 0 : if (card->scr.sda_vsn < SCR_SPEC_VER_1)
349 : : return 0;
350 : :
351 [ # # ]: 0 : if (!(card->csd.cmdclass & CCC_SWITCH))
352 : : return 0;
353 : :
354 [ # # ]: 0 : if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
355 : : return 0;
356 : :
357 [ # # ]: 0 : if (card->sw_caps.hs_max_dtr == 0)
358 : : return 0;
359 : :
360 : : err = -EIO;
361 : :
362 : : status = kmalloc(64, GFP_KERNEL);
363 [ # # ]: 0 : if (!status) {
364 : 0 : pr_err("%s: could not allocate a buffer for "
365 : : "switch capabilities.\n", mmc_hostname(card->host));
366 : 0 : return -ENOMEM;
367 : : }
368 : :
369 : 0 : err = mmc_sd_switch(card, 1, 0, 1, status);
370 [ # # ]: 0 : if (err)
371 : : goto out;
372 : :
373 [ # # ]: 0 : if ((status[16] & 0xF) != 1) {
374 : 0 : pr_warning("%s: Problem switching card "
375 : : "into high-speed mode!\n",
376 : : mmc_hostname(card->host));
377 : : err = 0;
378 : : } else {
379 : : err = 1;
380 : : }
381 : :
382 : : out:
383 : 0 : kfree(status);
384 : :
385 : 0 : return err;
386 : : }
387 : :
388 : 0 : static int sd_select_driver_type(struct mmc_card *card, u8 *status)
389 : : {
390 : : int host_drv_type = SD_DRIVER_TYPE_B;
391 : : int card_drv_type = SD_DRIVER_TYPE_B;
392 : : int drive_strength;
393 : : int err;
394 : :
395 : : /*
396 : : * If the host doesn't support any of the Driver Types A,C or D,
397 : : * or there is no board specific handler then default Driver
398 : : * Type B is used.
399 : : */
400 [ # # ]: 0 : if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
401 : : | MMC_CAP_DRIVER_TYPE_D)))
402 : : return 0;
403 : :
404 [ # # ]: 0 : if (!card->host->ops->select_drive_strength)
405 : : return 0;
406 : :
407 [ # # ]: 0 : if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
408 : : host_drv_type |= SD_DRIVER_TYPE_A;
409 : :
410 [ # # ]: 0 : if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
411 : 0 : host_drv_type |= SD_DRIVER_TYPE_C;
412 : :
413 [ # # ]: 0 : if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
414 : 0 : host_drv_type |= SD_DRIVER_TYPE_D;
415 : :
416 [ # # ]: 0 : if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
417 : : card_drv_type |= SD_DRIVER_TYPE_A;
418 : :
419 [ # # ]: 0 : if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
420 : 0 : card_drv_type |= SD_DRIVER_TYPE_C;
421 : :
422 [ # # ]: 0 : if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
423 : 0 : card_drv_type |= SD_DRIVER_TYPE_D;
424 : :
425 : : /*
426 : : * The drive strength that the hardware can support
427 : : * depends on the board design. Pass the appropriate
428 : : * information and let the hardware specific code
429 : : * return what is possible given the options
430 : : */
431 : : mmc_host_clk_hold(card->host);
432 : 0 : drive_strength = card->host->ops->select_drive_strength(
433 : : card->sw_caps.uhs_max_dtr,
434 : : host_drv_type, card_drv_type);
435 : : mmc_host_clk_release(card->host);
436 : :
437 : 0 : err = mmc_sd_switch(card, 1, 2, drive_strength, status);
438 [ # # ]: 0 : if (err)
439 : : return err;
440 : :
441 [ # # ]: 0 : if ((status[15] & 0xF) != drive_strength) {
442 : 0 : pr_warning("%s: Problem setting drive strength!\n",
443 : : mmc_hostname(card->host));
444 : 0 : return 0;
445 : : }
446 : :
447 : 0 : mmc_set_driver_type(card->host, drive_strength);
448 : :
449 : 0 : return 0;
450 : : }
451 : :
452 : 0 : static void sd_update_bus_speed_mode(struct mmc_card *card)
453 : : {
454 : : /*
455 : : * If the host doesn't support any of the UHS-I modes, fallback on
456 : : * default speed.
457 : : */
458 [ # # ]: 0 : if (!mmc_host_uhs(card->host)) {
459 : 0 : card->sd_bus_speed = 0;
460 : 0 : return;
461 : : }
462 : :
463 [ # # ][ # # ]: 0 : if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
464 : 0 : (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
465 : 0 : card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
466 [ # # ][ # # ]: 0 : } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
467 : 0 : (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
468 : 0 : card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
469 [ # # ]: 0 : } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
470 [ # # ]: 0 : MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
471 : : SD_MODE_UHS_SDR50)) {
472 : 0 : card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
473 [ # # ]: 0 : } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
474 [ # # ]: 0 : MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
475 : 0 : (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
476 : 0 : card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
477 [ # # ]: 0 : } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
478 : : MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
479 [ # # ]: 0 : MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
480 : : SD_MODE_UHS_SDR12)) {
481 : 0 : card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
482 : : }
483 : : }
484 : :
485 : 0 : static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
486 : : {
487 : : int err;
488 : : unsigned int timing = 0;
489 : :
490 [ # # # # : 0 : switch (card->sd_bus_speed) {
# # ]
491 : : case UHS_SDR104_BUS_SPEED:
492 : : timing = MMC_TIMING_UHS_SDR104;
493 : 0 : card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
494 : 0 : break;
495 : : case UHS_DDR50_BUS_SPEED:
496 : : timing = MMC_TIMING_UHS_DDR50;
497 : 0 : card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
498 : 0 : break;
499 : : case UHS_SDR50_BUS_SPEED:
500 : : timing = MMC_TIMING_UHS_SDR50;
501 : 0 : card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
502 : 0 : break;
503 : : case UHS_SDR25_BUS_SPEED:
504 : : timing = MMC_TIMING_UHS_SDR25;
505 : 0 : card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
506 : 0 : break;
507 : : case UHS_SDR12_BUS_SPEED:
508 : : timing = MMC_TIMING_UHS_SDR12;
509 : 0 : card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
510 : 0 : break;
511 : : default:
512 : : return 0;
513 : : }
514 : :
515 : 0 : err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
516 [ # # ]: 0 : if (err)
517 : : return err;
518 : :
519 [ # # ]: 0 : if ((status[16] & 0xF) != card->sd_bus_speed)
520 : 0 : pr_warning("%s: Problem setting bus speed mode!\n",
521 : : mmc_hostname(card->host));
522 : : else {
523 : 0 : mmc_set_timing(card->host, timing);
524 : 0 : mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
525 : : }
526 : :
527 : : return 0;
528 : : }
529 : :
530 : : /* Get host's max current setting at its current voltage */
531 : 0 : static u32 sd_get_host_max_current(struct mmc_host *host)
532 : : {
533 : : u32 voltage, max_current;
534 : :
535 : 0 : voltage = 1 << host->ios.vdd;
536 [ # # # # ]: 0 : switch (voltage) {
537 : : case MMC_VDD_165_195:
538 : 0 : max_current = host->max_current_180;
539 : 0 : break;
540 : : case MMC_VDD_29_30:
541 : : case MMC_VDD_30_31:
542 : 0 : max_current = host->max_current_300;
543 : 0 : break;
544 : : case MMC_VDD_32_33:
545 : : case MMC_VDD_33_34:
546 : 0 : max_current = host->max_current_330;
547 : 0 : break;
548 : : default:
549 : : max_current = 0;
550 : : }
551 : :
552 : 0 : return max_current;
553 : : }
554 : :
555 : 0 : static int sd_set_current_limit(struct mmc_card *card, u8 *status)
556 : : {
557 : : int current_limit = SD_SET_CURRENT_NO_CHANGE;
558 : : int err;
559 : : u32 max_current;
560 : :
561 : : /*
562 : : * Current limit switch is only defined for SDR50, SDR104, and DDR50
563 : : * bus speed modes. For other bus speed modes, we do not change the
564 : : * current limit.
565 : : */
566 [ # # ]: 0 : if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
567 : 0 : (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
568 : : (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
569 : : return 0;
570 : :
571 : : /*
572 : : * Host has different current capabilities when operating at
573 : : * different voltages, so find out its max current first.
574 : : */
575 : 0 : max_current = sd_get_host_max_current(card->host);
576 : :
577 : : /*
578 : : * We only check host's capability here, if we set a limit that is
579 : : * higher than the card's maximum current, the card will be using its
580 : : * maximum current, e.g. if the card's maximum current is 300ma, and
581 : : * when we set current limit to 200ma, the card will draw 200ma, and
582 : : * when we set current limit to 400/600/800ma, the card will draw its
583 : : * maximum 300ma from the host.
584 : : */
585 [ # # ]: 0 : if (max_current >= 800)
586 : : current_limit = SD_SET_CURRENT_LIMIT_800;
587 [ # # ]: 0 : else if (max_current >= 600)
588 : : current_limit = SD_SET_CURRENT_LIMIT_600;
589 [ # # ]: 0 : else if (max_current >= 400)
590 : : current_limit = SD_SET_CURRENT_LIMIT_400;
591 [ # # ]: 0 : else if (max_current >= 200)
592 : : current_limit = SD_SET_CURRENT_LIMIT_200;
593 : :
594 [ # # ]: 0 : if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
595 : 0 : err = mmc_sd_switch(card, 1, 3, current_limit, status);
596 [ # # ]: 0 : if (err)
597 : : return err;
598 : :
599 [ # # ]: 0 : if (((status[15] >> 4) & 0x0F) != current_limit)
600 : 0 : pr_warning("%s: Problem setting current limit!\n",
601 : : mmc_hostname(card->host));
602 : :
603 : : }
604 : :
605 : : return 0;
606 : : }
607 : :
608 : : /*
609 : : * UHS-I specific initialization procedure
610 : : */
611 : 0 : static int mmc_sd_init_uhs_card(struct mmc_card *card)
612 : : {
613 : : int err;
614 : : u8 *status;
615 : :
616 [ # # ]: 0 : if (!card->scr.sda_spec3)
617 : : return 0;
618 : :
619 [ # # ]: 0 : if (!(card->csd.cmdclass & CCC_SWITCH))
620 : : return 0;
621 : :
622 : : status = kmalloc(64, GFP_KERNEL);
623 [ # # ]: 0 : if (!status) {
624 : 0 : pr_err("%s: could not allocate a buffer for "
625 : : "switch capabilities.\n", mmc_hostname(card->host));
626 : 0 : return -ENOMEM;
627 : : }
628 : :
629 : : /* Set 4-bit bus width */
630 [ # # ][ # # ]: 0 : if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
631 : 0 : (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
632 : 0 : err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
633 [ # # ]: 0 : if (err)
634 : : goto out;
635 : :
636 : 0 : mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
637 : : }
638 : :
639 : : /*
640 : : * Select the bus speed mode depending on host
641 : : * and card capability.
642 : : */
643 : 0 : sd_update_bus_speed_mode(card);
644 : :
645 : : /* Set the driver strength for the card */
646 : 0 : err = sd_select_driver_type(card, status);
647 [ # # ]: 0 : if (err)
648 : : goto out;
649 : :
650 : : /* Set current limit for the card */
651 : 0 : err = sd_set_current_limit(card, status);
652 [ # # ]: 0 : if (err)
653 : : goto out;
654 : :
655 : : /* Set bus speed mode of the card */
656 : 0 : err = sd_set_bus_speed_mode(card, status);
657 [ # # ]: 0 : if (err)
658 : : goto out;
659 : :
660 : : /*
661 : : * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
662 : : * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
663 : : */
664 [ # # ][ # # ]: 0 : if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning &&
[ # # ]
665 : 0 : (card->sd_bus_speed == UHS_SDR50_BUS_SPEED ||
666 : : card->sd_bus_speed == UHS_SDR104_BUS_SPEED)) {
667 : : mmc_host_clk_hold(card->host);
668 : 0 : err = card->host->ops->execute_tuning(card->host,
669 : : MMC_SEND_TUNING_BLOCK);
670 : : mmc_host_clk_release(card->host);
671 : : }
672 : :
673 : : out:
674 : 0 : kfree(status);
675 : :
676 : 0 : return err;
677 : : }
678 : :
679 : 0 : MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
680 : : card->raw_cid[2], card->raw_cid[3]);
681 : 0 : MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
682 : : card->raw_csd[2], card->raw_csd[3]);
683 : 0 : MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
684 : 0 : MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
685 : 0 : MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
686 : 0 : MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
687 : 0 : MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
688 : 0 : MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
689 : 0 : MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
690 : 0 : MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
691 : 0 : MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
692 : 0 : MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
693 : :
694 : :
695 : : static struct attribute *sd_std_attrs[] = {
696 : : &dev_attr_cid.attr,
697 : : &dev_attr_csd.attr,
698 : : &dev_attr_scr.attr,
699 : : &dev_attr_date.attr,
700 : : &dev_attr_erase_size.attr,
701 : : &dev_attr_preferred_erase_size.attr,
702 : : &dev_attr_fwrev.attr,
703 : : &dev_attr_hwrev.attr,
704 : : &dev_attr_manfid.attr,
705 : : &dev_attr_name.attr,
706 : : &dev_attr_oemid.attr,
707 : : &dev_attr_serial.attr,
708 : : NULL,
709 : : };
710 : :
711 : : static struct attribute_group sd_std_attr_group = {
712 : : .attrs = sd_std_attrs,
713 : : };
714 : :
715 : : static const struct attribute_group *sd_attr_groups[] = {
716 : : &sd_std_attr_group,
717 : : NULL,
718 : : };
719 : :
720 : : struct device_type sd_type = {
721 : : .groups = sd_attr_groups,
722 : : };
723 : :
724 : : /*
725 : : * Fetch CID from card.
726 : : */
727 : 0 : int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
728 : : {
729 : : int err;
730 : : u32 max_current;
731 : : int retries = 10;
732 : : u32 pocr = ocr;
733 : :
734 : : try_again:
735 [ # # ]: 0 : if (!retries) {
736 : 0 : ocr &= ~SD_OCR_S18R;
737 : 0 : pr_warning("%s: Skipping voltage switch\n",
738 : : mmc_hostname(host));
739 : : }
740 : :
741 : : /*
742 : : * Since we're changing the OCR value, we seem to
743 : : * need to tell some cards to go back to the idle
744 : : * state. We wait 1ms to give cards time to
745 : : * respond.
746 : : */
747 : 0 : mmc_go_idle(host);
748 : :
749 : : /*
750 : : * If SD_SEND_IF_COND indicates an SD 2.0
751 : : * compliant card and we should set bit 30
752 : : * of the ocr to indicate that we can handle
753 : : * block-addressed SDHC cards.
754 : : */
755 : 0 : err = mmc_send_if_cond(host, ocr);
756 [ # # ]: 0 : if (!err)
757 : 0 : ocr |= SD_OCR_CCS;
758 : :
759 : : /*
760 : : * If the host supports one of UHS-I modes, request the card
761 : : * to switch to 1.8V signaling level. If the card has failed
762 : : * repeatedly to switch however, skip this.
763 : : */
764 [ # # ][ # # ]: 0 : if (retries && mmc_host_uhs(host))
765 : 0 : ocr |= SD_OCR_S18R;
766 : :
767 : : /*
768 : : * If the host can supply more than 150mA at current voltage,
769 : : * XPC should be set to 1.
770 : : */
771 : 0 : max_current = sd_get_host_max_current(host);
772 [ # # ]: 0 : if (max_current > 150)
773 : 0 : ocr |= SD_OCR_XPC;
774 : :
775 : 0 : err = mmc_send_app_op_cond(host, ocr, rocr);
776 [ # # ]: 0 : if (err)
777 : : return err;
778 : :
779 : : /*
780 : : * In case CCS and S18A in the response is set, start Signal Voltage
781 : : * Switch procedure. SPI mode doesn't support CMD11.
782 : : */
783 [ # # ][ # # ]: 0 : if (!mmc_host_is_spi(host) && rocr &&
[ # # ]
784 : 0 : ((*rocr & 0x41000000) == 0x41000000)) {
785 : 0 : err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
786 : : pocr);
787 [ # # ]: 0 : if (err == -EAGAIN) {
788 : 0 : retries--;
789 : 0 : goto try_again;
790 [ # # ]: 0 : } else if (err) {
791 : : retries = 0;
792 : : goto try_again;
793 : : }
794 : : }
795 : :
796 [ # # ]: 0 : if (mmc_host_is_spi(host))
797 : 0 : err = mmc_send_cid(host, cid);
798 : : else
799 : 0 : err = mmc_all_send_cid(host, cid);
800 : :
801 : 0 : return err;
802 : : }
803 : :
804 : 0 : int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
805 : : {
806 : : int err;
807 : :
808 : : /*
809 : : * Fetch CSD from card.
810 : : */
811 : 0 : err = mmc_send_csd(card, card->raw_csd);
812 [ # # ]: 0 : if (err)
813 : : return err;
814 : :
815 : 0 : err = mmc_decode_csd(card);
816 [ # # ]: 0 : if (err)
817 : 0 : return err;
818 : :
819 : : return 0;
820 : : }
821 : :
822 : 0 : int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
823 : : bool reinit)
824 : : {
825 : : int err;
826 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
827 : : int retries;
828 : : #endif
829 : :
830 [ # # ]: 0 : if (!reinit) {
831 : : /*
832 : : * Fetch SCR from card.
833 : : */
834 : 0 : err = mmc_app_send_scr(card, card->raw_scr);
835 [ # # ]: 0 : if (err)
836 : : return err;
837 : :
838 : 0 : err = mmc_decode_scr(card);
839 [ # # ]: 0 : if (err)
840 : : return err;
841 : :
842 : : /*
843 : : * Fetch and process SD Status register.
844 : : */
845 : 0 : err = mmc_read_ssr(card);
846 [ # # ]: 0 : if (err)
847 : : return err;
848 : :
849 : : /* Erase init depends on CSD and SSR */
850 : 0 : mmc_init_erase(card);
851 : :
852 : : /*
853 : : * Fetch switch information from card.
854 : : */
855 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
856 : : for (retries = 1; retries <= 3; retries++) {
857 : : err = mmc_read_switch(card);
858 : : if (!err) {
859 : : if (retries > 1) {
860 : : printk(KERN_WARNING
861 : : "%s: recovered\n",
862 : : mmc_hostname(host));
863 : : }
864 : : break;
865 : : } else {
866 : : printk(KERN_WARNING
867 : : "%s: read switch failed (attempt %d)\n",
868 : : mmc_hostname(host), retries);
869 : : }
870 : : }
871 : : #else
872 : 0 : err = mmc_read_switch(card);
873 : : #endif
874 : :
875 [ # # ]: 0 : if (err)
876 : : return err;
877 : : }
878 : :
879 : : /*
880 : : * For SPI, enable CRC as appropriate.
881 : : * This CRC enable is located AFTER the reading of the
882 : : * card registers because some SDHC cards are not able
883 : : * to provide valid CRCs for non-512-byte blocks.
884 : : */
885 [ # # ]: 0 : if (mmc_host_is_spi(host)) {
886 : 0 : err = mmc_spi_set_crc(host, use_spi_crc);
887 [ # # ]: 0 : if (err)
888 : : return err;
889 : : }
890 : :
891 : : /*
892 : : * Check if read-only switch is active.
893 : : */
894 [ # # ]: 0 : if (!reinit) {
895 : : int ro = -1;
896 : :
897 [ # # ]: 0 : if (host->ops->get_ro) {
898 : : mmc_host_clk_hold(card->host);
899 : 0 : ro = host->ops->get_ro(host);
900 : : mmc_host_clk_release(card->host);
901 : : }
902 : :
903 [ # # ]: 0 : if (ro < 0) {
904 : 0 : pr_warning("%s: host does not "
905 : : "support reading read-only "
906 : : "switch. assuming write-enable.\n",
907 : : mmc_hostname(host));
908 [ # # ]: 0 : } else if (ro > 0) {
909 : 0 : mmc_card_set_readonly(card);
910 : : }
911 : : }
912 : :
913 : : return 0;
914 : : }
915 : :
916 : 0 : unsigned mmc_sd_get_max_clock(struct mmc_card *card)
917 : : {
918 : : unsigned max_dtr = (unsigned int)-1;
919 : :
920 [ # # ][ # # ]: 0 : if (mmc_card_highspeed(card)) {
921 [ # # ][ # # ]: 0 : if (max_dtr > card->sw_caps.hs_max_dtr)
922 : : max_dtr = card->sw_caps.hs_max_dtr;
923 [ # # ][ # # ]: 0 : } else if (max_dtr > card->csd.max_dtr) {
924 : : max_dtr = card->csd.max_dtr;
925 : : }
926 : :
927 : 0 : return max_dtr;
928 : : }
929 : :
930 : 0 : void mmc_sd_go_highspeed(struct mmc_card *card)
931 : : {
932 : 0 : mmc_card_set_highspeed(card);
933 : 0 : mmc_set_timing(card->host, MMC_TIMING_SD_HS);
934 : 0 : }
935 : :
936 : : /*
937 : : * Handle the detection and initialisation of a card.
938 : : *
939 : : * In the case of a resume, "oldcard" will contain the card
940 : : * we're trying to reinitialise.
941 : : */
942 : 0 : static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
943 : : struct mmc_card *oldcard)
944 : : {
945 : : struct mmc_card *card;
946 : : int err;
947 : : u32 cid[4];
948 : 0 : u32 rocr = 0;
949 : :
950 [ # # ]: 0 : BUG_ON(!host);
951 [ # # ]: 0 : WARN_ON(!host->claimed);
952 : :
953 : 0 : err = mmc_sd_get_cid(host, ocr, cid, &rocr);
954 [ # # ]: 0 : if (err)
955 : : return err;
956 : :
957 [ # # ]: 0 : if (oldcard) {
958 [ # # ]: 0 : if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
959 : : return -ENOENT;
960 : :
961 : : card = oldcard;
962 : : } else {
963 : : /*
964 : : * Allocate card structure.
965 : : */
966 : 0 : card = mmc_alloc_card(host, &sd_type);
967 [ # # ]: 0 : if (IS_ERR(card))
968 : 0 : return PTR_ERR(card);
969 : :
970 : 0 : card->ocr = ocr;
971 : 0 : card->type = MMC_TYPE_SD;
972 : 0 : memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
973 : : }
974 : :
975 : : /*
976 : : * For native busses: get card RCA and quit open drain mode.
977 : : */
978 [ # # ]: 0 : if (!mmc_host_is_spi(host)) {
979 : 0 : err = mmc_send_relative_addr(host, &card->rca);
980 [ # # ]: 0 : if (err)
981 : : goto free_card;
982 : : }
983 : :
984 [ # # ]: 0 : if (!oldcard) {
985 : 0 : err = mmc_sd_get_csd(host, card);
986 [ # # ]: 0 : if (err)
987 : : goto free_card;
988 : :
989 : 0 : mmc_decode_cid(card);
990 : : }
991 : :
992 : : /*
993 : : * Select card, as all following commands rely on that.
994 : : */
995 [ # # ]: 0 : if (!mmc_host_is_spi(host)) {
996 : 0 : err = mmc_select_card(card);
997 [ # # ]: 0 : if (err)
998 : : goto free_card;
999 : : }
1000 : :
1001 : 0 : err = mmc_sd_setup_card(host, card, oldcard != NULL);
1002 [ # # ]: 0 : if (err)
1003 : : goto free_card;
1004 : :
1005 : : /* Initialization sequence for UHS-I cards */
1006 [ # # ]: 0 : if (rocr & SD_ROCR_S18A) {
1007 : 0 : err = mmc_sd_init_uhs_card(card);
1008 [ # # ]: 0 : if (err)
1009 : : goto free_card;
1010 : :
1011 : : /* Card is an ultra-high-speed card */
1012 : 0 : mmc_card_set_uhs(card);
1013 : : } else {
1014 : : /*
1015 : : * Attempt to change to high-speed (if supported)
1016 : : */
1017 : 0 : err = mmc_sd_switch_hs(card);
1018 [ # # ]: 0 : if (err > 0)
1019 : : mmc_sd_go_highspeed(card);
1020 [ # # ]: 0 : else if (err)
1021 : : goto free_card;
1022 : :
1023 : : /*
1024 : : * Set bus speed.
1025 : : */
1026 : 0 : mmc_set_clock(host, mmc_sd_get_max_clock(card));
1027 : :
1028 : : /*
1029 : : * Switch to wider bus (if supported).
1030 : : */
1031 [ # # ][ # # ]: 0 : if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1032 : 0 : (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1033 : 0 : err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1034 [ # # ]: 0 : if (err)
1035 : : goto free_card;
1036 : :
1037 : 0 : mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1038 : : }
1039 : : }
1040 : :
1041 : 0 : host->card = card;
1042 : 0 : return 0;
1043 : :
1044 : : free_card:
1045 [ # # ]: 0 : if (!oldcard)
1046 : 0 : mmc_remove_card(card);
1047 : :
1048 : 0 : return err;
1049 : : }
1050 : :
1051 : : /*
1052 : : * Host is being removed. Free up the current card.
1053 : : */
1054 : 0 : static void mmc_sd_remove(struct mmc_host *host)
1055 : : {
1056 [ # # ]: 0 : BUG_ON(!host);
1057 [ # # ]: 0 : BUG_ON(!host->card);
1058 : :
1059 : 0 : mmc_remove_card(host->card);
1060 : 0 : host->card = NULL;
1061 : 0 : }
1062 : :
1063 : : /*
1064 : : * Card detection - card is alive.
1065 : : */
1066 : 0 : static int mmc_sd_alive(struct mmc_host *host)
1067 : : {
1068 : 0 : return mmc_send_status(host->card, NULL);
1069 : : }
1070 : :
1071 : : /*
1072 : : * Card detection callback from host.
1073 : : */
1074 : 0 : static void mmc_sd_detect(struct mmc_host *host)
1075 : : {
1076 : : int err = 0;
1077 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1078 : : int retries = 5;
1079 : : #endif
1080 : :
1081 [ # # ]: 0 : BUG_ON(!host);
1082 [ # # ]: 0 : BUG_ON(!host->card);
1083 : :
1084 : 0 : mmc_get_card(host->card);
1085 : :
1086 : : /*
1087 : : * Just check if our card has been removed.
1088 : : */
1089 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1090 : : while(retries) {
1091 : : err = mmc_send_status(host->card, NULL);
1092 : : if (err) {
1093 : : retries--;
1094 : : udelay(5);
1095 : : continue;
1096 : : }
1097 : : break;
1098 : : }
1099 : : if (!retries) {
1100 : : printk(KERN_ERR "%s(%s): Unable to re-detect card (%d)\n",
1101 : : __func__, mmc_hostname(host), err);
1102 : : }
1103 : : #else
1104 : 0 : err = _mmc_detect_card_removed(host);
1105 : : #endif
1106 : :
1107 : 0 : mmc_put_card(host->card);
1108 : :
1109 [ # # ]: 0 : if (err) {
1110 : 0 : mmc_sd_remove(host);
1111 : :
1112 : : mmc_claim_host(host);
1113 : 0 : mmc_detach_bus(host);
1114 : 0 : mmc_power_off(host);
1115 : 0 : mmc_release_host(host);
1116 : : }
1117 : 0 : }
1118 : :
1119 : 0 : static int _mmc_sd_suspend(struct mmc_host *host)
1120 : : {
1121 : : int err = 0;
1122 : :
1123 [ # # ]: 0 : BUG_ON(!host);
1124 [ # # ]: 0 : BUG_ON(!host->card);
1125 : :
1126 : : mmc_claim_host(host);
1127 : :
1128 [ # # ]: 0 : if (mmc_card_suspended(host->card))
1129 : : goto out;
1130 : :
1131 [ # # ]: 0 : if (!mmc_host_is_spi(host))
1132 : 0 : err = mmc_deselect_cards(host);
1133 : 0 : host->card->state &= ~MMC_STATE_HIGHSPEED;
1134 [ # # ]: 0 : if (!err) {
1135 : 0 : mmc_power_off(host);
1136 : 0 : mmc_card_set_suspended(host->card);
1137 : : }
1138 : :
1139 : : out:
1140 : 0 : mmc_release_host(host);
1141 : 0 : return err;
1142 : : }
1143 : :
1144 : : /*
1145 : : * Callback for suspend
1146 : : */
1147 : 0 : static int mmc_sd_suspend(struct mmc_host *host)
1148 : : {
1149 : : int err;
1150 : :
1151 : 0 : err = _mmc_sd_suspend(host);
1152 : : if (!err) {
1153 : : pm_runtime_disable(&host->card->dev);
1154 : : pm_runtime_set_suspended(&host->card->dev);
1155 : : }
1156 : :
1157 : 0 : return err;
1158 : : }
1159 : :
1160 : : /*
1161 : : * This function tries to determine if the same card is still present
1162 : : * and, if so, restore all state to it.
1163 : : */
1164 : 0 : static int _mmc_sd_resume(struct mmc_host *host)
1165 : : {
1166 : : int err = 0;
1167 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1168 : : int retries;
1169 : : #endif
1170 : :
1171 [ # # ]: 0 : BUG_ON(!host);
1172 [ # # ]: 0 : BUG_ON(!host->card);
1173 : :
1174 : : mmc_claim_host(host);
1175 : :
1176 [ # # ]: 0 : if (!mmc_card_suspended(host->card))
1177 : : goto out;
1178 : :
1179 : 0 : mmc_power_up(host, host->card->ocr);
1180 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1181 : : retries = 5;
1182 : : while (retries) {
1183 : : err = mmc_sd_init_card(host, host->card->ocr, host->card);
1184 : :
1185 : : if (err) {
1186 : : printk(KERN_ERR "%s: Re-init card rc = %d (retries = %d)\n",
1187 : : mmc_hostname(host), err, retries);
1188 : : mdelay(5);
1189 : : retries--;
1190 : : continue;
1191 : : }
1192 : : break;
1193 : : }
1194 : : #else
1195 : 0 : err = mmc_sd_init_card(host, host->card->ocr, host->card);
1196 : : #endif
1197 : 0 : mmc_card_clr_suspended(host->card);
1198 : :
1199 : : out:
1200 : 0 : mmc_release_host(host);
1201 : 0 : return err;
1202 : : }
1203 : :
1204 : : /*
1205 : : * Callback for resume
1206 : : */
1207 : 0 : static int mmc_sd_resume(struct mmc_host *host)
1208 : : {
1209 : : int err = 0;
1210 : :
1211 [ # # ]: 0 : if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
1212 : 0 : err = _mmc_sd_resume(host);
1213 : : pm_runtime_set_active(&host->card->dev);
1214 : : pm_runtime_mark_last_busy(&host->card->dev);
1215 : : }
1216 : : pm_runtime_enable(&host->card->dev);
1217 : :
1218 : 0 : return err;
1219 : : }
1220 : :
1221 : : /*
1222 : : * Callback for runtime_suspend.
1223 : : */
1224 : 0 : static int mmc_sd_runtime_suspend(struct mmc_host *host)
1225 : : {
1226 : : int err;
1227 : :
1228 [ # # ]: 0 : if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1229 : : return 0;
1230 : :
1231 : 0 : err = _mmc_sd_suspend(host);
1232 [ # # ]: 0 : if (err)
1233 : 0 : pr_err("%s: error %d doing aggessive suspend\n",
1234 : : mmc_hostname(host), err);
1235 : :
1236 : 0 : return err;
1237 : : }
1238 : :
1239 : : /*
1240 : : * Callback for runtime_resume.
1241 : : */
1242 : 0 : static int mmc_sd_runtime_resume(struct mmc_host *host)
1243 : : {
1244 : : int err;
1245 : :
1246 [ # # ]: 0 : if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
1247 : : return 0;
1248 : :
1249 : 0 : err = _mmc_sd_resume(host);
1250 [ # # ]: 0 : if (err)
1251 : 0 : pr_err("%s: error %d doing aggessive resume\n",
1252 : : mmc_hostname(host), err);
1253 : :
1254 : : return 0;
1255 : : }
1256 : :
1257 : 0 : static int mmc_sd_power_restore(struct mmc_host *host)
1258 : : {
1259 : : int ret;
1260 : :
1261 : 0 : host->card->state &= ~MMC_STATE_HIGHSPEED;
1262 : : mmc_claim_host(host);
1263 : 0 : ret = mmc_sd_init_card(host, host->card->ocr, host->card);
1264 : 0 : mmc_release_host(host);
1265 : :
1266 : 0 : return ret;
1267 : : }
1268 : :
1269 : : static const struct mmc_bus_ops mmc_sd_ops = {
1270 : : .remove = mmc_sd_remove,
1271 : : .detect = mmc_sd_detect,
1272 : : .suspend = NULL,
1273 : : .resume = NULL,
1274 : : .power_restore = mmc_sd_power_restore,
1275 : : .alive = mmc_sd_alive,
1276 : : .shutdown = mmc_sd_suspend,
1277 : : };
1278 : :
1279 : : static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1280 : : .remove = mmc_sd_remove,
1281 : : .detect = mmc_sd_detect,
1282 : : .runtime_suspend = mmc_sd_runtime_suspend,
1283 : : .runtime_resume = mmc_sd_runtime_resume,
1284 : : .suspend = mmc_sd_suspend,
1285 : : .resume = mmc_sd_resume,
1286 : : .power_restore = mmc_sd_power_restore,
1287 : : .alive = mmc_sd_alive,
1288 : : .shutdown = mmc_sd_suspend,
1289 : : };
1290 : :
1291 : 0 : static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1292 : : {
1293 : : const struct mmc_bus_ops *bus_ops;
1294 : :
1295 [ # # ]: 0 : if (!mmc_card_is_removable(host))
1296 : : bus_ops = &mmc_sd_ops_unsafe;
1297 : : else
1298 : : bus_ops = &mmc_sd_ops;
1299 : 0 : mmc_attach_bus(host, bus_ops);
1300 : 0 : }
1301 : :
1302 : : /*
1303 : : * Starting point for SD card init.
1304 : : */
1305 : 0 : int mmc_attach_sd(struct mmc_host *host)
1306 : : {
1307 : : int err;
1308 : : u32 ocr, rocr;
1309 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1310 : : int retries;
1311 : : #endif
1312 : :
1313 [ # # ]: 0 : BUG_ON(!host);
1314 [ # # ]: 0 : WARN_ON(!host->claimed);
1315 : :
1316 : 0 : err = mmc_send_app_op_cond(host, 0, &ocr);
1317 [ # # ]: 0 : if (err)
1318 : : return err;
1319 : :
1320 : 0 : mmc_sd_attach_bus_ops(host);
1321 [ # # ]: 0 : if (host->ocr_avail_sd)
1322 : 0 : host->ocr_avail = host->ocr_avail_sd;
1323 : :
1324 : : /*
1325 : : * We need to get OCR a different way for SPI.
1326 : : */
1327 [ # # ]: 0 : if (mmc_host_is_spi(host)) {
1328 : 0 : mmc_go_idle(host);
1329 : :
1330 : 0 : err = mmc_spi_read_ocr(host, 0, &ocr);
1331 [ # # ]: 0 : if (err)
1332 : : goto err;
1333 : : }
1334 : :
1335 : 0 : rocr = mmc_select_voltage(host, ocr);
1336 : :
1337 : : /*
1338 : : * Can we support the voltage(s) of the card(s)?
1339 : : */
1340 [ # # ]: 0 : if (!rocr) {
1341 : : err = -EINVAL;
1342 : : goto err;
1343 : : }
1344 : :
1345 : : /*
1346 : : * Detect and init the card.
1347 : : */
1348 : : #ifdef CONFIG_MMC_PARANOID_SD_INIT
1349 : : retries = 5;
1350 : : while (retries) {
1351 : : err = mmc_sd_init_card(host, rocr, NULL);
1352 : : if (err) {
1353 : : retries--;
1354 : : continue;
1355 : : }
1356 : : break;
1357 : : }
1358 : :
1359 : : if (!retries) {
1360 : : printk(KERN_ERR "%s: mmc_sd_init_card() failure (err = %d)\n",
1361 : : mmc_hostname(host), err);
1362 : : goto err;
1363 : : }
1364 : : #else
1365 : 0 : err = mmc_sd_init_card(host, rocr, NULL);
1366 [ # # ]: 0 : if (err)
1367 : : goto err;
1368 : : #endif
1369 : :
1370 : 0 : mmc_release_host(host);
1371 : 0 : err = mmc_add_card(host->card);
1372 : : mmc_claim_host(host);
1373 [ # # ]: 0 : if (err)
1374 : : goto remove_card;
1375 : :
1376 : : return 0;
1377 : :
1378 : : remove_card:
1379 : 0 : mmc_release_host(host);
1380 : 0 : mmc_remove_card(host->card);
1381 : 0 : host->card = NULL;
1382 : : mmc_claim_host(host);
1383 : : err:
1384 : 0 : mmc_detach_bus(host);
1385 : :
1386 : 0 : pr_err("%s: error %d whilst initialising SD card\n",
1387 : : mmc_hostname(host), err);
1388 : :
1389 : 0 : return err;
1390 : : }
1391 : :
|
