xref: /openbmc/linux/drivers/mmc/core/core.c (revision 22246614) 
1 /*
2  *  linux/drivers/mmc/core/core.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  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/completion.h>
17 #include <linux/device.h>
18 #include <linux/delay.h>
19 #include <linux/pagemap.h>
20 #include <linux/err.h>
21 #include <linux/leds.h>
22 #include <linux/scatterlist.h>
23 
24 #include <linux/mmc/card.h>
25 #include <linux/mmc/host.h>
26 #include <linux/mmc/mmc.h>
27 #include <linux/mmc/sd.h>
28 
29 #include "core.h"
30 #include "bus.h"
31 #include "host.h"
32 #include "sdio_bus.h"
33 
34 #include "mmc_ops.h"
35 #include "sd_ops.h"
36 #include "sdio_ops.h"
37 
38 static struct workqueue_struct *workqueue;
39 
40 /*
41  * Enabling software CRCs on the data blocks can be a significant (30%)
42  * performance cost, and for other reasons may not always be desired.
43  * So we allow it it to be disabled.
44  */
45 int use_spi_crc = 1;
46 module_param(use_spi_crc, bool, 0);
47 
48 /*
49  * Internal function. Schedule delayed work in the MMC work queue.
50  */
51 static int mmc_schedule_delayed_work(struct delayed_work *work,
52 				     unsigned long delay)
53 {
54 	return queue_delayed_work(workqueue, work, delay);
55 }
56 
57 /*
58  * Internal function. Flush all scheduled work from the MMC work queue.
59  */
60 static void mmc_flush_scheduled_work(void)
61 {
62 	flush_workqueue(workqueue);
63 }
64 
65 /**
66  *	mmc_request_done - finish processing an MMC request
67  *	@host: MMC host which completed request
68  *	@mrq: MMC request which request
69  *
70  *	MMC drivers should call this function when they have completed
71  *	their processing of a request.
72  */
73 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
74 {
75 	struct mmc_command *cmd = mrq->cmd;
76 	int err = cmd->error;
77 
78 	if (err && cmd->retries && mmc_host_is_spi(host)) {
79 		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
80 			cmd->retries = 0;
81 	}
82 
83 	if (err && cmd->retries) {
84 		pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
85 			mmc_hostname(host), cmd->opcode, err);
86 
87 		cmd->retries--;
88 		cmd->error = 0;
89 		host->ops->request(host, mrq);
90 	} else {
91 		led_trigger_event(host->led, LED_OFF);
92 
93 		pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
94 			mmc_hostname(host), cmd->opcode, err,
95 			cmd->resp[0], cmd->resp[1],
96 			cmd->resp[2], cmd->resp[3]);
97 
98 		if (mrq->data) {
99 			pr_debug("%s:     %d bytes transferred: %d\n",
100 				mmc_hostname(host),
101 				mrq->data->bytes_xfered, mrq->data->error);
102 		}
103 
104 		if (mrq->stop) {
105 			pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
106 				mmc_hostname(host), mrq->stop->opcode,
107 				mrq->stop->error,
108 				mrq->stop->resp[0], mrq->stop->resp[1],
109 				mrq->stop->resp[2], mrq->stop->resp[3]);
110 		}
111 
112 		if (mrq->done)
113 			mrq->done(mrq);
114 	}
115 }
116 
117 EXPORT_SYMBOL(mmc_request_done);
118 
119 static void
120 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
121 {
122 #ifdef CONFIG_MMC_DEBUG
123 	unsigned int i, sz;
124 #endif
125 
126 	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
127 		 mmc_hostname(host), mrq->cmd->opcode,
128 		 mrq->cmd->arg, mrq->cmd->flags);
129 
130 	if (mrq->data) {
131 		pr_debug("%s:     blksz %d blocks %d flags %08x "
132 			"tsac %d ms nsac %d\n",
133 			mmc_hostname(host), mrq->data->blksz,
134 			mrq->data->blocks, mrq->data->flags,
135 			mrq->data->timeout_ns / 1000000,
136 			mrq->data->timeout_clks);
137 	}
138 
139 	if (mrq->stop) {
140 		pr_debug("%s:     CMD%u arg %08x flags %08x\n",
141 			 mmc_hostname(host), mrq->stop->opcode,
142 			 mrq->stop->arg, mrq->stop->flags);
143 	}
144 
145 	WARN_ON(!host->claimed);
146 
147 	led_trigger_event(host->led, LED_FULL);
148 
149 	mrq->cmd->error = 0;
150 	mrq->cmd->mrq = mrq;
151 	if (mrq->data) {
152 		BUG_ON(mrq->data->blksz > host->max_blk_size);
153 		BUG_ON(mrq->data->blocks > host->max_blk_count);
154 		BUG_ON(mrq->data->blocks * mrq->data->blksz >
155 			host->max_req_size);
156 
157 #ifdef CONFIG_MMC_DEBUG
158 		sz = 0;
159 		for (i = 0;i < mrq->data->sg_len;i++)
160 			sz += mrq->data->sg[i].length;
161 		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
162 #endif
163 
164 		mrq->cmd->data = mrq->data;
165 		mrq->data->error = 0;
166 		mrq->data->mrq = mrq;
167 		if (mrq->stop) {
168 			mrq->data->stop = mrq->stop;
169 			mrq->stop->error = 0;
170 			mrq->stop->mrq = mrq;
171 		}
172 	}
173 	host->ops->request(host, mrq);
174 }
175 
176 static void mmc_wait_done(struct mmc_request *mrq)
177 {
178 	complete(mrq->done_data);
179 }
180 
181 /**
182  *	mmc_wait_for_req - start a request and wait for completion
183  *	@host: MMC host to start command
184  *	@mrq: MMC request to start
185  *
186  *	Start a new MMC custom command request for a host, and wait
187  *	for the command to complete. Does not attempt to parse the
188  *	response.
189  */
190 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
191 {
192 	DECLARE_COMPLETION_ONSTACK(complete);
193 
194 	mrq->done_data = &complete;
195 	mrq->done = mmc_wait_done;
196 
197 	mmc_start_request(host, mrq);
198 
199 	wait_for_completion(&complete);
200 }
201 
202 EXPORT_SYMBOL(mmc_wait_for_req);
203 
204 /**
205  *	mmc_wait_for_cmd - start a command and wait for completion
206  *	@host: MMC host to start command
207  *	@cmd: MMC command to start
208  *	@retries: maximum number of retries
209  *
210  *	Start a new MMC command for a host, and wait for the command
211  *	to complete.  Return any error that occurred while the command
212  *	was executing.  Do not attempt to parse the response.
213  */
214 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
215 {
216 	struct mmc_request mrq;
217 
218 	WARN_ON(!host->claimed);
219 
220 	memset(&mrq, 0, sizeof(struct mmc_request));
221 
222 	memset(cmd->resp, 0, sizeof(cmd->resp));
223 	cmd->retries = retries;
224 
225 	mrq.cmd = cmd;
226 	cmd->data = NULL;
227 
228 	mmc_wait_for_req(host, &mrq);
229 
230 	return cmd->error;
231 }
232 
233 EXPORT_SYMBOL(mmc_wait_for_cmd);
234 
235 /**
236  *	mmc_set_data_timeout - set the timeout for a data command
237  *	@data: data phase for command
238  *	@card: the MMC card associated with the data transfer
239  *
240  *	Computes the data timeout parameters according to the
241  *	correct algorithm given the card type.
242  */
243 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
244 {
245 	unsigned int mult;
246 
247 	/*
248 	 * SDIO cards only define an upper 1 s limit on access.
249 	 */
250 	if (mmc_card_sdio(card)) {
251 		data->timeout_ns = 1000000000;
252 		data->timeout_clks = 0;
253 		return;
254 	}
255 
256 	/*
257 	 * SD cards use a 100 multiplier rather than 10
258 	 */
259 	mult = mmc_card_sd(card) ? 100 : 10;
260 
261 	/*
262 	 * Scale up the multiplier (and therefore the timeout) by
263 	 * the r2w factor for writes.
264 	 */
265 	if (data->flags & MMC_DATA_WRITE)
266 		mult <<= card->csd.r2w_factor;
267 
268 	data->timeout_ns = card->csd.tacc_ns * mult;
269 	data->timeout_clks = card->csd.tacc_clks * mult;
270 
271 	/*
272 	 * SD cards also have an upper limit on the timeout.
273 	 */
274 	if (mmc_card_sd(card)) {
275 		unsigned int timeout_us, limit_us;
276 
277 		timeout_us = data->timeout_ns / 1000;
278 		timeout_us += data->timeout_clks * 1000 /
279 			(card->host->ios.clock / 1000);
280 
281 		if (data->flags & MMC_DATA_WRITE)
282 			limit_us = 250000;
283 		else
284 			limit_us = 100000;
285 
286 		/*
287 		 * SDHC cards always use these fixed values.
288 		 */
289 		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
290 			data->timeout_ns = limit_us * 1000;
291 			data->timeout_clks = 0;
292 		}
293 	}
294 }
295 EXPORT_SYMBOL(mmc_set_data_timeout);
296 
297 /**
298  *	__mmc_claim_host - exclusively claim a host
299  *	@host: mmc host to claim
300  *	@abort: whether or not the operation should be aborted
301  *
302  *	Claim a host for a set of operations.  If @abort is non null and
303  *	dereference a non-zero value then this will return prematurely with
304  *	that non-zero value without acquiring the lock.  Returns zero
305  *	with the lock held otherwise.
306  */
307 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
308 {
309 	DECLARE_WAITQUEUE(wait, current);
310 	unsigned long flags;
311 	int stop;
312 
313 	might_sleep();
314 
315 	add_wait_queue(&host->wq, &wait);
316 	spin_lock_irqsave(&host->lock, flags);
317 	while (1) {
318 		set_current_state(TASK_UNINTERRUPTIBLE);
319 		stop = abort ? atomic_read(abort) : 0;
320 		if (stop || !host->claimed)
321 			break;
322 		spin_unlock_irqrestore(&host->lock, flags);
323 		schedule();
324 		spin_lock_irqsave(&host->lock, flags);
325 	}
326 	set_current_state(TASK_RUNNING);
327 	if (!stop)
328 		host->claimed = 1;
329 	else
330 		wake_up(&host->wq);
331 	spin_unlock_irqrestore(&host->lock, flags);
332 	remove_wait_queue(&host->wq, &wait);
333 	return stop;
334 }
335 
336 EXPORT_SYMBOL(__mmc_claim_host);
337 
338 /**
339  *	mmc_release_host - release a host
340  *	@host: mmc host to release
341  *
342  *	Release a MMC host, allowing others to claim the host
343  *	for their operations.
344  */
345 void mmc_release_host(struct mmc_host *host)
346 {
347 	unsigned long flags;
348 
349 	WARN_ON(!host->claimed);
350 
351 	spin_lock_irqsave(&host->lock, flags);
352 	host->claimed = 0;
353 	spin_unlock_irqrestore(&host->lock, flags);
354 
355 	wake_up(&host->wq);
356 }
357 
358 EXPORT_SYMBOL(mmc_release_host);
359 
360 /*
361  * Internal function that does the actual ios call to the host driver,
362  * optionally printing some debug output.
363  */
364 static inline void mmc_set_ios(struct mmc_host *host)
365 {
366 	struct mmc_ios *ios = &host->ios;
367 
368 	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
369 		"width %u timing %u\n",
370 		 mmc_hostname(host), ios->clock, ios->bus_mode,
371 		 ios->power_mode, ios->chip_select, ios->vdd,
372 		 ios->bus_width, ios->timing);
373 
374 	host->ops->set_ios(host, ios);
375 }
376 
377 /*
378  * Control chip select pin on a host.
379  */
380 void mmc_set_chip_select(struct mmc_host *host, int mode)
381 {
382 	host->ios.chip_select = mode;
383 	mmc_set_ios(host);
384 }
385 
386 /*
387  * Sets the host clock to the highest possible frequency that
388  * is below "hz".
389  */
390 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
391 {
392 	WARN_ON(hz < host->f_min);
393 
394 	if (hz > host->f_max)
395 		hz = host->f_max;
396 
397 	host->ios.clock = hz;
398 	mmc_set_ios(host);
399 }
400 
401 /*
402  * Change the bus mode (open drain/push-pull) of a host.
403  */
404 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
405 {
406 	host->ios.bus_mode = mode;
407 	mmc_set_ios(host);
408 }
409 
410 /*
411  * Change data bus width of a host.
412  */
413 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
414 {
415 	host->ios.bus_width = width;
416 	mmc_set_ios(host);
417 }
418 
419 /*
420  * Mask off any voltages we don't support and select
421  * the lowest voltage
422  */
423 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
424 {
425 	int bit;
426 
427 	ocr &= host->ocr_avail;
428 
429 	bit = ffs(ocr);
430 	if (bit) {
431 		bit -= 1;
432 
433 		ocr &= 3 << bit;
434 
435 		host->ios.vdd = bit;
436 		mmc_set_ios(host);
437 	} else {
438 		ocr = 0;
439 	}
440 
441 	return ocr;
442 }
443 
444 /*
445  * Select timing parameters for host.
446  */
447 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
448 {
449 	host->ios.timing = timing;
450 	mmc_set_ios(host);
451 }
452 
453 /*
454  * Apply power to the MMC stack.  This is a two-stage process.
455  * First, we enable power to the card without the clock running.
456  * We then wait a bit for the power to stabilise.  Finally,
457  * enable the bus drivers and clock to the card.
458  *
459  * We must _NOT_ enable the clock prior to power stablising.
460  *
461  * If a host does all the power sequencing itself, ignore the
462  * initial MMC_POWER_UP stage.
463  */
464 static void mmc_power_up(struct mmc_host *host)
465 {
466 	int bit = fls(host->ocr_avail) - 1;
467 
468 	host->ios.vdd = bit;
469 	if (mmc_host_is_spi(host)) {
470 		host->ios.chip_select = MMC_CS_HIGH;
471 		host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
472 	} else {
473 		host->ios.chip_select = MMC_CS_DONTCARE;
474 		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
475 	}
476 	host->ios.power_mode = MMC_POWER_UP;
477 	host->ios.bus_width = MMC_BUS_WIDTH_1;
478 	host->ios.timing = MMC_TIMING_LEGACY;
479 	mmc_set_ios(host);
480 
481 	/*
482 	 * This delay should be sufficient to allow the power supply
483 	 * to reach the minimum voltage.
484 	 */
485 	mmc_delay(2);
486 
487 	host->ios.clock = host->f_min;
488 	host->ios.power_mode = MMC_POWER_ON;
489 	mmc_set_ios(host);
490 
491 	/*
492 	 * This delay must be at least 74 clock sizes, or 1 ms, or the
493 	 * time required to reach a stable voltage.
494 	 */
495 	mmc_delay(2);
496 }
497 
498 static void mmc_power_off(struct mmc_host *host)
499 {
500 	host->ios.clock = 0;
501 	host->ios.vdd = 0;
502 	if (!mmc_host_is_spi(host)) {
503 		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
504 		host->ios.chip_select = MMC_CS_DONTCARE;
505 	}
506 	host->ios.power_mode = MMC_POWER_OFF;
507 	host->ios.bus_width = MMC_BUS_WIDTH_1;
508 	host->ios.timing = MMC_TIMING_LEGACY;
509 	mmc_set_ios(host);
510 }
511 
512 /*
513  * Cleanup when the last reference to the bus operator is dropped.
514  */
515 static void __mmc_release_bus(struct mmc_host *host)
516 {
517 	BUG_ON(!host);
518 	BUG_ON(host->bus_refs);
519 	BUG_ON(!host->bus_dead);
520 
521 	host->bus_ops = NULL;
522 }
523 
524 /*
525  * Increase reference count of bus operator
526  */
527 static inline void mmc_bus_get(struct mmc_host *host)
528 {
529 	unsigned long flags;
530 
531 	spin_lock_irqsave(&host->lock, flags);
532 	host->bus_refs++;
533 	spin_unlock_irqrestore(&host->lock, flags);
534 }
535 
536 /*
537  * Decrease reference count of bus operator and free it if
538  * it is the last reference.
539  */
540 static inline void mmc_bus_put(struct mmc_host *host)
541 {
542 	unsigned long flags;
543 
544 	spin_lock_irqsave(&host->lock, flags);
545 	host->bus_refs--;
546 	if ((host->bus_refs == 0) && host->bus_ops)
547 		__mmc_release_bus(host);
548 	spin_unlock_irqrestore(&host->lock, flags);
549 }
550 
551 /*
552  * Assign a mmc bus handler to a host. Only one bus handler may control a
553  * host at any given time.
554  */
555 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
556 {
557 	unsigned long flags;
558 
559 	BUG_ON(!host);
560 	BUG_ON(!ops);
561 
562 	WARN_ON(!host->claimed);
563 
564 	spin_lock_irqsave(&host->lock, flags);
565 
566 	BUG_ON(host->bus_ops);
567 	BUG_ON(host->bus_refs);
568 
569 	host->bus_ops = ops;
570 	host->bus_refs = 1;
571 	host->bus_dead = 0;
572 
573 	spin_unlock_irqrestore(&host->lock, flags);
574 }
575 
576 /*
577  * Remove the current bus handler from a host. Assumes that there are
578  * no interesting cards left, so the bus is powered down.
579  */
580 void mmc_detach_bus(struct mmc_host *host)
581 {
582 	unsigned long flags;
583 
584 	BUG_ON(!host);
585 
586 	WARN_ON(!host->claimed);
587 	WARN_ON(!host->bus_ops);
588 
589 	spin_lock_irqsave(&host->lock, flags);
590 
591 	host->bus_dead = 1;
592 
593 	spin_unlock_irqrestore(&host->lock, flags);
594 
595 	mmc_power_off(host);
596 
597 	mmc_bus_put(host);
598 }
599 
600 /**
601  *	mmc_detect_change - process change of state on a MMC socket
602  *	@host: host which changed state.
603  *	@delay: optional delay to wait before detection (jiffies)
604  *
605  *	MMC drivers should call this when they detect a card has been
606  *	inserted or removed. The MMC layer will confirm that any
607  *	present card is still functional, and initialize any newly
608  *	inserted.
609  */
610 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
611 {
612 #ifdef CONFIG_MMC_DEBUG
613 	unsigned long flags;
614 	spin_lock_irqsave(&host->lock, flags);
615 	WARN_ON(host->removed);
616 	spin_unlock_irqrestore(&host->lock, flags);
617 #endif
618 
619 	mmc_schedule_delayed_work(&host->detect, delay);
620 }
621 
622 EXPORT_SYMBOL(mmc_detect_change);
623 
624 
625 void mmc_rescan(struct work_struct *work)
626 {
627 	struct mmc_host *host =
628 		container_of(work, struct mmc_host, detect.work);
629 	u32 ocr;
630 	int err;
631 
632 	mmc_bus_get(host);
633 
634 	if (host->bus_ops == NULL) {
635 		/*
636 		 * Only we can add a new handler, so it's safe to
637 		 * release the lock here.
638 		 */
639 		mmc_bus_put(host);
640 
641 		mmc_claim_host(host);
642 
643 		mmc_power_up(host);
644 		mmc_go_idle(host);
645 
646 		mmc_send_if_cond(host, host->ocr_avail);
647 
648 		/*
649 		 * First we search for SDIO...
650 		 */
651 		err = mmc_send_io_op_cond(host, 0, &ocr);
652 		if (!err) {
653 			if (mmc_attach_sdio(host, ocr))
654 				mmc_power_off(host);
655 			return;
656 		}
657 
658 		/*
659 		 * ...then normal SD...
660 		 */
661 		err = mmc_send_app_op_cond(host, 0, &ocr);
662 		if (!err) {
663 			if (mmc_attach_sd(host, ocr))
664 				mmc_power_off(host);
665 			return;
666 		}
667 
668 		/*
669 		 * ...and finally MMC.
670 		 */
671 		err = mmc_send_op_cond(host, 0, &ocr);
672 		if (!err) {
673 			if (mmc_attach_mmc(host, ocr))
674 				mmc_power_off(host);
675 			return;
676 		}
677 
678 		mmc_release_host(host);
679 		mmc_power_off(host);
680 	} else {
681 		if (host->bus_ops->detect && !host->bus_dead)
682 			host->bus_ops->detect(host);
683 
684 		mmc_bus_put(host);
685 	}
686 }
687 
688 void mmc_start_host(struct mmc_host *host)
689 {
690 	mmc_power_off(host);
691 	mmc_detect_change(host, 0);
692 }
693 
694 void mmc_stop_host(struct mmc_host *host)
695 {
696 #ifdef CONFIG_MMC_DEBUG
697 	unsigned long flags;
698 	spin_lock_irqsave(&host->lock, flags);
699 	host->removed = 1;
700 	spin_unlock_irqrestore(&host->lock, flags);
701 #endif
702 
703 	mmc_flush_scheduled_work();
704 
705 	mmc_bus_get(host);
706 	if (host->bus_ops && !host->bus_dead) {
707 		if (host->bus_ops->remove)
708 			host->bus_ops->remove(host);
709 
710 		mmc_claim_host(host);
711 		mmc_detach_bus(host);
712 		mmc_release_host(host);
713 	}
714 	mmc_bus_put(host);
715 
716 	BUG_ON(host->card);
717 
718 	mmc_power_off(host);
719 }
720 
721 #ifdef CONFIG_PM
722 
723 /**
724  *	mmc_suspend_host - suspend a host
725  *	@host: mmc host
726  *	@state: suspend mode (PM_SUSPEND_xxx)
727  */
728 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
729 {
730 	mmc_flush_scheduled_work();
731 
732 	mmc_bus_get(host);
733 	if (host->bus_ops && !host->bus_dead) {
734 		if (host->bus_ops->suspend)
735 			host->bus_ops->suspend(host);
736 		if (!host->bus_ops->resume) {
737 			if (host->bus_ops->remove)
738 				host->bus_ops->remove(host);
739 
740 			mmc_claim_host(host);
741 			mmc_detach_bus(host);
742 			mmc_release_host(host);
743 		}
744 	}
745 	mmc_bus_put(host);
746 
747 	mmc_power_off(host);
748 
749 	return 0;
750 }
751 
752 EXPORT_SYMBOL(mmc_suspend_host);
753 
754 /**
755  *	mmc_resume_host - resume a previously suspended host
756  *	@host: mmc host
757  */
758 int mmc_resume_host(struct mmc_host *host)
759 {
760 	mmc_bus_get(host);
761 	if (host->bus_ops && !host->bus_dead) {
762 		mmc_power_up(host);
763 		BUG_ON(!host->bus_ops->resume);
764 		host->bus_ops->resume(host);
765 	}
766 	mmc_bus_put(host);
767 
768 	/*
769 	 * We add a slight delay here so that resume can progress
770 	 * in parallel.
771 	 */
772 	mmc_detect_change(host, 1);
773 
774 	return 0;
775 }
776 
777 EXPORT_SYMBOL(mmc_resume_host);
778 
779 #endif
780 
781 static int __init mmc_init(void)
782 {
783 	int ret;
784 
785 	workqueue = create_singlethread_workqueue("kmmcd");
786 	if (!workqueue)
787 		return -ENOMEM;
788 
789 	ret = mmc_register_bus();
790 	if (ret)
791 		goto destroy_workqueue;
792 
793 	ret = mmc_register_host_class();
794 	if (ret)
795 		goto unregister_bus;
796 
797 	ret = sdio_register_bus();
798 	if (ret)
799 		goto unregister_host_class;
800 
801 	return 0;
802 
803 unregister_host_class:
804 	mmc_unregister_host_class();
805 unregister_bus:
806 	mmc_unregister_bus();
807 destroy_workqueue:
808 	destroy_workqueue(workqueue);
809 
810 	return ret;
811 }
812 
813 static void __exit mmc_exit(void)
814 {
815 	sdio_unregister_bus();
816 	mmc_unregister_host_class();
817 	mmc_unregister_bus();
818 	destroy_workqueue(workqueue);
819 }
820 
821 subsys_initcall(mmc_init);
822 module_exit(mmc_exit);
823 
824 MODULE_LICENSE("GPL");
825