1 /*
2 * linux/drivers/mmc/sdio.c
3 *
4 * Copyright 2006-2007 Pierre Ossman
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 */
11
12 #include <linux/err.h>
13 #include <linux/module.h>
14 #include <linux/pm_runtime.h>
15
16 #include <linux/mmc/host.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/mmc.h>
19 #include <linux/mmc/sdio.h>
20 #include <linux/mmc/sdio_func.h>
21 #include <linux/mmc/sdio_ids.h>
22
23 #include "core.h"
24 #include "bus.h"
25 #include "sd.h"
26 #include "sdio_bus.h"
27 #include "mmc_ops.h"
28 #include "sd_ops.h"
29 #include "sdio_ops.h"
30 #include "sdio_cis.h"
31
32 #ifdef CONFIG_MMC_EMBEDDED_SDIO
33 #include <linux/mmc/sdio_ids.h>
34 #endif
35
sdio_read_fbr(struct sdio_func * func)36 static int sdio_read_fbr(struct sdio_func *func)
37 {
38 int ret;
39 unsigned char data;
40
41 if (mmc_card_nonstd_func_interface(func->card)) {
42 func->class = SDIO_CLASS_NONE;
43 return 0;
44 }
45
46 ret = mmc_io_rw_direct(func->card, 0, 0,
47 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
48 if (ret)
49 goto out;
50
51 data &= 0x0f;
52
53 if (data == 0x0f) {
54 ret = mmc_io_rw_direct(func->card, 0, 0,
55 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
56 if (ret)
57 goto out;
58 }
59
60 func->class = data;
61
62 out:
63 return ret;
64 }
65
sdio_init_func(struct mmc_card * card,unsigned int fn)66 static int sdio_init_func(struct mmc_card *card, unsigned int fn)
67 {
68 int ret;
69 struct sdio_func *func;
70
71 BUG_ON(fn > SDIO_MAX_FUNCS);
72
73 func = sdio_alloc_func(card);
74 if (IS_ERR(func))
75 return PTR_ERR(func);
76
77 func->num = fn;
78
79 if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) {
80 ret = sdio_read_fbr(func);
81 if (ret)
82 goto fail;
83
84 ret = sdio_read_func_cis(func);
85 if (ret)
86 goto fail;
87 } else {
88 func->vendor = func->card->cis.vendor;
89 func->device = func->card->cis.device;
90 func->max_blksize = func->card->cis.blksize;
91 }
92
93 card->sdio_func[fn - 1] = func;
94
95 return 0;
96
97 fail:
98 /*
99 * It is okay to remove the function here even though we hold
100 * the host lock as we haven't registered the device yet.
101 */
102 sdio_remove_func(func);
103 return ret;
104 }
105
sdio_read_cccr(struct mmc_card * card,u32 ocr)106 static int sdio_read_cccr(struct mmc_card *card, u32 ocr)
107 {
108 int ret;
109 int cccr_vsn;
110 int uhs = ocr & R4_18V_PRESENT;
111 unsigned char data;
112 unsigned char speed;
113
114 memset(&card->cccr, 0, sizeof(struct sdio_cccr));
115
116 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
117 if (ret)
118 goto out;
119
120 cccr_vsn = data & 0x0f;
121
122 if (cccr_vsn > SDIO_CCCR_REV_3_00) {
123 pr_err("%s: unrecognised CCCR structure version %d\n",
124 mmc_hostname(card->host), cccr_vsn);
125 return -EINVAL;
126 }
127
128 card->cccr.sdio_vsn = (data & 0xf0) >> 4;
129
130 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
131 if (ret)
132 goto out;
133
134 if (data & SDIO_CCCR_CAP_SMB)
135 card->cccr.multi_block = 1;
136 if (data & SDIO_CCCR_CAP_LSC)
137 card->cccr.low_speed = 1;
138 if (data & SDIO_CCCR_CAP_4BLS)
139 card->cccr.wide_bus = 1;
140
141 if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
142 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
143 if (ret)
144 goto out;
145
146 if (data & SDIO_POWER_SMPC)
147 card->cccr.high_power = 1;
148 }
149
150 if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
151 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
152 if (ret)
153 goto out;
154
155 card->scr.sda_spec3 = 0;
156 card->sw_caps.sd3_bus_mode = 0;
157 card->sw_caps.sd3_drv_type = 0;
158 if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) {
159 card->scr.sda_spec3 = 1;
160 ret = mmc_io_rw_direct(card, 0, 0,
161 SDIO_CCCR_UHS, 0, &data);
162 if (ret)
163 goto out;
164
165 if (mmc_host_uhs(card->host)) {
166 if (data & SDIO_UHS_DDR50)
167 card->sw_caps.sd3_bus_mode
168 |= SD_MODE_UHS_DDR50;
169
170 if (data & SDIO_UHS_SDR50)
171 card->sw_caps.sd3_bus_mode
172 |= SD_MODE_UHS_SDR50;
173
174 if (data & SDIO_UHS_SDR104)
175 card->sw_caps.sd3_bus_mode
176 |= SD_MODE_UHS_SDR104;
177 }
178
179 ret = mmc_io_rw_direct(card, 0, 0,
180 SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
181 if (ret)
182 goto out;
183
184 if (data & SDIO_DRIVE_SDTA)
185 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
186 if (data & SDIO_DRIVE_SDTC)
187 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
188 if (data & SDIO_DRIVE_SDTD)
189 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
190 }
191
192 /* if no uhs mode ensure we check for high speed */
193 if (!card->sw_caps.sd3_bus_mode) {
194 if (speed & SDIO_SPEED_SHS) {
195 card->cccr.high_speed = 1;
196 card->sw_caps.hs_max_dtr = 50000000;
197 } else {
198 card->cccr.high_speed = 0;
199 card->sw_caps.hs_max_dtr = 25000000;
200 }
201 }
202 }
203
204 out:
205 return ret;
206 }
207
sdio_enable_wide(struct mmc_card * card)208 static int sdio_enable_wide(struct mmc_card *card)
209 {
210 int ret;
211 u8 ctrl;
212
213 if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
214 return 0;
215
216 if (card->cccr.low_speed && !card->cccr.wide_bus)
217 return 0;
218
219 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
220 if (ret)
221 return ret;
222
223 if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED)
224 pr_warning("%s: SDIO_CCCR_IF is invalid: 0x%02x\n",
225 mmc_hostname(card->host), ctrl);
226
227 /* set as 4-bit bus width */
228 ctrl &= ~SDIO_BUS_WIDTH_MASK;
229 ctrl |= SDIO_BUS_WIDTH_4BIT;
230
231 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
232 if (ret)
233 return ret;
234
235 return 1;
236 }
237
238 /*
239 * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
240 * of the card. This may be required on certain setups of boards,
241 * controllers and embedded sdio device which do not need the card's
242 * pull-up. As a result, card detection is disabled and power is saved.
243 */
sdio_disable_cd(struct mmc_card * card)244 static int sdio_disable_cd(struct mmc_card *card)
245 {
246 int ret;
247 u8 ctrl;
248
249 if (!mmc_card_disable_cd(card))
250 return 0;
251
252 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
253 if (ret)
254 return ret;
255
256 ctrl |= SDIO_BUS_CD_DISABLE;
257
258 return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
259 }
260
261 /*
262 * Devices that remain active during a system suspend are
263 * put back into 1-bit mode.
264 */
sdio_disable_wide(struct mmc_card * card)265 static int sdio_disable_wide(struct mmc_card *card)
266 {
267 int ret;
268 u8 ctrl;
269
270 if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
271 return 0;
272
273 if (card->cccr.low_speed && !card->cccr.wide_bus)
274 return 0;
275
276 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
277 if (ret)
278 return ret;
279
280 if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
281 return 0;
282
283 ctrl &= ~SDIO_BUS_WIDTH_4BIT;
284 ctrl |= SDIO_BUS_ASYNC_INT;
285
286 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
287 if (ret)
288 return ret;
289
290 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
291
292 return 0;
293 }
294
295
sdio_enable_4bit_bus(struct mmc_card * card)296 static int sdio_enable_4bit_bus(struct mmc_card *card)
297 {
298 int err;
299
300 if (card->type == MMC_TYPE_SDIO)
301 return sdio_enable_wide(card);
302
303 if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
304 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
305 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
306 if (err)
307 return err;
308 } else
309 return 0;
310
311 err = sdio_enable_wide(card);
312 if (err <= 0)
313 mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);
314
315 return err;
316 }
317
318
319 /*
320 * Test if the card supports high-speed mode and, if so, switch to it.
321 */
mmc_sdio_switch_hs(struct mmc_card * card,int enable)322 static int mmc_sdio_switch_hs(struct mmc_card *card, int enable)
323 {
324 int ret;
325 u8 speed;
326
327 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
328 return 0;
329
330 if (!card->cccr.high_speed)
331 return 0;
332
333 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
334 if (ret)
335 return ret;
336
337 if (enable)
338 speed |= SDIO_SPEED_EHS;
339 else
340 speed &= ~SDIO_SPEED_EHS;
341
342 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
343 if (ret)
344 return ret;
345
346 return 1;
347 }
348
349 /*
350 * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported.
351 */
sdio_enable_hs(struct mmc_card * card)352 static int sdio_enable_hs(struct mmc_card *card)
353 {
354 int ret;
355
356 ret = mmc_sdio_switch_hs(card, true);
357 if (ret <= 0 || card->type == MMC_TYPE_SDIO)
358 return ret;
359
360 ret = mmc_sd_switch_hs(card);
361 if (ret <= 0)
362 mmc_sdio_switch_hs(card, false);
363
364 return ret;
365 }
366
mmc_sdio_get_max_clock(struct mmc_card * card)367 static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
368 {
369 unsigned max_dtr;
370
371 if (mmc_card_highspeed(card)) {
372 /*
373 * The SDIO specification doesn't mention how
374 * the CIS transfer speed register relates to
375 * high-speed, but it seems that 50 MHz is
376 * mandatory.
377 */
378 max_dtr = 50000000;
379 } else {
380 max_dtr = card->cis.max_dtr;
381 }
382
383 if (card->type == MMC_TYPE_SD_COMBO)
384 max_dtr = min(max_dtr, mmc_sd_get_max_clock(card));
385
386 return max_dtr;
387 }
388
host_drive_to_sdio_drive(int host_strength)389 static unsigned char host_drive_to_sdio_drive(int host_strength)
390 {
391 switch (host_strength) {
392 case MMC_SET_DRIVER_TYPE_A:
393 return SDIO_DTSx_SET_TYPE_A;
394 case MMC_SET_DRIVER_TYPE_B:
395 return SDIO_DTSx_SET_TYPE_B;
396 case MMC_SET_DRIVER_TYPE_C:
397 return SDIO_DTSx_SET_TYPE_C;
398 case MMC_SET_DRIVER_TYPE_D:
399 return SDIO_DTSx_SET_TYPE_D;
400 default:
401 return SDIO_DTSx_SET_TYPE_B;
402 }
403 }
404
sdio_select_driver_type(struct mmc_card * card)405 static void sdio_select_driver_type(struct mmc_card *card)
406 {
407 int host_drv_type = SD_DRIVER_TYPE_B;
408 int card_drv_type = SD_DRIVER_TYPE_B;
409 int drive_strength;
410 unsigned char card_strength;
411 int err;
412
413 /*
414 * If the host doesn't support any of the Driver Types A,C or D,
415 * or there is no board specific handler then default Driver
416 * Type B is used.
417 */
418 if (!(card->host->caps &
419 (MMC_CAP_DRIVER_TYPE_A |
420 MMC_CAP_DRIVER_TYPE_C |
421 MMC_CAP_DRIVER_TYPE_D)))
422 return;
423
424 if (!card->host->ops->select_drive_strength)
425 return;
426
427 if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
428 host_drv_type |= SD_DRIVER_TYPE_A;
429
430 if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
431 host_drv_type |= SD_DRIVER_TYPE_C;
432
433 if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
434 host_drv_type |= SD_DRIVER_TYPE_D;
435
436 if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
437 card_drv_type |= SD_DRIVER_TYPE_A;
438
439 if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
440 card_drv_type |= SD_DRIVER_TYPE_C;
441
442 if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
443 card_drv_type |= SD_DRIVER_TYPE_D;
444
445 /*
446 * The drive strength that the hardware can support
447 * depends on the board design. Pass the appropriate
448 * information and let the hardware specific code
449 * return what is possible given the options
450 */
451 drive_strength = card->host->ops->select_drive_strength(
452 card->sw_caps.uhs_max_dtr,
453 host_drv_type, card_drv_type);
454
455 /* if error just use default for drive strength B */
456 err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
457 &card_strength);
458 if (err)
459 return;
460
461 card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
462 card_strength |= host_drive_to_sdio_drive(drive_strength);
463
464 err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
465 card_strength, NULL);
466
467 /* if error default to drive strength B */
468 if (!err)
469 mmc_set_driver_type(card->host, drive_strength);
470 }
471
472
sdio_set_bus_speed_mode(struct mmc_card * card)473 static int sdio_set_bus_speed_mode(struct mmc_card *card)
474 {
475 unsigned int bus_speed, timing;
476 int err;
477 unsigned char speed;
478
479 /*
480 * If the host doesn't support any of the UHS-I modes, fallback on
481 * default speed.
482 */
483 if (!mmc_host_uhs(card->host))
484 return 0;
485
486 bus_speed = SDIO_SPEED_SDR12;
487 timing = MMC_TIMING_UHS_SDR12;
488 if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
489 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
490 bus_speed = SDIO_SPEED_SDR104;
491 timing = MMC_TIMING_UHS_SDR104;
492 card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
493 card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
494 } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
495 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
496 bus_speed = SDIO_SPEED_DDR50;
497 timing = MMC_TIMING_UHS_DDR50;
498 card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
499 card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
500 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
501 MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
502 SD_MODE_UHS_SDR50)) {
503 bus_speed = SDIO_SPEED_SDR50;
504 timing = MMC_TIMING_UHS_SDR50;
505 card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
506 card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
507 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
508 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
509 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
510 bus_speed = SDIO_SPEED_SDR25;
511 timing = MMC_TIMING_UHS_SDR25;
512 card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
513 card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
514 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
515 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
516 MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
517 SD_MODE_UHS_SDR12)) {
518 bus_speed = SDIO_SPEED_SDR12;
519 timing = MMC_TIMING_UHS_SDR12;
520 card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
521 card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
522 }
523
524 err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
525 if (err)
526 return err;
527
528 speed &= ~SDIO_SPEED_BSS_MASK;
529 speed |= bus_speed;
530 err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
531 if (err)
532 return err;
533
534 if (bus_speed) {
535 mmc_set_timing(card->host, timing);
536 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
537 }
538
539 return 0;
540 }
541
542 /*
543 * UHS-I specific initialization procedure
544 */
mmc_sdio_init_uhs_card(struct mmc_card * card)545 static int mmc_sdio_init_uhs_card(struct mmc_card *card)
546 {
547 int err;
548
549 if (!card->scr.sda_spec3)
550 return 0;
551
552 /*
553 * Switch to wider bus (if supported).
554 */
555 if (card->host->caps & MMC_CAP_4_BIT_DATA) {
556 err = sdio_enable_4bit_bus(card);
557 if (err > 0) {
558 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
559 err = 0;
560 }
561 }
562
563 /* Set the driver strength for the card */
564 sdio_select_driver_type(card);
565
566 /* Set bus speed mode of the card */
567 err = sdio_set_bus_speed_mode(card);
568 if (err)
569 goto out;
570
571 /* Initialize and start re-tuning timer */
572 if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
573 err = card->host->ops->execute_tuning(card->host,
574 MMC_SEND_TUNING_BLOCK);
575
576 out:
577
578 return err;
579 }
580
581 /*
582 * Handle the detection and initialisation of a card.
583 *
584 * In the case of a resume, "oldcard" will contain the card
585 * we're trying to reinitialise.
586 */
mmc_sdio_init_card(struct mmc_host * host,u32 ocr,struct mmc_card * oldcard,int powered_resume)587 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
588 struct mmc_card *oldcard, int powered_resume)
589 {
590 struct mmc_card *card;
591 int err;
592 int retries = 10;
593
594 BUG_ON(!host);
595 WARN_ON(!host->claimed);
596
597 try_again:
598 if (!retries) {
599 pr_warning("%s: Skipping voltage switch\n",
600 mmc_hostname(host));
601 ocr &= ~R4_18V_PRESENT;
602 host->ocr &= ~R4_18V_PRESENT;
603 }
604
605 /*
606 * Inform the card of the voltage
607 */
608 if (!powered_resume) {
609 err = mmc_send_io_op_cond(host, host->ocr, &ocr);
610 if (err)
611 goto err;
612 }
613
614 /*
615 * For SPI, enable CRC as appropriate.
616 */
617 if (mmc_host_is_spi(host)) {
618 err = mmc_spi_set_crc(host, use_spi_crc);
619 if (err)
620 goto err;
621 }
622
623 /*
624 * Allocate card structure.
625 */
626 card = mmc_alloc_card(host, NULL);
627 if (IS_ERR(card)) {
628 err = PTR_ERR(card);
629 goto err;
630 }
631
632 if ((ocr & R4_MEMORY_PRESENT) &&
633 mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid, NULL) == 0) {
634 card->type = MMC_TYPE_SD_COMBO;
635
636 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
637 memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
638 mmc_remove_card(card);
639 return -ENOENT;
640 }
641 } else {
642 card->type = MMC_TYPE_SDIO;
643
644 if (oldcard && oldcard->type != MMC_TYPE_SDIO) {
645 mmc_remove_card(card);
646 return -ENOENT;
647 }
648 }
649
650 /*
651 * Call the optional HC's init_card function to handle quirks.
652 */
653 if (host->ops->init_card)
654 host->ops->init_card(host, card);
655
656 /*
657 * If the host and card support UHS-I mode request the card
658 * to switch to 1.8V signaling level. No 1.8v signalling if
659 * UHS mode is not enabled to maintain compatibility and some
660 * systems that claim 1.8v signalling in fact do not support
661 * it.
662 */
663 if (!powered_resume && (ocr & R4_18V_PRESENT) && mmc_host_uhs(host)) {
664 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
665 if (err == -EAGAIN) {
666 sdio_reset(host);
667 mmc_go_idle(host);
668 mmc_send_if_cond(host, host->ocr_avail);
669 mmc_remove_card(card);
670 retries--;
671 goto try_again;
672 } else if (err) {
673 ocr &= ~R4_18V_PRESENT;
674 host->ocr &= ~R4_18V_PRESENT;
675 }
676 err = 0;
677 } else {
678 ocr &= ~R4_18V_PRESENT;
679 host->ocr &= ~R4_18V_PRESENT;
680 }
681
682 /*
683 * For native busses: set card RCA and quit open drain mode.
684 */
685 if (!powered_resume && !mmc_host_is_spi(host)) {
686 err = mmc_send_relative_addr(host, &card->rca);
687 if (err)
688 goto remove;
689
690 /*
691 * Update oldcard with the new RCA received from the SDIO
692 * device -- we're doing this so that it's updated in the
693 * "card" struct when oldcard overwrites that later.
694 */
695 if (oldcard)
696 oldcard->rca = card->rca;
697 }
698
699 /*
700 * Read CSD, before selecting the card
701 */
702 if (!oldcard && card->type == MMC_TYPE_SD_COMBO) {
703 err = mmc_sd_get_csd(host, card);
704 if (err)
705 return err;
706
707 mmc_decode_cid(card);
708 }
709
710 /*
711 * Select card, as all following commands rely on that.
712 */
713 if (!powered_resume && !mmc_host_is_spi(host)) {
714 err = mmc_select_card(card);
715 if (err)
716 goto remove;
717 }
718
719 if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
720 /*
721 * This is non-standard SDIO device, meaning it doesn't
722 * have any CIA (Common I/O area) registers present.
723 * It's host's responsibility to fill cccr and cis
724 * structures in init_card().
725 */
726 mmc_set_clock(host, card->cis.max_dtr);
727
728 if (card->cccr.high_speed) {
729 mmc_card_set_highspeed(card);
730 mmc_set_timing(card->host, MMC_TIMING_SD_HS);
731 }
732
733 goto finish;
734 }
735
736 #ifdef CONFIG_MMC_EMBEDDED_SDIO
737 if (host->embedded_sdio_data.cccr)
738 memcpy(&card->cccr, host->embedded_sdio_data.cccr, sizeof(struct sdio_cccr));
739 else {
740 #endif
741 /*
742 * Read the common registers.
743 */
744 err = sdio_read_cccr(card, ocr);
745 if (err)
746 goto remove;
747 #ifdef CONFIG_MMC_EMBEDDED_SDIO
748 }
749 #endif
750
751 #ifdef CONFIG_MMC_EMBEDDED_SDIO
752 if (host->embedded_sdio_data.cis)
753 memcpy(&card->cis, host->embedded_sdio_data.cis, sizeof(struct sdio_cis));
754 else {
755 #endif
756 /*
757 * Read the common CIS tuples.
758 */
759 err = sdio_read_common_cis(card);
760 if (err)
761 goto remove;
762 #ifdef CONFIG_MMC_EMBEDDED_SDIO
763 }
764 #endif
765
766 if (oldcard) {
767 int same = (card->cis.vendor == oldcard->cis.vendor &&
768 card->cis.device == oldcard->cis.device);
769 mmc_remove_card(card);
770 if (!same)
771 return -ENOENT;
772
773 card = oldcard;
774 }
775 mmc_fixup_device(card, NULL);
776
777 if (card->type == MMC_TYPE_SD_COMBO) {
778 err = mmc_sd_setup_card(host, card, oldcard != NULL);
779 /* handle as SDIO-only card if memory init failed */
780 if (err) {
781 mmc_go_idle(host);
782 if (mmc_host_is_spi(host))
783 /* should not fail, as it worked previously */
784 mmc_spi_set_crc(host, use_spi_crc);
785 card->type = MMC_TYPE_SDIO;
786 } else
787 card->dev.type = &sd_type;
788 }
789
790 /*
791 * If needed, disconnect card detection pull-up resistor.
792 */
793 err = sdio_disable_cd(card);
794 if (err)
795 goto remove;
796
797 /* Initialization sequence for UHS-I cards */
798 /* Only if card supports 1.8v and UHS signaling */
799 if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
800 err = mmc_sdio_init_uhs_card(card);
801 if (err)
802 goto remove;
803
804 /* Card is an ultra-high-speed card */
805 mmc_card_set_uhs(card);
806 } else {
807 /*
808 * Switch to high-speed (if supported).
809 */
810 err = sdio_enable_hs(card);
811 if (err > 0)
812 mmc_sd_go_highspeed(card);
813 else if (err)
814 goto remove;
815
816 /*
817 * Change to the card's maximum speed.
818 */
819 mmc_set_clock(host, mmc_sdio_get_max_clock(card));
820
821 /*
822 * Switch to wider bus (if supported).
823 */
824 err = sdio_enable_4bit_bus(card);
825 if (err > 0)
826 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
827 else if (err)
828 goto remove;
829 }
830 finish:
831 if (!oldcard)
832 host->card = card;
833 return 0;
834
835 remove:
836 if (!oldcard)
837 mmc_remove_card(card);
838
839 err:
840 return err;
841 }
842
843 /*
844 * Host is being removed. Free up the current card.
845 */
mmc_sdio_remove(struct mmc_host * host)846 static void mmc_sdio_remove(struct mmc_host *host)
847 {
848 int i;
849
850 BUG_ON(!host);
851 BUG_ON(!host->card);
852
853 for (i = 0;i < host->card->sdio_funcs;i++) {
854 if (host->card->sdio_func[i]) {
855 sdio_remove_func(host->card->sdio_func[i]);
856 host->card->sdio_func[i] = NULL;
857 }
858 }
859
860 mmc_remove_card(host->card);
861 host->card = NULL;
862 }
863
864 /*
865 * Card detection - card is alive.
866 */
mmc_sdio_alive(struct mmc_host * host)867 static int mmc_sdio_alive(struct mmc_host *host)
868 {
869 return mmc_select_card(host->card);
870 }
871
872 /*
873 * Card detection callback from host.
874 */
mmc_sdio_detect(struct mmc_host * host)875 static void mmc_sdio_detect(struct mmc_host *host)
876 {
877 int err;
878
879 BUG_ON(!host);
880 BUG_ON(!host->card);
881
882 /* Make sure card is powered before detecting it */
883 if (host->caps & MMC_CAP_POWER_OFF_CARD) {
884 err = pm_runtime_get_sync(&host->card->dev);
885 if (err < 0) {
886 pm_runtime_put_noidle(&host->card->dev);
887 goto out;
888 }
889 }
890
891 mmc_claim_host(host);
892
893 /*
894 * Just check if our card has been removed.
895 */
896 err = _mmc_detect_card_removed(host);
897
898 mmc_release_host(host);
899
900 /*
901 * Tell PM core it's OK to power off the card now.
902 *
903 * The _sync variant is used in order to ensure that the card
904 * is left powered off in case an error occurred, and the card
905 * is going to be removed.
906 *
907 * Since there is no specific reason to believe a new user
908 * is about to show up at this point, the _sync variant is
909 * desirable anyway.
910 */
911 if (host->caps & MMC_CAP_POWER_OFF_CARD)
912 pm_runtime_put_sync(&host->card->dev);
913
914 out:
915 if (err) {
916 mmc_sdio_remove(host);
917
918 mmc_claim_host(host);
919 mmc_detach_bus(host);
920 mmc_power_off(host);
921 mmc_release_host(host);
922 }
923 }
924
925 /*
926 * SDIO suspend. We need to suspend all functions separately.
927 * Therefore all registered functions must have drivers with suspend
928 * and resume methods. Failing that we simply remove the whole card.
929 */
mmc_sdio_suspend(struct mmc_host * host)930 static int mmc_sdio_suspend(struct mmc_host *host)
931 {
932 int i, err = 0;
933
934 for (i = 0; i < host->card->sdio_funcs; i++) {
935 struct sdio_func *func = host->card->sdio_func[i];
936 if (func && sdio_func_present(func) && func->dev.driver) {
937 const struct dev_pm_ops *pmops = func->dev.driver->pm;
938 if (!pmops || !pmops->suspend || !pmops->resume) {
939 /* force removal of entire card in that case */
940 err = -ENOSYS;
941 } else
942 err = pmops->suspend(&func->dev);
943 if (err)
944 break;
945 }
946 }
947 while (err && --i >= 0) {
948 struct sdio_func *func = host->card->sdio_func[i];
949 if (func && sdio_func_present(func) && func->dev.driver) {
950 const struct dev_pm_ops *pmops = func->dev.driver->pm;
951 pmops->resume(&func->dev);
952 }
953 }
954
955 if (!err && mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
956 mmc_claim_host(host);
957 sdio_disable_wide(host->card);
958 mmc_release_host(host);
959 }
960
961 return err;
962 }
963
mmc_sdio_resume(struct mmc_host * host)964 static int mmc_sdio_resume(struct mmc_host *host)
965 {
966 int i, err = 0;
967
968 BUG_ON(!host);
969 BUG_ON(!host->card);
970
971 /* Basic card reinitialization. */
972 mmc_claim_host(host);
973
974 /* No need to reinitialize powered-resumed nonremovable cards */
975 if (mmc_card_is_removable(host) || !mmc_card_keep_power(host)) {
976 sdio_reset(host);
977 mmc_go_idle(host);
978 err = mmc_sdio_init_card(host, host->ocr, host->card,
979 mmc_card_keep_power(host));
980 } else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
981 /* We may have switched to 1-bit mode during suspend */
982 err = sdio_enable_4bit_bus(host->card);
983 if (err > 0) {
984 mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
985 err = 0;
986 }
987 }
988
989 if (!err && host->sdio_irqs)
990 wake_up_process(host->sdio_irq_thread);
991 mmc_release_host(host);
992
993 /*
994 * If the card looked to be the same as before suspending, then
995 * we proceed to resume all card functions. If one of them returns
996 * an error then we simply return that error to the core and the
997 * card will be redetected as new. It is the responsibility of
998 * the function driver to perform further tests with the extra
999 * knowledge it has of the card to confirm the card is indeed the
1000 * same as before suspending (same MAC address for network cards,
1001 * etc.) and return an error otherwise.
1002 */
1003 for (i = 0; !err && i < host->card->sdio_funcs; i++) {
1004 struct sdio_func *func = host->card->sdio_func[i];
1005 if (func && sdio_func_present(func) && func->dev.driver) {
1006 const struct dev_pm_ops *pmops = func->dev.driver->pm;
1007 err = pmops->resume(&func->dev);
1008 }
1009 }
1010
1011 return err;
1012 }
1013
mmc_sdio_power_restore(struct mmc_host * host)1014 static int mmc_sdio_power_restore(struct mmc_host *host)
1015 {
1016 int ret;
1017 u32 ocr;
1018
1019 BUG_ON(!host);
1020 BUG_ON(!host->card);
1021
1022 mmc_claim_host(host);
1023
1024 /*
1025 * Reset the card by performing the same steps that are taken by
1026 * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
1027 *
1028 * sdio_reset() is technically not needed. Having just powered up the
1029 * hardware, it should already be in reset state. However, some
1030 * platforms (such as SD8686 on OLPC) do not instantly cut power,
1031 * meaning that a reset is required when restoring power soon after
1032 * powering off. It is harmless in other cases.
1033 *
1034 * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
1035 * is not necessary for non-removable cards. However, it is required
1036 * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
1037 * harmless in other situations.
1038 *
1039 * With these steps taken, mmc_select_voltage() is also required to
1040 * restore the correct voltage setting of the card.
1041 */
1042
1043 sdio_reset(host);
1044 mmc_go_idle(host);
1045 mmc_send_if_cond(host, host->ocr_avail);
1046
1047 ret = mmc_send_io_op_cond(host, 0, &ocr);
1048 if (ret)
1049 goto out;
1050
1051 if (host->ocr_avail_sdio)
1052 host->ocr_avail = host->ocr_avail_sdio;
1053
1054 host->ocr = mmc_select_voltage(host, ocr & ~0x7F);
1055 if (!host->ocr) {
1056 ret = -EINVAL;
1057 goto out;
1058 }
1059
1060 if (mmc_host_uhs(host))
1061 /* to query card if 1.8V signalling is supported */
1062 host->ocr |= R4_18V_PRESENT;
1063
1064 ret = mmc_sdio_init_card(host, host->ocr, host->card,
1065 mmc_card_keep_power(host));
1066 if (!ret && host->sdio_irqs)
1067 mmc_signal_sdio_irq(host);
1068
1069 out:
1070 mmc_release_host(host);
1071
1072 return ret;
1073 }
1074
1075 static const struct mmc_bus_ops mmc_sdio_ops = {
1076 .remove = mmc_sdio_remove,
1077 .detect = mmc_sdio_detect,
1078 .suspend = mmc_sdio_suspend,
1079 .resume = mmc_sdio_resume,
1080 .power_restore = mmc_sdio_power_restore,
1081 .alive = mmc_sdio_alive,
1082 };
1083
1084
1085 /*
1086 * Starting point for SDIO card init.
1087 */
mmc_attach_sdio(struct mmc_host * host)1088 int mmc_attach_sdio(struct mmc_host *host)
1089 {
1090 int err, i, funcs;
1091 u32 ocr;
1092 struct mmc_card *card;
1093
1094 BUG_ON(!host);
1095 WARN_ON(!host->claimed);
1096
1097 err = mmc_send_io_op_cond(host, 0, &ocr);
1098 if (err)
1099 return err;
1100
1101 mmc_attach_bus(host, &mmc_sdio_ops);
1102 if (host->ocr_avail_sdio)
1103 host->ocr_avail = host->ocr_avail_sdio;
1104
1105 /*
1106 * Sanity check the voltages that the card claims to
1107 * support.
1108 */
1109 if (ocr & 0x7F) {
1110 pr_warning("%s: card claims to support voltages "
1111 "below the defined range. These will be ignored.\n",
1112 mmc_hostname(host));
1113 ocr &= ~0x7F;
1114 }
1115
1116 host->ocr = mmc_select_voltage(host, ocr);
1117
1118 /*
1119 * Can we support the voltage(s) of the card(s)?
1120 */
1121 if (!host->ocr) {
1122 err = -EINVAL;
1123 goto err;
1124 }
1125
1126 /*
1127 * Detect and init the card.
1128 */
1129 if (mmc_host_uhs(host))
1130 /* to query card if 1.8V signalling is supported */
1131 host->ocr |= R4_18V_PRESENT;
1132
1133 err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
1134 if (err) {
1135 if (err == -EAGAIN) {
1136 /*
1137 * Retry initialization with S18R set to 0.
1138 */
1139 host->ocr &= ~R4_18V_PRESENT;
1140 err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
1141 }
1142 if (err)
1143 goto err;
1144 }
1145 card = host->card;
1146
1147 /*
1148 * Enable runtime PM only if supported by host+card+board
1149 */
1150 if (host->caps & MMC_CAP_POWER_OFF_CARD) {
1151 /*
1152 * Let runtime PM core know our card is active
1153 */
1154 err = pm_runtime_set_active(&card->dev);
1155 if (err)
1156 goto remove;
1157
1158 /*
1159 * Enable runtime PM for this card
1160 */
1161 pm_runtime_enable(&card->dev);
1162 }
1163
1164 /*
1165 * The number of functions on the card is encoded inside
1166 * the ocr.
1167 */
1168 funcs = (ocr & 0x70000000) >> 28;
1169 card->sdio_funcs = 0;
1170
1171 #ifdef CONFIG_MMC_EMBEDDED_SDIO
1172 if (host->embedded_sdio_data.funcs)
1173 card->sdio_funcs = funcs = host->embedded_sdio_data.num_funcs;
1174 #endif
1175
1176 /*
1177 * Initialize (but don't add) all present functions.
1178 */
1179 for (i = 0; i < funcs; i++, card->sdio_funcs++) {
1180 #ifdef CONFIG_MMC_EMBEDDED_SDIO
1181 if (host->embedded_sdio_data.funcs) {
1182 struct sdio_func *tmp;
1183
1184 tmp = sdio_alloc_func(host->card);
1185 if (IS_ERR(tmp))
1186 goto remove;
1187 tmp->num = (i + 1);
1188 card->sdio_func[i] = tmp;
1189 tmp->class = host->embedded_sdio_data.funcs[i].f_class;
1190 tmp->max_blksize = host->embedded_sdio_data.funcs[i].f_maxblksize;
1191 tmp->vendor = card->cis.vendor;
1192 tmp->device = card->cis.device;
1193 } else {
1194 #endif
1195 err = sdio_init_func(host->card, i + 1);
1196 if (err)
1197 goto remove;
1198 #ifdef CONFIG_MMC_EMBEDDED_SDIO
1199 }
1200 #endif
1201 /*
1202 * Enable Runtime PM for this func (if supported)
1203 */
1204 if (host->caps & MMC_CAP_POWER_OFF_CARD)
1205 pm_runtime_enable(&card->sdio_func[i]->dev);
1206 }
1207
1208 /*
1209 * First add the card to the driver model...
1210 */
1211 mmc_release_host(host);
1212 err = mmc_add_card(host->card);
1213 if (err)
1214 goto remove_added;
1215
1216 /*
1217 * ...then the SDIO functions.
1218 */
1219 for (i = 0;i < funcs;i++) {
1220 err = sdio_add_func(host->card->sdio_func[i]);
1221 if (err)
1222 goto remove_added;
1223 }
1224
1225 mmc_claim_host(host);
1226 return 0;
1227
1228
1229 remove_added:
1230 /* Remove without lock if the device has been added. */
1231 mmc_sdio_remove(host);
1232 mmc_claim_host(host);
1233 remove:
1234 /* And with lock if it hasn't been added. */
1235 mmc_release_host(host);
1236 if (host->card)
1237 mmc_sdio_remove(host);
1238 mmc_claim_host(host);
1239 err:
1240 mmc_detach_bus(host);
1241
1242 pr_err("%s: error %d whilst initialising SDIO card\n",
1243 mmc_hostname(host), err);
1244
1245 return err;
1246 }
1247
sdio_reset_comm(struct mmc_card * card)1248 int sdio_reset_comm(struct mmc_card *card)
1249 {
1250 struct mmc_host *host = card->host;
1251 u32 ocr;
1252 int err;
1253
1254 printk("%s():\n", __func__);
1255 mmc_claim_host(host);
1256
1257 mmc_go_idle(host);
1258
1259 mmc_set_clock(host, host->f_min);
1260
1261 err = mmc_send_io_op_cond(host, 0, &ocr);
1262 if (err)
1263 goto err;
1264
1265 host->ocr = mmc_select_voltage(host, ocr);
1266 if (!host->ocr) {
1267 err = -EINVAL;
1268 goto err;
1269 }
1270
1271 err = mmc_sdio_init_card(host, host->ocr, card, 0);
1272 if (err)
1273 goto err;
1274
1275 mmc_release_host(host);
1276 return 0;
1277 err:
1278 printk("%s: Error resetting SDIO communications (%d)\n",
1279 mmc_hostname(host), err);
1280 mmc_release_host(host);
1281 return err;
1282 }
1283 EXPORT_SYMBOL(sdio_reset_comm);
1284