2 * linux/drivers/mmc/mmc.c
4 * Copyright (C) 2003-2004 Russell King, All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/config.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
14 #include <linux/completion.h>
15 #include <linux/device.h>
16 #include <linux/delay.h>
17 #include <linux/pagemap.h>
18 #include <linux/err.h>
20 #include <linux/mmc/card.h>
21 #include <linux/mmc/host.h>
22 #include <linux/mmc/protocol.h>
26 #ifdef CONFIG_MMC_DEBUG
27 #define DBG(x...) printk(KERN_DEBUG x)
29 #define DBG(x...) do { } while (0)
35 * OCR Bit positions to 10s of Vdd mV.
37 static const unsigned short mmc_ocr_bit_to_vdd
[] = {
38 150, 155, 160, 165, 170, 180, 190, 200,
39 210, 220, 230, 240, 250, 260, 270, 280,
40 290, 300, 310, 320, 330, 340, 350, 360
43 static const unsigned int tran_exp
[] = {
44 10000, 100000, 1000000, 10000000,
48 static const unsigned char tran_mant
[] = {
49 0, 10, 12, 13, 15, 20, 25, 30,
50 35, 40, 45, 50, 55, 60, 70, 80,
53 static const unsigned int tacc_exp
[] = {
54 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
57 static const unsigned int tacc_mant
[] = {
58 0, 10, 12, 13, 15, 20, 25, 30,
59 35, 40, 45, 50, 55, 60, 70, 80,
64 * mmc_request_done - finish processing an MMC command
65 * @host: MMC host which completed command
66 * @mrq: MMC request which completed
68 * MMC drivers should call this function when they have completed
69 * their processing of a command. This should be called before the
70 * data part of the command has completed.
72 void mmc_request_done(struct mmc_host
*host
, struct mmc_request
*mrq
)
74 struct mmc_command
*cmd
= mrq
->cmd
;
75 int err
= mrq
->cmd
->error
;
76 DBG("MMC: req done (%02x): %d: %08x %08x %08x %08x\n", cmd
->opcode
,
77 err
, cmd
->resp
[0], cmd
->resp
[1], cmd
->resp
[2], cmd
->resp
[3]);
79 if (err
&& cmd
->retries
) {
82 host
->ops
->request(host
, mrq
);
83 } else if (mrq
->done
) {
88 EXPORT_SYMBOL(mmc_request_done
);
91 * mmc_start_request - start a command on a host
92 * @host: MMC host to start command on
93 * @mrq: MMC request to start
95 * Queue a command on the specified host. We expect the
96 * caller to be holding the host lock with interrupts disabled.
99 mmc_start_request(struct mmc_host
*host
, struct mmc_request
*mrq
)
101 DBG("MMC: starting cmd %02x arg %08x flags %08x\n",
102 mrq
->cmd
->opcode
, mrq
->cmd
->arg
, mrq
->cmd
->flags
);
104 WARN_ON(host
->card_busy
== NULL
);
109 mrq
->cmd
->data
= mrq
->data
;
110 mrq
->data
->error
= 0;
111 mrq
->data
->mrq
= mrq
;
113 mrq
->data
->stop
= mrq
->stop
;
114 mrq
->stop
->error
= 0;
115 mrq
->stop
->mrq
= mrq
;
118 host
->ops
->request(host
, mrq
);
121 EXPORT_SYMBOL(mmc_start_request
);
123 static void mmc_wait_done(struct mmc_request
*mrq
)
125 complete(mrq
->done_data
);
128 int mmc_wait_for_req(struct mmc_host
*host
, struct mmc_request
*mrq
)
130 DECLARE_COMPLETION(complete
);
132 mrq
->done_data
= &complete
;
133 mrq
->done
= mmc_wait_done
;
135 mmc_start_request(host
, mrq
);
137 wait_for_completion(&complete
);
142 EXPORT_SYMBOL(mmc_wait_for_req
);
145 * mmc_wait_for_cmd - start a command and wait for completion
146 * @host: MMC host to start command
147 * @cmd: MMC command to start
148 * @retries: maximum number of retries
150 * Start a new MMC command for a host, and wait for the command
151 * to complete. Return any error that occurred while the command
152 * was executing. Do not attempt to parse the response.
154 int mmc_wait_for_cmd(struct mmc_host
*host
, struct mmc_command
*cmd
, int retries
)
156 struct mmc_request mrq
;
158 BUG_ON(host
->card_busy
== NULL
);
160 memset(&mrq
, 0, sizeof(struct mmc_request
));
162 memset(cmd
->resp
, 0, sizeof(cmd
->resp
));
163 cmd
->retries
= retries
;
168 mmc_wait_for_req(host
, &mrq
);
173 EXPORT_SYMBOL(mmc_wait_for_cmd
);
178 * __mmc_claim_host - exclusively claim a host
179 * @host: mmc host to claim
180 * @card: mmc card to claim host for
182 * Claim a host for a set of operations. If a valid card
183 * is passed and this wasn't the last card selected, select
184 * the card before returning.
186 * Note: you should use mmc_card_claim_host or mmc_claim_host.
188 int __mmc_claim_host(struct mmc_host
*host
, struct mmc_card
*card
)
190 DECLARE_WAITQUEUE(wait
, current
);
194 add_wait_queue(&host
->wq
, &wait
);
195 spin_lock_irqsave(&host
->lock
, flags
);
197 set_current_state(TASK_UNINTERRUPTIBLE
);
198 if (host
->card_busy
== NULL
)
200 spin_unlock_irqrestore(&host
->lock
, flags
);
202 spin_lock_irqsave(&host
->lock
, flags
);
204 set_current_state(TASK_RUNNING
);
205 host
->card_busy
= card
;
206 spin_unlock_irqrestore(&host
->lock
, flags
);
207 remove_wait_queue(&host
->wq
, &wait
);
209 if (card
!= (void *)-1 && host
->card_selected
!= card
) {
210 struct mmc_command cmd
;
212 host
->card_selected
= card
;
214 cmd
.opcode
= MMC_SELECT_CARD
;
215 cmd
.arg
= card
->rca
<< 16;
216 cmd
.flags
= MMC_RSP_R1
;
218 err
= mmc_wait_for_cmd(host
, &cmd
, CMD_RETRIES
);
224 EXPORT_SYMBOL(__mmc_claim_host
);
227 * mmc_release_host - release a host
228 * @host: mmc host to release
230 * Release a MMC host, allowing others to claim the host
231 * for their operations.
233 void mmc_release_host(struct mmc_host
*host
)
237 BUG_ON(host
->card_busy
== NULL
);
239 spin_lock_irqsave(&host
->lock
, flags
);
240 host
->card_busy
= NULL
;
241 spin_unlock_irqrestore(&host
->lock
, flags
);
246 EXPORT_SYMBOL(mmc_release_host
);
249 * Ensure that no card is selected.
251 static void mmc_deselect_cards(struct mmc_host
*host
)
253 struct mmc_command cmd
;
255 if (host
->card_selected
) {
256 host
->card_selected
= NULL
;
258 cmd
.opcode
= MMC_SELECT_CARD
;
260 cmd
.flags
= MMC_RSP_NONE
;
262 mmc_wait_for_cmd(host
, &cmd
, 0);
267 static inline void mmc_delay(unsigned int ms
)
269 if (ms
< HZ
/ 1000) {
273 msleep_interruptible (ms
);
278 * Mask off any voltages we don't support and select
281 static u32
mmc_select_voltage(struct mmc_host
*host
, u32 ocr
)
285 ocr
&= host
->ocr_avail
;
294 host
->ops
->set_ios(host
, &host
->ios
);
302 #define UNSTUFF_BITS(resp,start,size) \
304 const int __size = size; \
305 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
306 const int __off = 3 - ((start) / 32); \
307 const int __shft = (start) & 31; \
310 __res = resp[__off] >> __shft; \
311 if (__size + __shft > 32) \
312 __res |= resp[__off-1] << ((32 - __shft) % 32); \
317 * Given the decoded CSD structure, decode the raw CID to our CID structure.
319 static void mmc_decode_cid(struct mmc_card
*card
)
321 u32
*resp
= card
->raw_cid
;
323 memset(&card
->cid
, 0, sizeof(struct mmc_cid
));
326 * The selection of the format here is guesswork based upon
327 * information people have sent to date.
329 switch (card
->csd
.mmca_vsn
) {
330 case 0: /* MMC v1.? */
331 case 1: /* MMC v1.4 */
332 card
->cid
.manfid
= UNSTUFF_BITS(resp
, 104, 24);
333 card
->cid
.prod_name
[0] = UNSTUFF_BITS(resp
, 96, 8);
334 card
->cid
.prod_name
[1] = UNSTUFF_BITS(resp
, 88, 8);
335 card
->cid
.prod_name
[2] = UNSTUFF_BITS(resp
, 80, 8);
336 card
->cid
.prod_name
[3] = UNSTUFF_BITS(resp
, 72, 8);
337 card
->cid
.prod_name
[4] = UNSTUFF_BITS(resp
, 64, 8);
338 card
->cid
.prod_name
[5] = UNSTUFF_BITS(resp
, 56, 8);
339 card
->cid
.prod_name
[6] = UNSTUFF_BITS(resp
, 48, 8);
340 card
->cid
.hwrev
= UNSTUFF_BITS(resp
, 44, 4);
341 card
->cid
.fwrev
= UNSTUFF_BITS(resp
, 40, 4);
342 card
->cid
.serial
= UNSTUFF_BITS(resp
, 16, 24);
343 card
->cid
.month
= UNSTUFF_BITS(resp
, 12, 4);
344 card
->cid
.year
= UNSTUFF_BITS(resp
, 8, 4) + 1997;
347 case 2: /* MMC v2.x ? */
348 case 3: /* MMC v3.x ? */
349 card
->cid
.manfid
= UNSTUFF_BITS(resp
, 120, 8);
350 card
->cid
.oemid
= UNSTUFF_BITS(resp
, 104, 16);
351 card
->cid
.prod_name
[0] = UNSTUFF_BITS(resp
, 96, 8);
352 card
->cid
.prod_name
[1] = UNSTUFF_BITS(resp
, 88, 8);
353 card
->cid
.prod_name
[2] = UNSTUFF_BITS(resp
, 80, 8);
354 card
->cid
.prod_name
[3] = UNSTUFF_BITS(resp
, 72, 8);
355 card
->cid
.prod_name
[4] = UNSTUFF_BITS(resp
, 64, 8);
356 card
->cid
.prod_name
[5] = UNSTUFF_BITS(resp
, 56, 8);
357 card
->cid
.serial
= UNSTUFF_BITS(resp
, 16, 32);
358 card
->cid
.month
= UNSTUFF_BITS(resp
, 12, 4);
359 card
->cid
.year
= UNSTUFF_BITS(resp
, 8, 4) + 1997;
363 printk("%s: card has unknown MMCA version %d\n",
364 mmc_hostname(card
->host
), card
->csd
.mmca_vsn
);
365 mmc_card_set_bad(card
);
371 * Given a 128-bit response, decode to our card CSD structure.
373 static void mmc_decode_csd(struct mmc_card
*card
)
375 struct mmc_csd
*csd
= &card
->csd
;
376 unsigned int e
, m
, csd_struct
;
377 u32
*resp
= card
->raw_csd
;
380 * We only understand CSD structure v1.1 and v2.
381 * v2 has extra information in bits 15, 11 and 10.
383 csd_struct
= UNSTUFF_BITS(resp
, 126, 2);
384 if (csd_struct
!= 1 && csd_struct
!= 2) {
385 printk("%s: unrecognised CSD structure version %d\n",
386 mmc_hostname(card
->host
), csd_struct
);
387 mmc_card_set_bad(card
);
391 csd
->mmca_vsn
= UNSTUFF_BITS(resp
, 122, 4);
392 m
= UNSTUFF_BITS(resp
, 115, 4);
393 e
= UNSTUFF_BITS(resp
, 112, 3);
394 csd
->tacc_ns
= (tacc_exp
[e
] * tacc_mant
[m
] + 9) / 10;
395 csd
->tacc_clks
= UNSTUFF_BITS(resp
, 104, 8) * 100;
397 m
= UNSTUFF_BITS(resp
, 99, 4);
398 e
= UNSTUFF_BITS(resp
, 96, 3);
399 csd
->max_dtr
= tran_exp
[e
] * tran_mant
[m
];
400 csd
->cmdclass
= UNSTUFF_BITS(resp
, 84, 12);
402 e
= UNSTUFF_BITS(resp
, 47, 3);
403 m
= UNSTUFF_BITS(resp
, 62, 12);
404 csd
->capacity
= (1 + m
) << (e
+ 2);
406 csd
->read_blkbits
= UNSTUFF_BITS(resp
, 80, 4);
410 * Locate a MMC card on this MMC host given a raw CID.
412 static struct mmc_card
*mmc_find_card(struct mmc_host
*host
, u32
*raw_cid
)
414 struct mmc_card
*card
;
416 list_for_each_entry(card
, &host
->cards
, node
) {
417 if (memcmp(card
->raw_cid
, raw_cid
, sizeof(card
->raw_cid
)) == 0)
424 * Allocate a new MMC card, and assign a unique RCA.
426 static struct mmc_card
*
427 mmc_alloc_card(struct mmc_host
*host
, u32
*raw_cid
, unsigned int *frca
)
429 struct mmc_card
*card
, *c
;
430 unsigned int rca
= *frca
;
432 card
= kmalloc(sizeof(struct mmc_card
), GFP_KERNEL
);
434 return ERR_PTR(-ENOMEM
);
436 mmc_init_card(card
, host
);
437 memcpy(card
->raw_cid
, raw_cid
, sizeof(card
->raw_cid
));
440 list_for_each_entry(c
, &host
->cards
, node
)
454 * Tell attached cards to go to IDLE state
456 static void mmc_idle_cards(struct mmc_host
*host
)
458 struct mmc_command cmd
;
460 host
->ios
.chip_select
= MMC_CS_HIGH
;
461 host
->ops
->set_ios(host
, &host
->ios
);
465 cmd
.opcode
= MMC_GO_IDLE_STATE
;
467 cmd
.flags
= MMC_RSP_NONE
;
469 mmc_wait_for_cmd(host
, &cmd
, 0);
473 host
->ios
.chip_select
= MMC_CS_DONTCARE
;
474 host
->ops
->set_ios(host
, &host
->ios
);
480 * Apply power to the MMC stack.
482 static void mmc_power_up(struct mmc_host
*host
)
484 int bit
= fls(host
->ocr_avail
) - 1;
487 host
->ios
.bus_mode
= MMC_BUSMODE_OPENDRAIN
;
488 host
->ios
.chip_select
= MMC_CS_DONTCARE
;
489 host
->ios
.power_mode
= MMC_POWER_UP
;
490 host
->ops
->set_ios(host
, &host
->ios
);
494 host
->ios
.clock
= host
->f_min
;
495 host
->ios
.power_mode
= MMC_POWER_ON
;
496 host
->ops
->set_ios(host
, &host
->ios
);
501 static void mmc_power_off(struct mmc_host
*host
)
505 host
->ios
.bus_mode
= MMC_BUSMODE_OPENDRAIN
;
506 host
->ios
.chip_select
= MMC_CS_DONTCARE
;
507 host
->ios
.power_mode
= MMC_POWER_OFF
;
508 host
->ops
->set_ios(host
, &host
->ios
);
511 static int mmc_send_op_cond(struct mmc_host
*host
, u32 ocr
, u32
*rocr
)
513 struct mmc_command cmd
;
516 cmd
.opcode
= MMC_SEND_OP_COND
;
518 cmd
.flags
= MMC_RSP_R3
;
520 for (i
= 100; i
; i
--) {
521 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
522 if (err
!= MMC_ERR_NONE
)
525 if (cmd
.resp
[0] & MMC_CARD_BUSY
|| ocr
== 0)
528 err
= MMC_ERR_TIMEOUT
;
540 * Discover cards by requesting their CID. If this command
541 * times out, it is not an error; there are no further cards
542 * to be discovered. Add new cards to the list.
544 * Create a mmc_card entry for each discovered card, assigning
545 * it an RCA, and save the raw CID for decoding later.
547 static void mmc_discover_cards(struct mmc_host
*host
)
549 struct mmc_card
*card
;
550 unsigned int first_rca
= 1, err
;
553 struct mmc_command cmd
;
555 cmd
.opcode
= MMC_ALL_SEND_CID
;
557 cmd
.flags
= MMC_RSP_R2
;
559 err
= mmc_wait_for_cmd(host
, &cmd
, CMD_RETRIES
);
560 if (err
== MMC_ERR_TIMEOUT
) {
564 if (err
!= MMC_ERR_NONE
) {
565 printk(KERN_ERR
"%s: error requesting CID: %d\n",
566 mmc_hostname(host
), err
);
570 card
= mmc_find_card(host
, cmd
.resp
);
572 card
= mmc_alloc_card(host
, cmd
.resp
, &first_rca
);
577 list_add(&card
->node
, &host
->cards
);
580 card
->state
&= ~MMC_STATE_DEAD
;
582 cmd
.opcode
= MMC_SET_RELATIVE_ADDR
;
583 cmd
.arg
= card
->rca
<< 16;
584 cmd
.flags
= MMC_RSP_R1
;
586 err
= mmc_wait_for_cmd(host
, &cmd
, CMD_RETRIES
);
587 if (err
!= MMC_ERR_NONE
)
588 mmc_card_set_dead(card
);
592 static void mmc_read_csds(struct mmc_host
*host
)
594 struct mmc_card
*card
;
596 list_for_each_entry(card
, &host
->cards
, node
) {
597 struct mmc_command cmd
;
600 if (card
->state
& (MMC_STATE_DEAD
|MMC_STATE_PRESENT
))
603 cmd
.opcode
= MMC_SEND_CSD
;
604 cmd
.arg
= card
->rca
<< 16;
605 cmd
.flags
= MMC_RSP_R2
;
607 err
= mmc_wait_for_cmd(host
, &cmd
, CMD_RETRIES
);
608 if (err
!= MMC_ERR_NONE
) {
609 mmc_card_set_dead(card
);
613 memcpy(card
->raw_csd
, cmd
.resp
, sizeof(card
->raw_csd
));
615 mmc_decode_csd(card
);
616 mmc_decode_cid(card
);
620 static unsigned int mmc_calculate_clock(struct mmc_host
*host
)
622 struct mmc_card
*card
;
623 unsigned int max_dtr
= host
->f_max
;
625 list_for_each_entry(card
, &host
->cards
, node
)
626 if (!mmc_card_dead(card
) && max_dtr
> card
->csd
.max_dtr
)
627 max_dtr
= card
->csd
.max_dtr
;
629 DBG("MMC: selected %d.%03dMHz transfer rate\n",
630 max_dtr
/ 1000000, (max_dtr
/ 1000) % 1000);
636 * Check whether cards we already know about are still present.
637 * We do this by requesting status, and checking whether a card
640 * A request for status does not cause a state change in data
643 static void mmc_check_cards(struct mmc_host
*host
)
645 struct list_head
*l
, *n
;
647 mmc_deselect_cards(host
);
649 list_for_each_safe(l
, n
, &host
->cards
) {
650 struct mmc_card
*card
= mmc_list_to_card(l
);
651 struct mmc_command cmd
;
654 cmd
.opcode
= MMC_SEND_STATUS
;
655 cmd
.arg
= card
->rca
<< 16;
656 cmd
.flags
= MMC_RSP_R1
;
658 err
= mmc_wait_for_cmd(host
, &cmd
, CMD_RETRIES
);
659 if (err
== MMC_ERR_NONE
)
662 mmc_card_set_dead(card
);
666 static void mmc_setup(struct mmc_host
*host
)
668 if (host
->ios
.power_mode
!= MMC_POWER_ON
) {
673 mmc_idle_cards(host
);
675 err
= mmc_send_op_cond(host
, 0, &ocr
);
676 if (err
!= MMC_ERR_NONE
)
679 host
->ocr
= mmc_select_voltage(host
, ocr
);
682 * Since we're changing the OCR value, we seem to
683 * need to tell some cards to go back to the idle
684 * state. We wait 1ms to give cards time to
688 mmc_idle_cards(host
);
690 host
->ios
.bus_mode
= MMC_BUSMODE_OPENDRAIN
;
691 host
->ios
.clock
= host
->f_min
;
692 host
->ops
->set_ios(host
, &host
->ios
);
695 * We should remember the OCR mask from the existing
696 * cards, and detect the new cards OCR mask, combine
697 * the two and re-select the VDD. However, if we do
698 * change VDD, we should do an idle, and then do a
699 * full re-initialisation. We would need to notify
700 * drivers so that they can re-setup the cards as
701 * well, while keeping their queues at bay.
703 * For the moment, we take the easy way out - if the
704 * new cards don't like our currently selected VDD,
705 * they drop off the bus.
713 * Send the selected OCR multiple times... until the cards
714 * all get the idea that they should be ready for CMD2.
715 * (My SanDisk card seems to need this.)
717 mmc_send_op_cond(host
, host
->ocr
, NULL
);
719 mmc_discover_cards(host
);
722 * Ok, now switch to push-pull mode.
724 host
->ios
.bus_mode
= MMC_BUSMODE_PUSHPULL
;
725 host
->ops
->set_ios(host
, &host
->ios
);
732 * mmc_detect_change - process change of state on a MMC socket
733 * @host: host which changed state.
735 * All we know is that card(s) have been inserted or removed
736 * from the socket(s). We don't know which socket or cards.
738 void mmc_detect_change(struct mmc_host
*host
)
740 schedule_work(&host
->detect
);
743 EXPORT_SYMBOL(mmc_detect_change
);
746 static void mmc_rescan(void *data
)
748 struct mmc_host
*host
= data
;
749 struct list_head
*l
, *n
;
751 mmc_claim_host(host
);
753 if (host
->ios
.power_mode
== MMC_POWER_ON
)
754 mmc_check_cards(host
);
758 if (!list_empty(&host
->cards
)) {
760 * (Re-)calculate the fastest clock rate which the
761 * attached cards and the host support.
763 host
->ios
.clock
= mmc_calculate_clock(host
);
764 host
->ops
->set_ios(host
, &host
->ios
);
767 mmc_release_host(host
);
769 list_for_each_safe(l
, n
, &host
->cards
) {
770 struct mmc_card
*card
= mmc_list_to_card(l
);
773 * If this is a new and good card, register it.
775 if (!mmc_card_present(card
) && !mmc_card_dead(card
)) {
776 if (mmc_register_card(card
))
777 mmc_card_set_dead(card
);
779 mmc_card_set_present(card
);
783 * If this card is dead, destroy it.
785 if (mmc_card_dead(card
)) {
786 list_del(&card
->node
);
787 mmc_remove_card(card
);
792 * If we discover that there are no cards on the
793 * bus, turn off the clock and power down.
795 if (list_empty(&host
->cards
))
801 * mmc_alloc_host - initialise the per-host structure.
802 * @extra: sizeof private data structure
803 * @dev: pointer to host device model structure
805 * Initialise the per-host structure.
807 struct mmc_host
*mmc_alloc_host(int extra
, struct device
*dev
)
809 struct mmc_host
*host
;
811 host
= mmc_alloc_host_sysfs(extra
, dev
);
813 spin_lock_init(&host
->lock
);
814 init_waitqueue_head(&host
->wq
);
815 INIT_LIST_HEAD(&host
->cards
);
816 INIT_WORK(&host
->detect
, mmc_rescan
, host
);
819 * By default, hosts do not support SGIO or large requests.
820 * They have to set these according to their abilities.
822 host
->max_hw_segs
= 1;
823 host
->max_phys_segs
= 1;
824 host
->max_sectors
= 1 << (PAGE_CACHE_SHIFT
- 9);
825 host
->max_seg_size
= PAGE_CACHE_SIZE
;
831 EXPORT_SYMBOL(mmc_alloc_host
);
834 * mmc_add_host - initialise host hardware
837 int mmc_add_host(struct mmc_host
*host
)
841 ret
= mmc_add_host_sysfs(host
);
844 mmc_detect_change(host
);
850 EXPORT_SYMBOL(mmc_add_host
);
853 * mmc_remove_host - remove host hardware
856 * Unregister and remove all cards associated with this host,
857 * and power down the MMC bus.
859 void mmc_remove_host(struct mmc_host
*host
)
861 struct list_head
*l
, *n
;
863 list_for_each_safe(l
, n
, &host
->cards
) {
864 struct mmc_card
*card
= mmc_list_to_card(l
);
866 mmc_remove_card(card
);
870 mmc_remove_host_sysfs(host
);
873 EXPORT_SYMBOL(mmc_remove_host
);
876 * mmc_free_host - free the host structure
879 * Free the host once all references to it have been dropped.
881 void mmc_free_host(struct mmc_host
*host
)
883 flush_scheduled_work();
884 mmc_free_host_sysfs(host
);
887 EXPORT_SYMBOL(mmc_free_host
);
892 * mmc_suspend_host - suspend a host
894 * @state: suspend mode (PM_SUSPEND_xxx)
896 int mmc_suspend_host(struct mmc_host
*host
, pm_message_t state
)
898 mmc_claim_host(host
);
899 mmc_deselect_cards(host
);
901 mmc_release_host(host
);
906 EXPORT_SYMBOL(mmc_suspend_host
);
909 * mmc_resume_host - resume a previously suspended host
912 int mmc_resume_host(struct mmc_host
*host
)
914 mmc_detect_change(host
);
919 EXPORT_SYMBOL(mmc_resume_host
);
923 MODULE_LICENSE("GPL");