mmc: core: Fix hangs related to insert/remove of cards
[~shefty/rdma-dev.git] / drivers / mmc / core / core.c
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-2008 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 #include <linux/log2.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/suspend.h>
27 #include <linux/fault-inject.h>
28 #include <linux/random.h>
29
30 #include <linux/mmc/card.h>
31 #include <linux/mmc/host.h>
32 #include <linux/mmc/mmc.h>
33 #include <linux/mmc/sd.h>
34
35 #include "core.h"
36 #include "bus.h"
37 #include "host.h"
38 #include "sdio_bus.h"
39
40 #include "mmc_ops.h"
41 #include "sd_ops.h"
42 #include "sdio_ops.h"
43
44 static struct workqueue_struct *workqueue;
45
46 /*
47  * Enabling software CRCs on the data blocks can be a significant (30%)
48  * performance cost, and for other reasons may not always be desired.
49  * So we allow it it to be disabled.
50  */
51 int use_spi_crc = 1;
52 module_param(use_spi_crc, bool, 0);
53
54 /*
55  * We normally treat cards as removed during suspend if they are not
56  * known to be on a non-removable bus, to avoid the risk of writing
57  * back data to a different card after resume.  Allow this to be
58  * overridden if necessary.
59  */
60 #ifdef CONFIG_MMC_UNSAFE_RESUME
61 int mmc_assume_removable;
62 #else
63 int mmc_assume_removable = 1;
64 #endif
65 EXPORT_SYMBOL(mmc_assume_removable);
66 module_param_named(removable, mmc_assume_removable, bool, 0644);
67 MODULE_PARM_DESC(
68         removable,
69         "MMC/SD cards are removable and may be removed during suspend");
70
71 /*
72  * Internal function. Schedule delayed work in the MMC work queue.
73  */
74 static int mmc_schedule_delayed_work(struct delayed_work *work,
75                                      unsigned long delay)
76 {
77         return queue_delayed_work(workqueue, work, delay);
78 }
79
80 /*
81  * Internal function. Flush all scheduled work from the MMC work queue.
82  */
83 static void mmc_flush_scheduled_work(void)
84 {
85         flush_workqueue(workqueue);
86 }
87
88 #ifdef CONFIG_FAIL_MMC_REQUEST
89
90 /*
91  * Internal function. Inject random data errors.
92  * If mmc_data is NULL no errors are injected.
93  */
94 static void mmc_should_fail_request(struct mmc_host *host,
95                                     struct mmc_request *mrq)
96 {
97         struct mmc_command *cmd = mrq->cmd;
98         struct mmc_data *data = mrq->data;
99         static const int data_errors[] = {
100                 -ETIMEDOUT,
101                 -EILSEQ,
102                 -EIO,
103         };
104
105         if (!data)
106                 return;
107
108         if (cmd->error || data->error ||
109             !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
110                 return;
111
112         data->error = data_errors[random32() % ARRAY_SIZE(data_errors)];
113         data->bytes_xfered = (random32() % (data->bytes_xfered >> 9)) << 9;
114 }
115
116 #else /* CONFIG_FAIL_MMC_REQUEST */
117
118 static inline void mmc_should_fail_request(struct mmc_host *host,
119                                            struct mmc_request *mrq)
120 {
121 }
122
123 #endif /* CONFIG_FAIL_MMC_REQUEST */
124
125 /**
126  *      mmc_request_done - finish processing an MMC request
127  *      @host: MMC host which completed request
128  *      @mrq: MMC request which request
129  *
130  *      MMC drivers should call this function when they have completed
131  *      their processing of a request.
132  */
133 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
134 {
135         struct mmc_command *cmd = mrq->cmd;
136         int err = cmd->error;
137
138         if (err && cmd->retries && mmc_host_is_spi(host)) {
139                 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
140                         cmd->retries = 0;
141         }
142
143         if (err && cmd->retries) {
144                 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
145                         mmc_hostname(host), cmd->opcode, err);
146
147                 cmd->retries--;
148                 cmd->error = 0;
149                 host->ops->request(host, mrq);
150         } else {
151                 mmc_should_fail_request(host, mrq);
152
153                 led_trigger_event(host->led, LED_OFF);
154
155                 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
156                         mmc_hostname(host), cmd->opcode, err,
157                         cmd->resp[0], cmd->resp[1],
158                         cmd->resp[2], cmd->resp[3]);
159
160                 if (mrq->data) {
161                         pr_debug("%s:     %d bytes transferred: %d\n",
162                                 mmc_hostname(host),
163                                 mrq->data->bytes_xfered, mrq->data->error);
164                 }
165
166                 if (mrq->stop) {
167                         pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
168                                 mmc_hostname(host), mrq->stop->opcode,
169                                 mrq->stop->error,
170                                 mrq->stop->resp[0], mrq->stop->resp[1],
171                                 mrq->stop->resp[2], mrq->stop->resp[3]);
172                 }
173
174                 if (mrq->done)
175                         mrq->done(mrq);
176
177                 mmc_host_clk_release(host);
178         }
179 }
180
181 EXPORT_SYMBOL(mmc_request_done);
182
183 static void
184 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
185 {
186 #ifdef CONFIG_MMC_DEBUG
187         unsigned int i, sz;
188         struct scatterlist *sg;
189 #endif
190
191         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
192                  mmc_hostname(host), mrq->cmd->opcode,
193                  mrq->cmd->arg, mrq->cmd->flags);
194
195         if (mrq->data) {
196                 pr_debug("%s:     blksz %d blocks %d flags %08x "
197                         "tsac %d ms nsac %d\n",
198                         mmc_hostname(host), mrq->data->blksz,
199                         mrq->data->blocks, mrq->data->flags,
200                         mrq->data->timeout_ns / 1000000,
201                         mrq->data->timeout_clks);
202         }
203
204         if (mrq->stop) {
205                 pr_debug("%s:     CMD%u arg %08x flags %08x\n",
206                          mmc_hostname(host), mrq->stop->opcode,
207                          mrq->stop->arg, mrq->stop->flags);
208         }
209
210         WARN_ON(!host->claimed);
211
212         mrq->cmd->error = 0;
213         mrq->cmd->mrq = mrq;
214         if (mrq->data) {
215                 BUG_ON(mrq->data->blksz > host->max_blk_size);
216                 BUG_ON(mrq->data->blocks > host->max_blk_count);
217                 BUG_ON(mrq->data->blocks * mrq->data->blksz >
218                         host->max_req_size);
219
220 #ifdef CONFIG_MMC_DEBUG
221                 sz = 0;
222                 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
223                         sz += sg->length;
224                 BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
225 #endif
226
227                 mrq->cmd->data = mrq->data;
228                 mrq->data->error = 0;
229                 mrq->data->mrq = mrq;
230                 if (mrq->stop) {
231                         mrq->data->stop = mrq->stop;
232                         mrq->stop->error = 0;
233                         mrq->stop->mrq = mrq;
234                 }
235         }
236         mmc_host_clk_hold(host);
237         led_trigger_event(host->led, LED_FULL);
238         host->ops->request(host, mrq);
239 }
240
241 static void mmc_wait_done(struct mmc_request *mrq)
242 {
243         complete(&mrq->completion);
244 }
245
246 static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
247 {
248         init_completion(&mrq->completion);
249         mrq->done = mmc_wait_done;
250         mmc_start_request(host, mrq);
251 }
252
253 static void mmc_wait_for_req_done(struct mmc_host *host,
254                                   struct mmc_request *mrq)
255 {
256         wait_for_completion(&mrq->completion);
257 }
258
259 /**
260  *      mmc_pre_req - Prepare for a new request
261  *      @host: MMC host to prepare command
262  *      @mrq: MMC request to prepare for
263  *      @is_first_req: true if there is no previous started request
264  *                     that may run in parellel to this call, otherwise false
265  *
266  *      mmc_pre_req() is called in prior to mmc_start_req() to let
267  *      host prepare for the new request. Preparation of a request may be
268  *      performed while another request is running on the host.
269  */
270 static void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq,
271                  bool is_first_req)
272 {
273         if (host->ops->pre_req)
274                 host->ops->pre_req(host, mrq, is_first_req);
275 }
276
277 /**
278  *      mmc_post_req - Post process a completed request
279  *      @host: MMC host to post process command
280  *      @mrq: MMC request to post process for
281  *      @err: Error, if non zero, clean up any resources made in pre_req
282  *
283  *      Let the host post process a completed request. Post processing of
284  *      a request may be performed while another reuqest is running.
285  */
286 static void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq,
287                          int err)
288 {
289         if (host->ops->post_req)
290                 host->ops->post_req(host, mrq, err);
291 }
292
293 /**
294  *      mmc_start_req - start a non-blocking request
295  *      @host: MMC host to start command
296  *      @areq: async request to start
297  *      @error: out parameter returns 0 for success, otherwise non zero
298  *
299  *      Start a new MMC custom command request for a host.
300  *      If there is on ongoing async request wait for completion
301  *      of that request and start the new one and return.
302  *      Does not wait for the new request to complete.
303  *
304  *      Returns the completed request, NULL in case of none completed.
305  *      Wait for the an ongoing request (previoulsy started) to complete and
306  *      return the completed request. If there is no ongoing request, NULL
307  *      is returned without waiting. NULL is not an error condition.
308  */
309 struct mmc_async_req *mmc_start_req(struct mmc_host *host,
310                                     struct mmc_async_req *areq, int *error)
311 {
312         int err = 0;
313         struct mmc_async_req *data = host->areq;
314
315         /* Prepare a new request */
316         if (areq)
317                 mmc_pre_req(host, areq->mrq, !host->areq);
318
319         if (host->areq) {
320                 mmc_wait_for_req_done(host, host->areq->mrq);
321                 err = host->areq->err_check(host->card, host->areq);
322                 if (err) {
323                         mmc_post_req(host, host->areq->mrq, 0);
324                         if (areq)
325                                 mmc_post_req(host, areq->mrq, -EINVAL);
326
327                         host->areq = NULL;
328                         goto out;
329                 }
330         }
331
332         if (areq)
333                 __mmc_start_req(host, areq->mrq);
334
335         if (host->areq)
336                 mmc_post_req(host, host->areq->mrq, 0);
337
338         host->areq = areq;
339  out:
340         if (error)
341                 *error = err;
342         return data;
343 }
344 EXPORT_SYMBOL(mmc_start_req);
345
346 /**
347  *      mmc_wait_for_req - start a request and wait for completion
348  *      @host: MMC host to start command
349  *      @mrq: MMC request to start
350  *
351  *      Start a new MMC custom command request for a host, and wait
352  *      for the command to complete. Does not attempt to parse the
353  *      response.
354  */
355 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
356 {
357         __mmc_start_req(host, mrq);
358         mmc_wait_for_req_done(host, mrq);
359 }
360 EXPORT_SYMBOL(mmc_wait_for_req);
361
362 /**
363  *      mmc_wait_for_cmd - start a command and wait for completion
364  *      @host: MMC host to start command
365  *      @cmd: MMC command to start
366  *      @retries: maximum number of retries
367  *
368  *      Start a new MMC command for a host, and wait for the command
369  *      to complete.  Return any error that occurred while the command
370  *      was executing.  Do not attempt to parse the response.
371  */
372 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
373 {
374         struct mmc_request mrq = {NULL};
375
376         WARN_ON(!host->claimed);
377
378         memset(cmd->resp, 0, sizeof(cmd->resp));
379         cmd->retries = retries;
380
381         mrq.cmd = cmd;
382         cmd->data = NULL;
383
384         mmc_wait_for_req(host, &mrq);
385
386         return cmd->error;
387 }
388
389 EXPORT_SYMBOL(mmc_wait_for_cmd);
390
391 /**
392  *      mmc_set_data_timeout - set the timeout for a data command
393  *      @data: data phase for command
394  *      @card: the MMC card associated with the data transfer
395  *
396  *      Computes the data timeout parameters according to the
397  *      correct algorithm given the card type.
398  */
399 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
400 {
401         unsigned int mult;
402
403         /*
404          * SDIO cards only define an upper 1 s limit on access.
405          */
406         if (mmc_card_sdio(card)) {
407                 data->timeout_ns = 1000000000;
408                 data->timeout_clks = 0;
409                 return;
410         }
411
412         /*
413          * SD cards use a 100 multiplier rather than 10
414          */
415         mult = mmc_card_sd(card) ? 100 : 10;
416
417         /*
418          * Scale up the multiplier (and therefore the timeout) by
419          * the r2w factor for writes.
420          */
421         if (data->flags & MMC_DATA_WRITE)
422                 mult <<= card->csd.r2w_factor;
423
424         data->timeout_ns = card->csd.tacc_ns * mult;
425         data->timeout_clks = card->csd.tacc_clks * mult;
426
427         /*
428          * SD cards also have an upper limit on the timeout.
429          */
430         if (mmc_card_sd(card)) {
431                 unsigned int timeout_us, limit_us;
432
433                 timeout_us = data->timeout_ns / 1000;
434                 if (mmc_host_clk_rate(card->host))
435                         timeout_us += data->timeout_clks * 1000 /
436                                 (mmc_host_clk_rate(card->host) / 1000);
437
438                 if (data->flags & MMC_DATA_WRITE)
439                         /*
440                          * The limit is really 250 ms, but that is
441                          * insufficient for some crappy cards.
442                          */
443                         limit_us = 300000;
444                 else
445                         limit_us = 100000;
446
447                 /*
448                  * SDHC cards always use these fixed values.
449                  */
450                 if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
451                         data->timeout_ns = limit_us * 1000;
452                         data->timeout_clks = 0;
453                 }
454         }
455         /*
456          * Some cards need very high timeouts if driven in SPI mode.
457          * The worst observed timeout was 900ms after writing a
458          * continuous stream of data until the internal logic
459          * overflowed.
460          */
461         if (mmc_host_is_spi(card->host)) {
462                 if (data->flags & MMC_DATA_WRITE) {
463                         if (data->timeout_ns < 1000000000)
464                                 data->timeout_ns = 1000000000;  /* 1s */
465                 } else {
466                         if (data->timeout_ns < 100000000)
467                                 data->timeout_ns =  100000000;  /* 100ms */
468                 }
469         }
470 }
471 EXPORT_SYMBOL(mmc_set_data_timeout);
472
473 /**
474  *      mmc_align_data_size - pads a transfer size to a more optimal value
475  *      @card: the MMC card associated with the data transfer
476  *      @sz: original transfer size
477  *
478  *      Pads the original data size with a number of extra bytes in
479  *      order to avoid controller bugs and/or performance hits
480  *      (e.g. some controllers revert to PIO for certain sizes).
481  *
482  *      Returns the improved size, which might be unmodified.
483  *
484  *      Note that this function is only relevant when issuing a
485  *      single scatter gather entry.
486  */
487 unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
488 {
489         /*
490          * FIXME: We don't have a system for the controller to tell
491          * the core about its problems yet, so for now we just 32-bit
492          * align the size.
493          */
494         sz = ((sz + 3) / 4) * 4;
495
496         return sz;
497 }
498 EXPORT_SYMBOL(mmc_align_data_size);
499
500 /**
501  *      mmc_host_enable - enable a host.
502  *      @host: mmc host to enable
503  *
504  *      Hosts that support power saving can use the 'enable' and 'disable'
505  *      methods to exit and enter power saving states. For more information
506  *      see comments for struct mmc_host_ops.
507  */
508 int mmc_host_enable(struct mmc_host *host)
509 {
510         if (!(host->caps & MMC_CAP_DISABLE))
511                 return 0;
512
513         if (host->en_dis_recurs)
514                 return 0;
515
516         if (host->nesting_cnt++)
517                 return 0;
518
519         cancel_delayed_work_sync(&host->disable);
520
521         if (host->enabled)
522                 return 0;
523
524         if (host->ops->enable) {
525                 int err;
526
527                 host->en_dis_recurs = 1;
528                 err = host->ops->enable(host);
529                 host->en_dis_recurs = 0;
530
531                 if (err) {
532                         pr_debug("%s: enable error %d\n",
533                                  mmc_hostname(host), err);
534                         return err;
535                 }
536         }
537         host->enabled = 1;
538         return 0;
539 }
540 EXPORT_SYMBOL(mmc_host_enable);
541
542 static int mmc_host_do_disable(struct mmc_host *host, int lazy)
543 {
544         if (host->ops->disable) {
545                 int err;
546
547                 host->en_dis_recurs = 1;
548                 err = host->ops->disable(host, lazy);
549                 host->en_dis_recurs = 0;
550
551                 if (err < 0) {
552                         pr_debug("%s: disable error %d\n",
553                                  mmc_hostname(host), err);
554                         return err;
555                 }
556                 if (err > 0) {
557                         unsigned long delay = msecs_to_jiffies(err);
558
559                         mmc_schedule_delayed_work(&host->disable, delay);
560                 }
561         }
562         host->enabled = 0;
563         return 0;
564 }
565
566 /**
567  *      mmc_host_disable - disable a host.
568  *      @host: mmc host to disable
569  *
570  *      Hosts that support power saving can use the 'enable' and 'disable'
571  *      methods to exit and enter power saving states. For more information
572  *      see comments for struct mmc_host_ops.
573  */
574 int mmc_host_disable(struct mmc_host *host)
575 {
576         int err;
577
578         if (!(host->caps & MMC_CAP_DISABLE))
579                 return 0;
580
581         if (host->en_dis_recurs)
582                 return 0;
583
584         if (--host->nesting_cnt)
585                 return 0;
586
587         if (!host->enabled)
588                 return 0;
589
590         err = mmc_host_do_disable(host, 0);
591         return err;
592 }
593 EXPORT_SYMBOL(mmc_host_disable);
594
595 /**
596  *      __mmc_claim_host - exclusively claim a host
597  *      @host: mmc host to claim
598  *      @abort: whether or not the operation should be aborted
599  *
600  *      Claim a host for a set of operations.  If @abort is non null and
601  *      dereference a non-zero value then this will return prematurely with
602  *      that non-zero value without acquiring the lock.  Returns zero
603  *      with the lock held otherwise.
604  */
605 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
606 {
607         DECLARE_WAITQUEUE(wait, current);
608         unsigned long flags;
609         int stop;
610
611         might_sleep();
612
613         add_wait_queue(&host->wq, &wait);
614         spin_lock_irqsave(&host->lock, flags);
615         while (1) {
616                 set_current_state(TASK_UNINTERRUPTIBLE);
617                 stop = abort ? atomic_read(abort) : 0;
618                 if (stop || !host->claimed || host->claimer == current)
619                         break;
620                 spin_unlock_irqrestore(&host->lock, flags);
621                 schedule();
622                 spin_lock_irqsave(&host->lock, flags);
623         }
624         set_current_state(TASK_RUNNING);
625         if (!stop) {
626                 host->claimed = 1;
627                 host->claimer = current;
628                 host->claim_cnt += 1;
629         } else
630                 wake_up(&host->wq);
631         spin_unlock_irqrestore(&host->lock, flags);
632         remove_wait_queue(&host->wq, &wait);
633         if (!stop)
634                 mmc_host_enable(host);
635         return stop;
636 }
637
638 EXPORT_SYMBOL(__mmc_claim_host);
639
640 /**
641  *      mmc_try_claim_host - try exclusively to claim a host
642  *      @host: mmc host to claim
643  *
644  *      Returns %1 if the host is claimed, %0 otherwise.
645  */
646 int mmc_try_claim_host(struct mmc_host *host)
647 {
648         int claimed_host = 0;
649         unsigned long flags;
650
651         spin_lock_irqsave(&host->lock, flags);
652         if (!host->claimed || host->claimer == current) {
653                 host->claimed = 1;
654                 host->claimer = current;
655                 host->claim_cnt += 1;
656                 claimed_host = 1;
657         }
658         spin_unlock_irqrestore(&host->lock, flags);
659         return claimed_host;
660 }
661 EXPORT_SYMBOL(mmc_try_claim_host);
662
663 /**
664  *      mmc_do_release_host - release a claimed host
665  *      @host: mmc host to release
666  *
667  *      If you successfully claimed a host, this function will
668  *      release it again.
669  */
670 void mmc_do_release_host(struct mmc_host *host)
671 {
672         unsigned long flags;
673
674         spin_lock_irqsave(&host->lock, flags);
675         if (--host->claim_cnt) {
676                 /* Release for nested claim */
677                 spin_unlock_irqrestore(&host->lock, flags);
678         } else {
679                 host->claimed = 0;
680                 host->claimer = NULL;
681                 spin_unlock_irqrestore(&host->lock, flags);
682                 wake_up(&host->wq);
683         }
684 }
685 EXPORT_SYMBOL(mmc_do_release_host);
686
687 void mmc_host_deeper_disable(struct work_struct *work)
688 {
689         struct mmc_host *host =
690                 container_of(work, struct mmc_host, disable.work);
691
692         /* If the host is claimed then we do not want to disable it anymore */
693         if (!mmc_try_claim_host(host))
694                 return;
695         mmc_host_do_disable(host, 1);
696         mmc_do_release_host(host);
697 }
698
699 /**
700  *      mmc_host_lazy_disable - lazily disable a host.
701  *      @host: mmc host to disable
702  *
703  *      Hosts that support power saving can use the 'enable' and 'disable'
704  *      methods to exit and enter power saving states. For more information
705  *      see comments for struct mmc_host_ops.
706  */
707 int mmc_host_lazy_disable(struct mmc_host *host)
708 {
709         if (!(host->caps & MMC_CAP_DISABLE))
710                 return 0;
711
712         if (host->en_dis_recurs)
713                 return 0;
714
715         if (--host->nesting_cnt)
716                 return 0;
717
718         if (!host->enabled)
719                 return 0;
720
721         if (host->disable_delay) {
722                 mmc_schedule_delayed_work(&host->disable,
723                                 msecs_to_jiffies(host->disable_delay));
724                 return 0;
725         } else
726                 return mmc_host_do_disable(host, 1);
727 }
728 EXPORT_SYMBOL(mmc_host_lazy_disable);
729
730 /**
731  *      mmc_release_host - release a host
732  *      @host: mmc host to release
733  *
734  *      Release a MMC host, allowing others to claim the host
735  *      for their operations.
736  */
737 void mmc_release_host(struct mmc_host *host)
738 {
739         WARN_ON(!host->claimed);
740
741         mmc_host_lazy_disable(host);
742
743         mmc_do_release_host(host);
744 }
745
746 EXPORT_SYMBOL(mmc_release_host);
747
748 /*
749  * Internal function that does the actual ios call to the host driver,
750  * optionally printing some debug output.
751  */
752 static inline void mmc_set_ios(struct mmc_host *host)
753 {
754         struct mmc_ios *ios = &host->ios;
755
756         pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
757                 "width %u timing %u\n",
758                  mmc_hostname(host), ios->clock, ios->bus_mode,
759                  ios->power_mode, ios->chip_select, ios->vdd,
760                  ios->bus_width, ios->timing);
761
762         if (ios->clock > 0)
763                 mmc_set_ungated(host);
764         host->ops->set_ios(host, ios);
765 }
766
767 /*
768  * Control chip select pin on a host.
769  */
770 void mmc_set_chip_select(struct mmc_host *host, int mode)
771 {
772         mmc_host_clk_hold(host);
773         host->ios.chip_select = mode;
774         mmc_set_ios(host);
775         mmc_host_clk_release(host);
776 }
777
778 /*
779  * Sets the host clock to the highest possible frequency that
780  * is below "hz".
781  */
782 static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
783 {
784         WARN_ON(hz < host->f_min);
785
786         if (hz > host->f_max)
787                 hz = host->f_max;
788
789         host->ios.clock = hz;
790         mmc_set_ios(host);
791 }
792
793 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
794 {
795         mmc_host_clk_hold(host);
796         __mmc_set_clock(host, hz);
797         mmc_host_clk_release(host);
798 }
799
800 #ifdef CONFIG_MMC_CLKGATE
801 /*
802  * This gates the clock by setting it to 0 Hz.
803  */
804 void mmc_gate_clock(struct mmc_host *host)
805 {
806         unsigned long flags;
807
808         spin_lock_irqsave(&host->clk_lock, flags);
809         host->clk_old = host->ios.clock;
810         host->ios.clock = 0;
811         host->clk_gated = true;
812         spin_unlock_irqrestore(&host->clk_lock, flags);
813         mmc_set_ios(host);
814 }
815
816 /*
817  * This restores the clock from gating by using the cached
818  * clock value.
819  */
820 void mmc_ungate_clock(struct mmc_host *host)
821 {
822         /*
823          * We should previously have gated the clock, so the clock shall
824          * be 0 here! The clock may however be 0 during initialization,
825          * when some request operations are performed before setting
826          * the frequency. When ungate is requested in that situation
827          * we just ignore the call.
828          */
829         if (host->clk_old) {
830                 BUG_ON(host->ios.clock);
831                 /* This call will also set host->clk_gated to false */
832                 __mmc_set_clock(host, host->clk_old);
833         }
834 }
835
836 void mmc_set_ungated(struct mmc_host *host)
837 {
838         unsigned long flags;
839
840         /*
841          * We've been given a new frequency while the clock is gated,
842          * so make sure we regard this as ungating it.
843          */
844         spin_lock_irqsave(&host->clk_lock, flags);
845         host->clk_gated = false;
846         spin_unlock_irqrestore(&host->clk_lock, flags);
847 }
848
849 #else
850 void mmc_set_ungated(struct mmc_host *host)
851 {
852 }
853 #endif
854
855 /*
856  * Change the bus mode (open drain/push-pull) of a host.
857  */
858 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
859 {
860         mmc_host_clk_hold(host);
861         host->ios.bus_mode = mode;
862         mmc_set_ios(host);
863         mmc_host_clk_release(host);
864 }
865
866 /*
867  * Change data bus width of a host.
868  */
869 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
870 {
871         mmc_host_clk_hold(host);
872         host->ios.bus_width = width;
873         mmc_set_ios(host);
874         mmc_host_clk_release(host);
875 }
876
877 /**
878  * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
879  * @vdd:        voltage (mV)
880  * @low_bits:   prefer low bits in boundary cases
881  *
882  * This function returns the OCR bit number according to the provided @vdd
883  * value. If conversion is not possible a negative errno value returned.
884  *
885  * Depending on the @low_bits flag the function prefers low or high OCR bits
886  * on boundary voltages. For example,
887  * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
888  * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
889  *
890  * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
891  */
892 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
893 {
894         const int max_bit = ilog2(MMC_VDD_35_36);
895         int bit;
896
897         if (vdd < 1650 || vdd > 3600)
898                 return -EINVAL;
899
900         if (vdd >= 1650 && vdd <= 1950)
901                 return ilog2(MMC_VDD_165_195);
902
903         if (low_bits)
904                 vdd -= 1;
905
906         /* Base 2000 mV, step 100 mV, bit's base 8. */
907         bit = (vdd - 2000) / 100 + 8;
908         if (bit > max_bit)
909                 return max_bit;
910         return bit;
911 }
912
913 /**
914  * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
915  * @vdd_min:    minimum voltage value (mV)
916  * @vdd_max:    maximum voltage value (mV)
917  *
918  * This function returns the OCR mask bits according to the provided @vdd_min
919  * and @vdd_max values. If conversion is not possible the function returns 0.
920  *
921  * Notes wrt boundary cases:
922  * This function sets the OCR bits for all boundary voltages, for example
923  * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
924  * MMC_VDD_34_35 mask.
925  */
926 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
927 {
928         u32 mask = 0;
929
930         if (vdd_max < vdd_min)
931                 return 0;
932
933         /* Prefer high bits for the boundary vdd_max values. */
934         vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
935         if (vdd_max < 0)
936                 return 0;
937
938         /* Prefer low bits for the boundary vdd_min values. */
939         vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
940         if (vdd_min < 0)
941                 return 0;
942
943         /* Fill the mask, from max bit to min bit. */
944         while (vdd_max >= vdd_min)
945                 mask |= 1 << vdd_max--;
946
947         return mask;
948 }
949 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
950
951 #ifdef CONFIG_REGULATOR
952
953 /**
954  * mmc_regulator_get_ocrmask - return mask of supported voltages
955  * @supply: regulator to use
956  *
957  * This returns either a negative errno, or a mask of voltages that
958  * can be provided to MMC/SD/SDIO devices using the specified voltage
959  * regulator.  This would normally be called before registering the
960  * MMC host adapter.
961  */
962 int mmc_regulator_get_ocrmask(struct regulator *supply)
963 {
964         int                     result = 0;
965         int                     count;
966         int                     i;
967
968         count = regulator_count_voltages(supply);
969         if (count < 0)
970                 return count;
971
972         for (i = 0; i < count; i++) {
973                 int             vdd_uV;
974                 int             vdd_mV;
975
976                 vdd_uV = regulator_list_voltage(supply, i);
977                 if (vdd_uV <= 0)
978                         continue;
979
980                 vdd_mV = vdd_uV / 1000;
981                 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
982         }
983
984         return result;
985 }
986 EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
987
988 /**
989  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
990  * @mmc: the host to regulate
991  * @supply: regulator to use
992  * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
993  *
994  * Returns zero on success, else negative errno.
995  *
996  * MMC host drivers may use this to enable or disable a regulator using
997  * a particular supply voltage.  This would normally be called from the
998  * set_ios() method.
999  */
1000 int mmc_regulator_set_ocr(struct mmc_host *mmc,
1001                         struct regulator *supply,
1002                         unsigned short vdd_bit)
1003 {
1004         int                     result = 0;
1005         int                     min_uV, max_uV;
1006
1007         if (vdd_bit) {
1008                 int             tmp;
1009                 int             voltage;
1010
1011                 /* REVISIT mmc_vddrange_to_ocrmask() may have set some
1012                  * bits this regulator doesn't quite support ... don't
1013                  * be too picky, most cards and regulators are OK with
1014                  * a 0.1V range goof (it's a small error percentage).
1015                  */
1016                 tmp = vdd_bit - ilog2(MMC_VDD_165_195);
1017                 if (tmp == 0) {
1018                         min_uV = 1650 * 1000;
1019                         max_uV = 1950 * 1000;
1020                 } else {
1021                         min_uV = 1900 * 1000 + tmp * 100 * 1000;
1022                         max_uV = min_uV + 100 * 1000;
1023                 }
1024
1025                 /* avoid needless changes to this voltage; the regulator
1026                  * might not allow this operation
1027                  */
1028                 voltage = regulator_get_voltage(supply);
1029                 if (voltage < 0)
1030                         result = voltage;
1031                 else if (voltage < min_uV || voltage > max_uV)
1032                         result = regulator_set_voltage(supply, min_uV, max_uV);
1033                 else
1034                         result = 0;
1035
1036                 if (result == 0 && !mmc->regulator_enabled) {
1037                         result = regulator_enable(supply);
1038                         if (!result)
1039                                 mmc->regulator_enabled = true;
1040                 }
1041         } else if (mmc->regulator_enabled) {
1042                 result = regulator_disable(supply);
1043                 if (result == 0)
1044                         mmc->regulator_enabled = false;
1045         }
1046
1047         if (result)
1048                 dev_err(mmc_dev(mmc),
1049                         "could not set regulator OCR (%d)\n", result);
1050         return result;
1051 }
1052 EXPORT_SYMBOL(mmc_regulator_set_ocr);
1053
1054 #endif /* CONFIG_REGULATOR */
1055
1056 /*
1057  * Mask off any voltages we don't support and select
1058  * the lowest voltage
1059  */
1060 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
1061 {
1062         int bit;
1063
1064         ocr &= host->ocr_avail;
1065
1066         bit = ffs(ocr);
1067         if (bit) {
1068                 bit -= 1;
1069
1070                 ocr &= 3 << bit;
1071
1072                 mmc_host_clk_hold(host);
1073                 host->ios.vdd = bit;
1074                 mmc_set_ios(host);
1075                 mmc_host_clk_release(host);
1076         } else {
1077                 pr_warning("%s: host doesn't support card's voltages\n",
1078                                 mmc_hostname(host));
1079                 ocr = 0;
1080         }
1081
1082         return ocr;
1083 }
1084
1085 int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11)
1086 {
1087         struct mmc_command cmd = {0};
1088         int err = 0;
1089
1090         BUG_ON(!host);
1091
1092         /*
1093          * Send CMD11 only if the request is to switch the card to
1094          * 1.8V signalling.
1095          */
1096         if ((signal_voltage != MMC_SIGNAL_VOLTAGE_330) && cmd11) {
1097                 cmd.opcode = SD_SWITCH_VOLTAGE;
1098                 cmd.arg = 0;
1099                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1100
1101                 err = mmc_wait_for_cmd(host, &cmd, 0);
1102                 if (err)
1103                         return err;
1104
1105                 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
1106                         return -EIO;
1107         }
1108
1109         host->ios.signal_voltage = signal_voltage;
1110
1111         if (host->ops->start_signal_voltage_switch)
1112                 err = host->ops->start_signal_voltage_switch(host, &host->ios);
1113
1114         return err;
1115 }
1116
1117 /*
1118  * Select timing parameters for host.
1119  */
1120 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
1121 {
1122         mmc_host_clk_hold(host);
1123         host->ios.timing = timing;
1124         mmc_set_ios(host);
1125         mmc_host_clk_release(host);
1126 }
1127
1128 /*
1129  * Select appropriate driver type for host.
1130  */
1131 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
1132 {
1133         mmc_host_clk_hold(host);
1134         host->ios.drv_type = drv_type;
1135         mmc_set_ios(host);
1136         mmc_host_clk_release(host);
1137 }
1138
1139 /*
1140  * Apply power to the MMC stack.  This is a two-stage process.
1141  * First, we enable power to the card without the clock running.
1142  * We then wait a bit for the power to stabilise.  Finally,
1143  * enable the bus drivers and clock to the card.
1144  *
1145  * We must _NOT_ enable the clock prior to power stablising.
1146  *
1147  * If a host does all the power sequencing itself, ignore the
1148  * initial MMC_POWER_UP stage.
1149  */
1150 static void mmc_power_up(struct mmc_host *host)
1151 {
1152         int bit;
1153
1154         mmc_host_clk_hold(host);
1155
1156         /* If ocr is set, we use it */
1157         if (host->ocr)
1158                 bit = ffs(host->ocr) - 1;
1159         else
1160                 bit = fls(host->ocr_avail) - 1;
1161
1162         host->ios.vdd = bit;
1163         if (mmc_host_is_spi(host)) {
1164                 host->ios.chip_select = MMC_CS_HIGH;
1165                 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
1166         } else {
1167                 host->ios.chip_select = MMC_CS_DONTCARE;
1168                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
1169         }
1170         host->ios.power_mode = MMC_POWER_UP;
1171         host->ios.bus_width = MMC_BUS_WIDTH_1;
1172         host->ios.timing = MMC_TIMING_LEGACY;
1173         mmc_set_ios(host);
1174
1175         /*
1176          * This delay should be sufficient to allow the power supply
1177          * to reach the minimum voltage.
1178          */
1179         mmc_delay(10);
1180
1181         host->ios.clock = host->f_init;
1182
1183         host->ios.power_mode = MMC_POWER_ON;
1184         mmc_set_ios(host);
1185
1186         /*
1187          * This delay must be at least 74 clock sizes, or 1 ms, or the
1188          * time required to reach a stable voltage.
1189          */
1190         mmc_delay(10);
1191
1192         mmc_host_clk_release(host);
1193 }
1194
1195 void mmc_power_off(struct mmc_host *host)
1196 {
1197         mmc_host_clk_hold(host);
1198
1199         host->ios.clock = 0;
1200         host->ios.vdd = 0;
1201
1202         /*
1203          * Reset ocr mask to be the highest possible voltage supported for
1204          * this mmc host. This value will be used at next power up.
1205          */
1206         host->ocr = 1 << (fls(host->ocr_avail) - 1);
1207
1208         if (!mmc_host_is_spi(host)) {
1209                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
1210                 host->ios.chip_select = MMC_CS_DONTCARE;
1211         }
1212         host->ios.power_mode = MMC_POWER_OFF;
1213         host->ios.bus_width = MMC_BUS_WIDTH_1;
1214         host->ios.timing = MMC_TIMING_LEGACY;
1215         mmc_set_ios(host);
1216
1217         /*
1218          * Some configurations, such as the 802.11 SDIO card in the OLPC
1219          * XO-1.5, require a short delay after poweroff before the card
1220          * can be successfully turned on again.
1221          */
1222         mmc_delay(1);
1223
1224         mmc_host_clk_release(host);
1225 }
1226
1227 /*
1228  * Cleanup when the last reference to the bus operator is dropped.
1229  */
1230 static void __mmc_release_bus(struct mmc_host *host)
1231 {
1232         BUG_ON(!host);
1233         BUG_ON(host->bus_refs);
1234         BUG_ON(!host->bus_dead);
1235
1236         host->bus_ops = NULL;
1237 }
1238
1239 /*
1240  * Increase reference count of bus operator
1241  */
1242 static inline void mmc_bus_get(struct mmc_host *host)
1243 {
1244         unsigned long flags;
1245
1246         spin_lock_irqsave(&host->lock, flags);
1247         host->bus_refs++;
1248         spin_unlock_irqrestore(&host->lock, flags);
1249 }
1250
1251 /*
1252  * Decrease reference count of bus operator and free it if
1253  * it is the last reference.
1254  */
1255 static inline void mmc_bus_put(struct mmc_host *host)
1256 {
1257         unsigned long flags;
1258
1259         spin_lock_irqsave(&host->lock, flags);
1260         host->bus_refs--;
1261         if ((host->bus_refs == 0) && host->bus_ops)
1262                 __mmc_release_bus(host);
1263         spin_unlock_irqrestore(&host->lock, flags);
1264 }
1265
1266 /*
1267  * Assign a mmc bus handler to a host. Only one bus handler may control a
1268  * host at any given time.
1269  */
1270 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
1271 {
1272         unsigned long flags;
1273
1274         BUG_ON(!host);
1275         BUG_ON(!ops);
1276
1277         WARN_ON(!host->claimed);
1278
1279         spin_lock_irqsave(&host->lock, flags);
1280
1281         BUG_ON(host->bus_ops);
1282         BUG_ON(host->bus_refs);
1283
1284         host->bus_ops = ops;
1285         host->bus_refs = 1;
1286         host->bus_dead = 0;
1287
1288         spin_unlock_irqrestore(&host->lock, flags);
1289 }
1290
1291 /*
1292  * Remove the current bus handler from a host.
1293  */
1294 void mmc_detach_bus(struct mmc_host *host)
1295 {
1296         unsigned long flags;
1297
1298         BUG_ON(!host);
1299
1300         WARN_ON(!host->claimed);
1301         WARN_ON(!host->bus_ops);
1302
1303         spin_lock_irqsave(&host->lock, flags);
1304
1305         host->bus_dead = 1;
1306
1307         spin_unlock_irqrestore(&host->lock, flags);
1308
1309         mmc_bus_put(host);
1310 }
1311
1312 /**
1313  *      mmc_detect_change - process change of state on a MMC socket
1314  *      @host: host which changed state.
1315  *      @delay: optional delay to wait before detection (jiffies)
1316  *
1317  *      MMC drivers should call this when they detect a card has been
1318  *      inserted or removed. The MMC layer will confirm that any
1319  *      present card is still functional, and initialize any newly
1320  *      inserted.
1321  */
1322 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1323 {
1324 #ifdef CONFIG_MMC_DEBUG
1325         unsigned long flags;
1326         spin_lock_irqsave(&host->lock, flags);
1327         WARN_ON(host->removed);
1328         spin_unlock_irqrestore(&host->lock, flags);
1329 #endif
1330
1331         mmc_schedule_delayed_work(&host->detect, delay);
1332 }
1333
1334 EXPORT_SYMBOL(mmc_detect_change);
1335
1336 void mmc_init_erase(struct mmc_card *card)
1337 {
1338         unsigned int sz;
1339
1340         if (is_power_of_2(card->erase_size))
1341                 card->erase_shift = ffs(card->erase_size) - 1;
1342         else
1343                 card->erase_shift = 0;
1344
1345         /*
1346          * It is possible to erase an arbitrarily large area of an SD or MMC
1347          * card.  That is not desirable because it can take a long time
1348          * (minutes) potentially delaying more important I/O, and also the
1349          * timeout calculations become increasingly hugely over-estimated.
1350          * Consequently, 'pref_erase' is defined as a guide to limit erases
1351          * to that size and alignment.
1352          *
1353          * For SD cards that define Allocation Unit size, limit erases to one
1354          * Allocation Unit at a time.  For MMC cards that define High Capacity
1355          * Erase Size, whether it is switched on or not, limit to that size.
1356          * Otherwise just have a stab at a good value.  For modern cards it
1357          * will end up being 4MiB.  Note that if the value is too small, it
1358          * can end up taking longer to erase.
1359          */
1360         if (mmc_card_sd(card) && card->ssr.au) {
1361                 card->pref_erase = card->ssr.au;
1362                 card->erase_shift = ffs(card->ssr.au) - 1;
1363         } else if (card->ext_csd.hc_erase_size) {
1364                 card->pref_erase = card->ext_csd.hc_erase_size;
1365         } else {
1366                 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
1367                 if (sz < 128)
1368                         card->pref_erase = 512 * 1024 / 512;
1369                 else if (sz < 512)
1370                         card->pref_erase = 1024 * 1024 / 512;
1371                 else if (sz < 1024)
1372                         card->pref_erase = 2 * 1024 * 1024 / 512;
1373                 else
1374                         card->pref_erase = 4 * 1024 * 1024 / 512;
1375                 if (card->pref_erase < card->erase_size)
1376                         card->pref_erase = card->erase_size;
1377                 else {
1378                         sz = card->pref_erase % card->erase_size;
1379                         if (sz)
1380                                 card->pref_erase += card->erase_size - sz;
1381                 }
1382         }
1383 }
1384
1385 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
1386                                           unsigned int arg, unsigned int qty)
1387 {
1388         unsigned int erase_timeout;
1389
1390         if (card->ext_csd.erase_group_def & 1) {
1391                 /* High Capacity Erase Group Size uses HC timeouts */
1392                 if (arg == MMC_TRIM_ARG)
1393                         erase_timeout = card->ext_csd.trim_timeout;
1394                 else
1395                         erase_timeout = card->ext_csd.hc_erase_timeout;
1396         } else {
1397                 /* CSD Erase Group Size uses write timeout */
1398                 unsigned int mult = (10 << card->csd.r2w_factor);
1399                 unsigned int timeout_clks = card->csd.tacc_clks * mult;
1400                 unsigned int timeout_us;
1401
1402                 /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */
1403                 if (card->csd.tacc_ns < 1000000)
1404                         timeout_us = (card->csd.tacc_ns * mult) / 1000;
1405                 else
1406                         timeout_us = (card->csd.tacc_ns / 1000) * mult;
1407
1408                 /*
1409                  * ios.clock is only a target.  The real clock rate might be
1410                  * less but not that much less, so fudge it by multiplying by 2.
1411                  */
1412                 timeout_clks <<= 1;
1413                 timeout_us += (timeout_clks * 1000) /
1414                               (mmc_host_clk_rate(card->host) / 1000);
1415
1416                 erase_timeout = timeout_us / 1000;
1417
1418                 /*
1419                  * Theoretically, the calculation could underflow so round up
1420                  * to 1ms in that case.
1421                  */
1422                 if (!erase_timeout)
1423                         erase_timeout = 1;
1424         }
1425
1426         /* Multiplier for secure operations */
1427         if (arg & MMC_SECURE_ARGS) {
1428                 if (arg == MMC_SECURE_ERASE_ARG)
1429                         erase_timeout *= card->ext_csd.sec_erase_mult;
1430                 else
1431                         erase_timeout *= card->ext_csd.sec_trim_mult;
1432         }
1433
1434         erase_timeout *= qty;
1435
1436         /*
1437          * Ensure at least a 1 second timeout for SPI as per
1438          * 'mmc_set_data_timeout()'
1439          */
1440         if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
1441                 erase_timeout = 1000;
1442
1443         return erase_timeout;
1444 }
1445
1446 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
1447                                          unsigned int arg,
1448                                          unsigned int qty)
1449 {
1450         unsigned int erase_timeout;
1451
1452         if (card->ssr.erase_timeout) {
1453                 /* Erase timeout specified in SD Status Register (SSR) */
1454                 erase_timeout = card->ssr.erase_timeout * qty +
1455                                 card->ssr.erase_offset;
1456         } else {
1457                 /*
1458                  * Erase timeout not specified in SD Status Register (SSR) so
1459                  * use 250ms per write block.
1460                  */
1461                 erase_timeout = 250 * qty;
1462         }
1463
1464         /* Must not be less than 1 second */
1465         if (erase_timeout < 1000)
1466                 erase_timeout = 1000;
1467
1468         return erase_timeout;
1469 }
1470
1471 static unsigned int mmc_erase_timeout(struct mmc_card *card,
1472                                       unsigned int arg,
1473                                       unsigned int qty)
1474 {
1475         if (mmc_card_sd(card))
1476                 return mmc_sd_erase_timeout(card, arg, qty);
1477         else
1478                 return mmc_mmc_erase_timeout(card, arg, qty);
1479 }
1480
1481 static int mmc_do_erase(struct mmc_card *card, unsigned int from,
1482                         unsigned int to, unsigned int arg)
1483 {
1484         struct mmc_command cmd = {0};
1485         unsigned int qty = 0;
1486         int err;
1487
1488         /*
1489          * qty is used to calculate the erase timeout which depends on how many
1490          * erase groups (or allocation units in SD terminology) are affected.
1491          * We count erasing part of an erase group as one erase group.
1492          * For SD, the allocation units are always a power of 2.  For MMC, the
1493          * erase group size is almost certainly also power of 2, but it does not
1494          * seem to insist on that in the JEDEC standard, so we fall back to
1495          * division in that case.  SD may not specify an allocation unit size,
1496          * in which case the timeout is based on the number of write blocks.
1497          *
1498          * Note that the timeout for secure trim 2 will only be correct if the
1499          * number of erase groups specified is the same as the total of all
1500          * preceding secure trim 1 commands.  Since the power may have been
1501          * lost since the secure trim 1 commands occurred, it is generally
1502          * impossible to calculate the secure trim 2 timeout correctly.
1503          */
1504         if (card->erase_shift)
1505                 qty += ((to >> card->erase_shift) -
1506                         (from >> card->erase_shift)) + 1;
1507         else if (mmc_card_sd(card))
1508                 qty += to - from + 1;
1509         else
1510                 qty += ((to / card->erase_size) -
1511                         (from / card->erase_size)) + 1;
1512
1513         if (!mmc_card_blockaddr(card)) {
1514                 from <<= 9;
1515                 to <<= 9;
1516         }
1517
1518         if (mmc_card_sd(card))
1519                 cmd.opcode = SD_ERASE_WR_BLK_START;
1520         else
1521                 cmd.opcode = MMC_ERASE_GROUP_START;
1522         cmd.arg = from;
1523         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1524         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1525         if (err) {
1526                 printk(KERN_ERR "mmc_erase: group start error %d, "
1527                        "status %#x\n", err, cmd.resp[0]);
1528                 err = -EINVAL;
1529                 goto out;
1530         }
1531
1532         memset(&cmd, 0, sizeof(struct mmc_command));
1533         if (mmc_card_sd(card))
1534                 cmd.opcode = SD_ERASE_WR_BLK_END;
1535         else
1536                 cmd.opcode = MMC_ERASE_GROUP_END;
1537         cmd.arg = to;
1538         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1539         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1540         if (err) {
1541                 printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n",
1542                        err, cmd.resp[0]);
1543                 err = -EINVAL;
1544                 goto out;
1545         }
1546
1547         memset(&cmd, 0, sizeof(struct mmc_command));
1548         cmd.opcode = MMC_ERASE;
1549         cmd.arg = arg;
1550         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
1551         cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
1552         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1553         if (err) {
1554                 printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
1555                        err, cmd.resp[0]);
1556                 err = -EIO;
1557                 goto out;
1558         }
1559
1560         if (mmc_host_is_spi(card->host))
1561                 goto out;
1562
1563         do {
1564                 memset(&cmd, 0, sizeof(struct mmc_command));
1565                 cmd.opcode = MMC_SEND_STATUS;
1566                 cmd.arg = card->rca << 16;
1567                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1568                 /* Do not retry else we can't see errors */
1569                 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1570                 if (err || (cmd.resp[0] & 0xFDF92000)) {
1571                         printk(KERN_ERR "error %d requesting status %#x\n",
1572                                 err, cmd.resp[0]);
1573                         err = -EIO;
1574                         goto out;
1575                 }
1576         } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
1577                  R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
1578 out:
1579         return err;
1580 }
1581
1582 /**
1583  * mmc_erase - erase sectors.
1584  * @card: card to erase
1585  * @from: first sector to erase
1586  * @nr: number of sectors to erase
1587  * @arg: erase command argument (SD supports only %MMC_ERASE_ARG)
1588  *
1589  * Caller must claim host before calling this function.
1590  */
1591 int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
1592               unsigned int arg)
1593 {
1594         unsigned int rem, to = from + nr;
1595
1596         if (!(card->host->caps & MMC_CAP_ERASE) ||
1597             !(card->csd.cmdclass & CCC_ERASE))
1598                 return -EOPNOTSUPP;
1599
1600         if (!card->erase_size)
1601                 return -EOPNOTSUPP;
1602
1603         if (mmc_card_sd(card) && arg != MMC_ERASE_ARG)
1604                 return -EOPNOTSUPP;
1605
1606         if ((arg & MMC_SECURE_ARGS) &&
1607             !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
1608                 return -EOPNOTSUPP;
1609
1610         if ((arg & MMC_TRIM_ARGS) &&
1611             !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
1612                 return -EOPNOTSUPP;
1613
1614         if (arg == MMC_SECURE_ERASE_ARG) {
1615                 if (from % card->erase_size || nr % card->erase_size)
1616                         return -EINVAL;
1617         }
1618
1619         if (arg == MMC_ERASE_ARG) {
1620                 rem = from % card->erase_size;
1621                 if (rem) {
1622                         rem = card->erase_size - rem;
1623                         from += rem;
1624                         if (nr > rem)
1625                                 nr -= rem;
1626                         else
1627                                 return 0;
1628                 }
1629                 rem = nr % card->erase_size;
1630                 if (rem)
1631                         nr -= rem;
1632         }
1633
1634         if (nr == 0)
1635                 return 0;
1636
1637         to = from + nr;
1638
1639         if (to <= from)
1640                 return -EINVAL;
1641
1642         /* 'from' and 'to' are inclusive */
1643         to -= 1;
1644
1645         return mmc_do_erase(card, from, to, arg);
1646 }
1647 EXPORT_SYMBOL(mmc_erase);
1648
1649 int mmc_can_erase(struct mmc_card *card)
1650 {
1651         if ((card->host->caps & MMC_CAP_ERASE) &&
1652             (card->csd.cmdclass & CCC_ERASE) && card->erase_size)
1653                 return 1;
1654         return 0;
1655 }
1656 EXPORT_SYMBOL(mmc_can_erase);
1657
1658 int mmc_can_trim(struct mmc_card *card)
1659 {
1660         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
1661                 return 1;
1662         return 0;
1663 }
1664 EXPORT_SYMBOL(mmc_can_trim);
1665
1666 int mmc_can_secure_erase_trim(struct mmc_card *card)
1667 {
1668         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)
1669                 return 1;
1670         return 0;
1671 }
1672 EXPORT_SYMBOL(mmc_can_secure_erase_trim);
1673
1674 int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
1675                             unsigned int nr)
1676 {
1677         if (!card->erase_size)
1678                 return 0;
1679         if (from % card->erase_size || nr % card->erase_size)
1680                 return 0;
1681         return 1;
1682 }
1683 EXPORT_SYMBOL(mmc_erase_group_aligned);
1684
1685 static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
1686                                             unsigned int arg)
1687 {
1688         struct mmc_host *host = card->host;
1689         unsigned int max_discard, x, y, qty = 0, max_qty, timeout;
1690         unsigned int last_timeout = 0;
1691
1692         if (card->erase_shift)
1693                 max_qty = UINT_MAX >> card->erase_shift;
1694         else if (mmc_card_sd(card))
1695                 max_qty = UINT_MAX;
1696         else
1697                 max_qty = UINT_MAX / card->erase_size;
1698
1699         /* Find the largest qty with an OK timeout */
1700         do {
1701                 y = 0;
1702                 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
1703                         timeout = mmc_erase_timeout(card, arg, qty + x);
1704                         if (timeout > host->max_discard_to)
1705                                 break;
1706                         if (timeout < last_timeout)
1707                                 break;
1708                         last_timeout = timeout;
1709                         y = x;
1710                 }
1711                 qty += y;
1712         } while (y);
1713
1714         if (!qty)
1715                 return 0;
1716
1717         if (qty == 1)
1718                 return 1;
1719
1720         /* Convert qty to sectors */
1721         if (card->erase_shift)
1722                 max_discard = --qty << card->erase_shift;
1723         else if (mmc_card_sd(card))
1724                 max_discard = qty;
1725         else
1726                 max_discard = --qty * card->erase_size;
1727
1728         return max_discard;
1729 }
1730
1731 unsigned int mmc_calc_max_discard(struct mmc_card *card)
1732 {
1733         struct mmc_host *host = card->host;
1734         unsigned int max_discard, max_trim;
1735
1736         if (!host->max_discard_to)
1737                 return UINT_MAX;
1738
1739         /*
1740          * Without erase_group_def set, MMC erase timeout depends on clock
1741          * frequence which can change.  In that case, the best choice is
1742          * just the preferred erase size.
1743          */
1744         if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
1745                 return card->pref_erase;
1746
1747         max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
1748         if (mmc_can_trim(card)) {
1749                 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
1750                 if (max_trim < max_discard)
1751                         max_discard = max_trim;
1752         } else if (max_discard < card->erase_size) {
1753                 max_discard = 0;
1754         }
1755         pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
1756                  mmc_hostname(host), max_discard, host->max_discard_to);
1757         return max_discard;
1758 }
1759 EXPORT_SYMBOL(mmc_calc_max_discard);
1760
1761 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
1762 {
1763         struct mmc_command cmd = {0};
1764
1765         if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card))
1766                 return 0;
1767
1768         cmd.opcode = MMC_SET_BLOCKLEN;
1769         cmd.arg = blocklen;
1770         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1771         return mmc_wait_for_cmd(card->host, &cmd, 5);
1772 }
1773 EXPORT_SYMBOL(mmc_set_blocklen);
1774
1775 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
1776 {
1777         host->f_init = freq;
1778
1779 #ifdef CONFIG_MMC_DEBUG
1780         pr_info("%s: %s: trying to init card at %u Hz\n",
1781                 mmc_hostname(host), __func__, host->f_init);
1782 #endif
1783         mmc_power_up(host);
1784
1785         /*
1786          * sdio_reset sends CMD52 to reset card.  Since we do not know
1787          * if the card is being re-initialized, just send it.  CMD52
1788          * should be ignored by SD/eMMC cards.
1789          */
1790         sdio_reset(host);
1791         mmc_go_idle(host);
1792
1793         mmc_send_if_cond(host, host->ocr_avail);
1794
1795         /* Order's important: probe SDIO, then SD, then MMC */
1796         if (!mmc_attach_sdio(host))
1797                 return 0;
1798         if (!mmc_attach_sd(host))
1799                 return 0;
1800         if (!mmc_attach_mmc(host))
1801                 return 0;
1802
1803         mmc_power_off(host);
1804         return -EIO;
1805 }
1806
1807 void mmc_rescan(struct work_struct *work)
1808 {
1809         static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
1810         struct mmc_host *host =
1811                 container_of(work, struct mmc_host, detect.work);
1812         int i;
1813
1814         if (host->rescan_disable)
1815                 return;
1816
1817         mmc_bus_get(host);
1818
1819         /*
1820          * if there is a _removable_ card registered, check whether it is
1821          * still present
1822          */
1823         if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
1824             && !(host->caps & MMC_CAP_NONREMOVABLE))
1825                 host->bus_ops->detect(host);
1826
1827         /*
1828          * Let mmc_bus_put() free the bus/bus_ops if we've found that
1829          * the card is no longer present.
1830          */
1831         mmc_bus_put(host);
1832         mmc_bus_get(host);
1833
1834         /* if there still is a card present, stop here */
1835         if (host->bus_ops != NULL) {
1836                 mmc_bus_put(host);
1837                 goto out;
1838         }
1839
1840         /*
1841          * Only we can add a new handler, so it's safe to
1842          * release the lock here.
1843          */
1844         mmc_bus_put(host);
1845
1846         if (host->ops->get_cd && host->ops->get_cd(host) == 0)
1847                 goto out;
1848
1849         mmc_claim_host(host);
1850         for (i = 0; i < ARRAY_SIZE(freqs); i++) {
1851                 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
1852                         break;
1853                 if (freqs[i] <= host->f_min)
1854                         break;
1855         }
1856         mmc_release_host(host);
1857
1858  out:
1859         if (host->caps & MMC_CAP_NEEDS_POLL)
1860                 mmc_schedule_delayed_work(&host->detect, HZ);
1861 }
1862
1863 void mmc_start_host(struct mmc_host *host)
1864 {
1865         mmc_power_off(host);
1866         mmc_detect_change(host, 0);
1867 }
1868
1869 void mmc_stop_host(struct mmc_host *host)
1870 {
1871 #ifdef CONFIG_MMC_DEBUG
1872         unsigned long flags;
1873         spin_lock_irqsave(&host->lock, flags);
1874         host->removed = 1;
1875         spin_unlock_irqrestore(&host->lock, flags);
1876 #endif
1877
1878         if (host->caps & MMC_CAP_DISABLE)
1879                 cancel_delayed_work(&host->disable);
1880         cancel_delayed_work_sync(&host->detect);
1881         mmc_flush_scheduled_work();
1882
1883         /* clear pm flags now and let card drivers set them as needed */
1884         host->pm_flags = 0;
1885
1886         mmc_bus_get(host);
1887         if (host->bus_ops && !host->bus_dead) {
1888                 if (host->bus_ops->remove)
1889                         host->bus_ops->remove(host);
1890
1891                 mmc_claim_host(host);
1892                 mmc_detach_bus(host);
1893                 mmc_power_off(host);
1894                 mmc_release_host(host);
1895                 mmc_bus_put(host);
1896                 return;
1897         }
1898         mmc_bus_put(host);
1899
1900         BUG_ON(host->card);
1901
1902         mmc_power_off(host);
1903 }
1904
1905 int mmc_power_save_host(struct mmc_host *host)
1906 {
1907         int ret = 0;
1908
1909 #ifdef CONFIG_MMC_DEBUG
1910         pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
1911 #endif
1912
1913         mmc_bus_get(host);
1914
1915         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1916                 mmc_bus_put(host);
1917                 return -EINVAL;
1918         }
1919
1920         if (host->bus_ops->power_save)
1921                 ret = host->bus_ops->power_save(host);
1922
1923         mmc_bus_put(host);
1924
1925         mmc_power_off(host);
1926
1927         return ret;
1928 }
1929 EXPORT_SYMBOL(mmc_power_save_host);
1930
1931 int mmc_power_restore_host(struct mmc_host *host)
1932 {
1933         int ret;
1934
1935 #ifdef CONFIG_MMC_DEBUG
1936         pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
1937 #endif
1938
1939         mmc_bus_get(host);
1940
1941         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1942                 mmc_bus_put(host);
1943                 return -EINVAL;
1944         }
1945
1946         mmc_power_up(host);
1947         ret = host->bus_ops->power_restore(host);
1948
1949         mmc_bus_put(host);
1950
1951         return ret;
1952 }
1953 EXPORT_SYMBOL(mmc_power_restore_host);
1954
1955 int mmc_card_awake(struct mmc_host *host)
1956 {
1957         int err = -ENOSYS;
1958
1959         mmc_bus_get(host);
1960
1961         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1962                 err = host->bus_ops->awake(host);
1963
1964         mmc_bus_put(host);
1965
1966         return err;
1967 }
1968 EXPORT_SYMBOL(mmc_card_awake);
1969
1970 int mmc_card_sleep(struct mmc_host *host)
1971 {
1972         int err = -ENOSYS;
1973
1974         mmc_bus_get(host);
1975
1976         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1977                 err = host->bus_ops->sleep(host);
1978
1979         mmc_bus_put(host);
1980
1981         return err;
1982 }
1983 EXPORT_SYMBOL(mmc_card_sleep);
1984
1985 int mmc_card_can_sleep(struct mmc_host *host)
1986 {
1987         struct mmc_card *card = host->card;
1988
1989         if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3)
1990                 return 1;
1991         return 0;
1992 }
1993 EXPORT_SYMBOL(mmc_card_can_sleep);
1994
1995 #ifdef CONFIG_PM
1996
1997 /**
1998  *      mmc_suspend_host - suspend a host
1999  *      @host: mmc host
2000  */
2001 int mmc_suspend_host(struct mmc_host *host)
2002 {
2003         int err = 0;
2004
2005         if (host->caps & MMC_CAP_DISABLE)
2006                 cancel_delayed_work(&host->disable);
2007         cancel_delayed_work(&host->detect);
2008         mmc_flush_scheduled_work();
2009
2010         mmc_bus_get(host);
2011         if (host->bus_ops && !host->bus_dead) {
2012                 if (host->bus_ops->suspend)
2013                         err = host->bus_ops->suspend(host);
2014                 if (err == -ENOSYS || !host->bus_ops->resume) {
2015                         /*
2016                          * We simply "remove" the card in this case.
2017                          * It will be redetected on resume.
2018                          */
2019                         if (host->bus_ops->remove)
2020                                 host->bus_ops->remove(host);
2021                         mmc_claim_host(host);
2022                         mmc_detach_bus(host);
2023                         mmc_power_off(host);
2024                         mmc_release_host(host);
2025                         host->pm_flags = 0;
2026                         err = 0;
2027                 }
2028         }
2029         mmc_bus_put(host);
2030
2031         if (!err && !mmc_card_keep_power(host))
2032                 mmc_power_off(host);
2033
2034         return err;
2035 }
2036
2037 EXPORT_SYMBOL(mmc_suspend_host);
2038
2039 /**
2040  *      mmc_resume_host - resume a previously suspended host
2041  *      @host: mmc host
2042  */
2043 int mmc_resume_host(struct mmc_host *host)
2044 {
2045         int err = 0;
2046
2047         mmc_bus_get(host);
2048         if (host->bus_ops && !host->bus_dead) {
2049                 if (!mmc_card_keep_power(host)) {
2050                         mmc_power_up(host);
2051                         mmc_select_voltage(host, host->ocr);
2052                         /*
2053                          * Tell runtime PM core we just powered up the card,
2054                          * since it still believes the card is powered off.
2055                          * Note that currently runtime PM is only enabled
2056                          * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
2057                          */
2058                         if (mmc_card_sdio(host->card) &&
2059                             (host->caps & MMC_CAP_POWER_OFF_CARD)) {
2060                                 pm_runtime_disable(&host->card->dev);
2061                                 pm_runtime_set_active(&host->card->dev);
2062                                 pm_runtime_enable(&host->card->dev);
2063                         }
2064                 }
2065                 BUG_ON(!host->bus_ops->resume);
2066                 err = host->bus_ops->resume(host);
2067                 if (err) {
2068                         printk(KERN_WARNING "%s: error %d during resume "
2069                                             "(card was removed?)\n",
2070                                             mmc_hostname(host), err);
2071                         err = 0;
2072                 }
2073         }
2074         host->pm_flags &= ~MMC_PM_KEEP_POWER;
2075         mmc_bus_put(host);
2076
2077         return err;
2078 }
2079 EXPORT_SYMBOL(mmc_resume_host);
2080
2081 /* Do the card removal on suspend if card is assumed removeable
2082  * Do that in pm notifier while userspace isn't yet frozen, so we will be able
2083    to sync the card.
2084 */
2085 int mmc_pm_notify(struct notifier_block *notify_block,
2086                                         unsigned long mode, void *unused)
2087 {
2088         struct mmc_host *host = container_of(
2089                 notify_block, struct mmc_host, pm_notify);
2090         unsigned long flags;
2091
2092
2093         switch (mode) {
2094         case PM_HIBERNATION_PREPARE:
2095         case PM_SUSPEND_PREPARE:
2096
2097                 spin_lock_irqsave(&host->lock, flags);
2098                 host->rescan_disable = 1;
2099                 spin_unlock_irqrestore(&host->lock, flags);
2100                 cancel_delayed_work_sync(&host->detect);
2101
2102                 if (!host->bus_ops || host->bus_ops->suspend)
2103                         break;
2104
2105                 mmc_claim_host(host);
2106
2107                 if (host->bus_ops->remove)
2108                         host->bus_ops->remove(host);
2109
2110                 mmc_detach_bus(host);
2111                 mmc_power_off(host);
2112                 mmc_release_host(host);
2113                 host->pm_flags = 0;
2114                 break;
2115
2116         case PM_POST_SUSPEND:
2117         case PM_POST_HIBERNATION:
2118         case PM_POST_RESTORE:
2119
2120                 spin_lock_irqsave(&host->lock, flags);
2121                 host->rescan_disable = 0;
2122                 spin_unlock_irqrestore(&host->lock, flags);
2123                 mmc_detect_change(host, 0);
2124
2125         }
2126
2127         return 0;
2128 }
2129 #endif
2130
2131 static int __init mmc_init(void)
2132 {
2133         int ret;
2134
2135         workqueue = alloc_ordered_workqueue("kmmcd", 0);
2136         if (!workqueue)
2137                 return -ENOMEM;
2138
2139         ret = mmc_register_bus();
2140         if (ret)
2141                 goto destroy_workqueue;
2142
2143         ret = mmc_register_host_class();
2144         if (ret)
2145                 goto unregister_bus;
2146
2147         ret = sdio_register_bus();
2148         if (ret)
2149                 goto unregister_host_class;
2150
2151         return 0;
2152
2153 unregister_host_class:
2154         mmc_unregister_host_class();
2155 unregister_bus:
2156         mmc_unregister_bus();
2157 destroy_workqueue:
2158         destroy_workqueue(workqueue);
2159
2160         return ret;
2161 }
2162
2163 static void __exit mmc_exit(void)
2164 {
2165         sdio_unregister_bus();
2166         mmc_unregister_host_class();
2167         mmc_unregister_bus();
2168         destroy_workqueue(workqueue);
2169 }
2170
2171 subsys_initcall(mmc_init);
2172 module_exit(mmc_exit);
2173
2174 MODULE_LICENSE("GPL");