2 * linux/drivers/mmc/sdio.c
4 * Copyright 2006-2007 Pierre Ossman
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.
12 #include <linux/err.h>
14 #include <linux/mmc/host.h>
15 #include <linux/mmc/card.h>
16 #include <linux/mmc/sdio.h>
17 #include <linux/mmc/sdio_func.h>
27 static int sdio_read_fbr(struct sdio_func
*func
)
32 ret
= mmc_io_rw_direct(func
->card
, 0, 0,
33 SDIO_FBR_BASE(func
->num
) + SDIO_FBR_STD_IF
, 0, &data
);
40 ret
= mmc_io_rw_direct(func
->card
, 0, 0,
41 SDIO_FBR_BASE(func
->num
) + SDIO_FBR_STD_IF_EXT
, 0, &data
);
52 static int sdio_init_func(struct mmc_card
*card
, unsigned int fn
)
55 struct sdio_func
*func
;
57 BUG_ON(fn
> SDIO_MAX_FUNCS
);
59 func
= sdio_alloc_func(card
);
65 ret
= sdio_read_fbr(func
);
69 ret
= sdio_read_func_cis(func
);
73 card
->sdio_func
[fn
- 1] = func
;
79 * It is okay to remove the function here even though we hold
80 * the host lock as we haven't registered the device yet.
82 sdio_remove_func(func
);
86 static int sdio_read_cccr(struct mmc_card
*card
)
92 memset(&card
->cccr
, 0, sizeof(struct sdio_cccr
));
94 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_CCCR
, 0, &data
);
98 cccr_vsn
= data
& 0x0f;
100 if (cccr_vsn
> SDIO_CCCR_REV_1_20
) {
101 printk(KERN_ERR
"%s: unrecognised CCCR structure version %d\n",
102 mmc_hostname(card
->host
), cccr_vsn
);
106 card
->cccr
.sdio_vsn
= (data
& 0xf0) >> 4;
108 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_CAPS
, 0, &data
);
112 if (data
& SDIO_CCCR_CAP_SMB
)
113 card
->cccr
.multi_block
= 1;
114 if (data
& SDIO_CCCR_CAP_LSC
)
115 card
->cccr
.low_speed
= 1;
116 if (data
& SDIO_CCCR_CAP_4BLS
)
117 card
->cccr
.wide_bus
= 1;
119 if (cccr_vsn
>= SDIO_CCCR_REV_1_10
) {
120 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_POWER
, 0, &data
);
124 if (data
& SDIO_POWER_SMPC
)
125 card
->cccr
.high_power
= 1;
128 if (cccr_vsn
>= SDIO_CCCR_REV_1_20
) {
129 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_SPEED
, 0, &data
);
133 if (data
& SDIO_SPEED_SHS
)
134 card
->cccr
.high_speed
= 1;
141 static int sdio_enable_wide(struct mmc_card
*card
)
146 if (!(card
->host
->caps
& MMC_CAP_4_BIT_DATA
))
149 if (card
->cccr
.low_speed
&& !card
->cccr
.wide_bus
)
152 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_IF
, 0, &ctrl
);
156 ctrl
|= SDIO_BUS_WIDTH_4BIT
;
158 ret
= mmc_io_rw_direct(card
, 1, 0, SDIO_CCCR_IF
, ctrl
, NULL
);
162 mmc_set_bus_width(card
->host
, MMC_BUS_WIDTH_4
);
168 * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
169 * of the card. This may be required on certain setups of boards,
170 * controllers and embedded sdio device which do not need the card's
171 * pull-up. As a result, card detection is disabled and power is saved.
173 static int sdio_disable_cd(struct mmc_card
*card
)
178 if (!card
->cccr
.disable_cd
)
181 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_IF
, 0, &ctrl
);
185 ctrl
|= SDIO_BUS_CD_DISABLE
;
187 return mmc_io_rw_direct(card
, 1, 0, SDIO_CCCR_IF
, ctrl
, NULL
);
191 * Test if the card supports high-speed mode and, if so, switch to it.
193 static int sdio_enable_hs(struct mmc_card
*card
)
198 if (!(card
->host
->caps
& MMC_CAP_SD_HIGHSPEED
))
201 if (!card
->cccr
.high_speed
)
204 ret
= mmc_io_rw_direct(card
, 0, 0, SDIO_CCCR_SPEED
, 0, &speed
);
208 speed
|= SDIO_SPEED_EHS
;
210 ret
= mmc_io_rw_direct(card
, 1, 0, SDIO_CCCR_SPEED
, speed
, NULL
);
214 mmc_card_set_highspeed(card
);
215 mmc_set_timing(card
->host
, MMC_TIMING_SD_HS
);
221 * Handle the detection and initialisation of a card.
223 * In the case of a resume, "oldcard" will contain the card
224 * we're trying to reinitialise.
226 static int mmc_sdio_init_card(struct mmc_host
*host
, u32 ocr
,
227 struct mmc_card
*oldcard
, int powered_resume
)
229 struct mmc_card
*card
;
233 WARN_ON(!host
->claimed
);
236 * Inform the card of the voltage
238 if (!powered_resume
) {
239 err
= mmc_send_io_op_cond(host
, host
->ocr
, &ocr
);
245 * For SPI, enable CRC as appropriate.
247 if (mmc_host_is_spi(host
)) {
248 err
= mmc_spi_set_crc(host
, use_spi_crc
);
254 * Allocate card structure.
256 card
= mmc_alloc_card(host
, NULL
);
262 card
->type
= MMC_TYPE_SDIO
;
265 * For native busses: set card RCA and quit open drain mode.
267 if (!powered_resume
&& !mmc_host_is_spi(host
)) {
268 err
= mmc_send_relative_addr(host
, &card
->rca
);
272 mmc_set_bus_mode(host
, MMC_BUSMODE_PUSHPULL
);
276 * Select card, as all following commands rely on that.
278 if (!powered_resume
&& !mmc_host_is_spi(host
)) {
279 err
= mmc_select_card(card
);
285 * Read the common registers.
287 err
= sdio_read_cccr(card
);
292 * Read the common CIS tuples.
294 err
= sdio_read_common_cis(card
);
299 int same
= (card
->cis
.vendor
== oldcard
->cis
.vendor
&&
300 card
->cis
.device
== oldcard
->cis
.device
);
301 mmc_remove_card(card
);
311 * Switch to high-speed (if supported).
313 err
= sdio_enable_hs(card
);
318 * Change to the card's maximum speed.
320 if (mmc_card_highspeed(card
)) {
322 * The SDIO specification doesn't mention how
323 * the CIS transfer speed register relates to
324 * high-speed, but it seems that 50 MHz is
327 mmc_set_clock(host
, 50000000);
329 mmc_set_clock(host
, card
->cis
.max_dtr
);
333 * Switch to wider bus (if supported).
335 err
= sdio_enable_wide(card
);
345 mmc_remove_card(card
);
352 * Host is being removed. Free up the current card.
354 static void mmc_sdio_remove(struct mmc_host
*host
)
361 for (i
= 0;i
< host
->card
->sdio_funcs
;i
++) {
362 if (host
->card
->sdio_func
[i
]) {
363 sdio_remove_func(host
->card
->sdio_func
[i
]);
364 host
->card
->sdio_func
[i
] = NULL
;
368 mmc_remove_card(host
->card
);
373 * Card detection callback from host.
375 static void mmc_sdio_detect(struct mmc_host
*host
)
382 mmc_claim_host(host
);
385 * Just check if our card has been removed.
387 err
= mmc_select_card(host
->card
);
389 mmc_release_host(host
);
392 mmc_sdio_remove(host
);
394 mmc_claim_host(host
);
395 mmc_detach_bus(host
);
396 mmc_release_host(host
);
401 * SDIO suspend. We need to suspend all functions separately.
402 * Therefore all registered functions must have drivers with suspend
403 * and resume methods. Failing that we simply remove the whole card.
405 static int mmc_sdio_suspend(struct mmc_host
*host
)
409 for (i
= 0; i
< host
->card
->sdio_funcs
; i
++) {
410 struct sdio_func
*func
= host
->card
->sdio_func
[i
];
411 if (func
&& sdio_func_present(func
) && func
->dev
.driver
) {
412 const struct dev_pm_ops
*pmops
= func
->dev
.driver
->pm
;
413 if (!pmops
|| !pmops
->suspend
|| !pmops
->resume
) {
414 /* force removal of entire card in that case */
417 err
= pmops
->suspend(&func
->dev
);
422 while (err
&& --i
>= 0) {
423 struct sdio_func
*func
= host
->card
->sdio_func
[i
];
424 if (func
&& sdio_func_present(func
) && func
->dev
.driver
) {
425 const struct dev_pm_ops
*pmops
= func
->dev
.driver
->pm
;
426 pmops
->resume(&func
->dev
);
433 static int mmc_sdio_resume(struct mmc_host
*host
)
440 /* Basic card reinitialization. */
441 mmc_claim_host(host
);
442 err
= mmc_sdio_init_card(host
, host
->ocr
, host
->card
,
443 (host
->pm_flags
& MMC_PM_KEEP_POWER
));
444 if (!err
&& host
->sdio_irqs
)
445 mmc_signal_sdio_irq(host
);
446 mmc_release_host(host
);
449 * If the card looked to be the same as before suspending, then
450 * we proceed to resume all card functions. If one of them returns
451 * an error then we simply return that error to the core and the
452 * card will be redetected as new. It is the responsibility of
453 * the function driver to perform further tests with the extra
454 * knowledge it has of the card to confirm the card is indeed the
455 * same as before suspending (same MAC address for network cards,
456 * etc.) and return an error otherwise.
458 for (i
= 0; !err
&& i
< host
->card
->sdio_funcs
; i
++) {
459 struct sdio_func
*func
= host
->card
->sdio_func
[i
];
460 if (func
&& sdio_func_present(func
) && func
->dev
.driver
) {
461 const struct dev_pm_ops
*pmops
= func
->dev
.driver
->pm
;
462 err
= pmops
->resume(&func
->dev
);
469 static const struct mmc_bus_ops mmc_sdio_ops
= {
470 .remove
= mmc_sdio_remove
,
471 .detect
= mmc_sdio_detect
,
472 .suspend
= mmc_sdio_suspend
,
473 .resume
= mmc_sdio_resume
,
478 * Starting point for SDIO card init.
480 int mmc_attach_sdio(struct mmc_host
*host
, u32 ocr
)
484 struct mmc_card
*card
;
487 WARN_ON(!host
->claimed
);
489 mmc_attach_bus(host
, &mmc_sdio_ops
);
492 * Sanity check the voltages that the card claims to
496 printk(KERN_WARNING
"%s: card claims to support voltages "
497 "below the defined range. These will be ignored.\n",
502 host
->ocr
= mmc_select_voltage(host
, ocr
);
505 * Can we support the voltage(s) of the card(s)?
513 * Detect and init the card.
515 err
= mmc_sdio_init_card(host
, host
->ocr
, NULL
, 0);
521 * The number of functions on the card is encoded inside
524 funcs
= (ocr
& 0x70000000) >> 28;
525 card
->sdio_funcs
= 0;
528 * If needed, disconnect card detection pull-up resistor.
530 err
= sdio_disable_cd(card
);
535 * Initialize (but don't add) all present functions.
537 for (i
= 0; i
< funcs
; i
++, card
->sdio_funcs
++) {
538 err
= sdio_init_func(host
->card
, i
+ 1);
543 mmc_release_host(host
);
546 * First add the card to the driver model...
548 err
= mmc_add_card(host
->card
);
553 * ...then the SDIO functions.
555 for (i
= 0;i
< funcs
;i
++) {
556 err
= sdio_add_func(host
->card
->sdio_func
[i
]);
565 /* Remove without lock if the device has been added. */
566 mmc_sdio_remove(host
);
567 mmc_claim_host(host
);
569 /* And with lock if it hasn't been added. */
571 mmc_sdio_remove(host
);
573 mmc_detach_bus(host
);
574 mmc_release_host(host
);
576 printk(KERN_ERR
"%s: error %d whilst initialising SDIO card\n",
577 mmc_hostname(host
), err
);
This page took 0.064072 seconds and 5 git commands to generate.