]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/mmc/core/core.c
mmc: sdhci-spear: Don't set power gpio to 1 on probe
[~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 static 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. Assumes that there are
1293  * no interesting cards left, so the bus is powered down.
1294  */
1295 void mmc_detach_bus(struct mmc_host *host)
1296 {
1297         unsigned long flags;
1298
1299         BUG_ON(!host);
1300
1301         WARN_ON(!host->claimed);
1302         WARN_ON(!host->bus_ops);
1303
1304         spin_lock_irqsave(&host->lock, flags);
1305
1306         host->bus_dead = 1;
1307
1308         spin_unlock_irqrestore(&host->lock, flags);
1309
1310         mmc_power_off(host);
1311
1312         mmc_bus_put(host);
1313 }
1314
1315 /**
1316  *      mmc_detect_change - process change of state on a MMC socket
1317  *      @host: host which changed state.
1318  *      @delay: optional delay to wait before detection (jiffies)
1319  *
1320  *      MMC drivers should call this when they detect a card has been
1321  *      inserted or removed. The MMC layer will confirm that any
1322  *      present card is still functional, and initialize any newly
1323  *      inserted.
1324  */
1325 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1326 {
1327 #ifdef CONFIG_MMC_DEBUG
1328         unsigned long flags;
1329         spin_lock_irqsave(&host->lock, flags);
1330         WARN_ON(host->removed);
1331         spin_unlock_irqrestore(&host->lock, flags);
1332 #endif
1333
1334         mmc_schedule_delayed_work(&host->detect, delay);
1335 }
1336
1337 EXPORT_SYMBOL(mmc_detect_change);
1338
1339 void mmc_init_erase(struct mmc_card *card)
1340 {
1341         unsigned int sz;
1342
1343         if (is_power_of_2(card->erase_size))
1344                 card->erase_shift = ffs(card->erase_size) - 1;
1345         else
1346                 card->erase_shift = 0;
1347
1348         /*
1349          * It is possible to erase an arbitrarily large area of an SD or MMC
1350          * card.  That is not desirable because it can take a long time
1351          * (minutes) potentially delaying more important I/O, and also the
1352          * timeout calculations become increasingly hugely over-estimated.
1353          * Consequently, 'pref_erase' is defined as a guide to limit erases
1354          * to that size and alignment.
1355          *
1356          * For SD cards that define Allocation Unit size, limit erases to one
1357          * Allocation Unit at a time.  For MMC cards that define High Capacity
1358          * Erase Size, whether it is switched on or not, limit to that size.
1359          * Otherwise just have a stab at a good value.  For modern cards it
1360          * will end up being 4MiB.  Note that if the value is too small, it
1361          * can end up taking longer to erase.
1362          */
1363         if (mmc_card_sd(card) && card->ssr.au) {
1364                 card->pref_erase = card->ssr.au;
1365                 card->erase_shift = ffs(card->ssr.au) - 1;
1366         } else if (card->ext_csd.hc_erase_size) {
1367                 card->pref_erase = card->ext_csd.hc_erase_size;
1368         } else {
1369                 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
1370                 if (sz < 128)
1371                         card->pref_erase = 512 * 1024 / 512;
1372                 else if (sz < 512)
1373                         card->pref_erase = 1024 * 1024 / 512;
1374                 else if (sz < 1024)
1375                         card->pref_erase = 2 * 1024 * 1024 / 512;
1376                 else
1377                         card->pref_erase = 4 * 1024 * 1024 / 512;
1378                 if (card->pref_erase < card->erase_size)
1379                         card->pref_erase = card->erase_size;
1380                 else {
1381                         sz = card->pref_erase % card->erase_size;
1382                         if (sz)
1383                                 card->pref_erase += card->erase_size - sz;
1384                 }
1385         }
1386 }
1387
1388 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
1389                                           unsigned int arg, unsigned int qty)
1390 {
1391         unsigned int erase_timeout;
1392
1393         if (card->ext_csd.erase_group_def & 1) {
1394                 /* High Capacity Erase Group Size uses HC timeouts */
1395                 if (arg == MMC_TRIM_ARG)
1396                         erase_timeout = card->ext_csd.trim_timeout;
1397                 else
1398                         erase_timeout = card->ext_csd.hc_erase_timeout;
1399         } else {
1400                 /* CSD Erase Group Size uses write timeout */
1401                 unsigned int mult = (10 << card->csd.r2w_factor);
1402                 unsigned int timeout_clks = card->csd.tacc_clks * mult;
1403                 unsigned int timeout_us;
1404
1405                 /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */
1406                 if (card->csd.tacc_ns < 1000000)
1407                         timeout_us = (card->csd.tacc_ns * mult) / 1000;
1408                 else
1409                         timeout_us = (card->csd.tacc_ns / 1000) * mult;
1410
1411                 /*
1412                  * ios.clock is only a target.  The real clock rate might be
1413                  * less but not that much less, so fudge it by multiplying by 2.
1414                  */
1415                 timeout_clks <<= 1;
1416                 timeout_us += (timeout_clks * 1000) /
1417                               (mmc_host_clk_rate(card->host) / 1000);
1418
1419                 erase_timeout = timeout_us / 1000;
1420
1421                 /*
1422                  * Theoretically, the calculation could underflow so round up
1423                  * to 1ms in that case.
1424                  */
1425                 if (!erase_timeout)
1426                         erase_timeout = 1;
1427         }
1428
1429         /* Multiplier for secure operations */
1430         if (arg & MMC_SECURE_ARGS) {
1431                 if (arg == MMC_SECURE_ERASE_ARG)
1432                         erase_timeout *= card->ext_csd.sec_erase_mult;
1433                 else
1434                         erase_timeout *= card->ext_csd.sec_trim_mult;
1435         }
1436
1437         erase_timeout *= qty;
1438
1439         /*
1440          * Ensure at least a 1 second timeout for SPI as per
1441          * 'mmc_set_data_timeout()'
1442          */
1443         if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
1444                 erase_timeout = 1000;
1445
1446         return erase_timeout;
1447 }
1448
1449 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
1450                                          unsigned int arg,
1451                                          unsigned int qty)
1452 {
1453         unsigned int erase_timeout;
1454
1455         if (card->ssr.erase_timeout) {
1456                 /* Erase timeout specified in SD Status Register (SSR) */
1457                 erase_timeout = card->ssr.erase_timeout * qty +
1458                                 card->ssr.erase_offset;
1459         } else {
1460                 /*
1461                  * Erase timeout not specified in SD Status Register (SSR) so
1462                  * use 250ms per write block.
1463                  */
1464                 erase_timeout = 250 * qty;
1465         }
1466
1467         /* Must not be less than 1 second */
1468         if (erase_timeout < 1000)
1469                 erase_timeout = 1000;
1470
1471         return erase_timeout;
1472 }
1473
1474 static unsigned int mmc_erase_timeout(struct mmc_card *card,
1475                                       unsigned int arg,
1476                                       unsigned int qty)
1477 {
1478         if (mmc_card_sd(card))
1479                 return mmc_sd_erase_timeout(card, arg, qty);
1480         else
1481                 return mmc_mmc_erase_timeout(card, arg, qty);
1482 }
1483
1484 static int mmc_do_erase(struct mmc_card *card, unsigned int from,
1485                         unsigned int to, unsigned int arg)
1486 {
1487         struct mmc_command cmd = {0};
1488         unsigned int qty = 0;
1489         int err;
1490
1491         /*
1492          * qty is used to calculate the erase timeout which depends on how many
1493          * erase groups (or allocation units in SD terminology) are affected.
1494          * We count erasing part of an erase group as one erase group.
1495          * For SD, the allocation units are always a power of 2.  For MMC, the
1496          * erase group size is almost certainly also power of 2, but it does not
1497          * seem to insist on that in the JEDEC standard, so we fall back to
1498          * division in that case.  SD may not specify an allocation unit size,
1499          * in which case the timeout is based on the number of write blocks.
1500          *
1501          * Note that the timeout for secure trim 2 will only be correct if the
1502          * number of erase groups specified is the same as the total of all
1503          * preceding secure trim 1 commands.  Since the power may have been
1504          * lost since the secure trim 1 commands occurred, it is generally
1505          * impossible to calculate the secure trim 2 timeout correctly.
1506          */
1507         if (card->erase_shift)
1508                 qty += ((to >> card->erase_shift) -
1509                         (from >> card->erase_shift)) + 1;
1510         else if (mmc_card_sd(card))
1511                 qty += to - from + 1;
1512         else
1513                 qty += ((to / card->erase_size) -
1514                         (from / card->erase_size)) + 1;
1515
1516         if (!mmc_card_blockaddr(card)) {
1517                 from <<= 9;
1518                 to <<= 9;
1519         }
1520
1521         if (mmc_card_sd(card))
1522                 cmd.opcode = SD_ERASE_WR_BLK_START;
1523         else
1524                 cmd.opcode = MMC_ERASE_GROUP_START;
1525         cmd.arg = from;
1526         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1527         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1528         if (err) {
1529                 printk(KERN_ERR "mmc_erase: group start error %d, "
1530                        "status %#x\n", err, cmd.resp[0]);
1531                 err = -EINVAL;
1532                 goto out;
1533         }
1534
1535         memset(&cmd, 0, sizeof(struct mmc_command));
1536         if (mmc_card_sd(card))
1537                 cmd.opcode = SD_ERASE_WR_BLK_END;
1538         else
1539                 cmd.opcode = MMC_ERASE_GROUP_END;
1540         cmd.arg = to;
1541         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1542         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1543         if (err) {
1544                 printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n",
1545                        err, cmd.resp[0]);
1546                 err = -EINVAL;
1547                 goto out;
1548         }
1549
1550         memset(&cmd, 0, sizeof(struct mmc_command));
1551         cmd.opcode = MMC_ERASE;
1552         cmd.arg = arg;
1553         cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
1554         cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
1555         err = mmc_wait_for_cmd(card->host, &cmd, 0);
1556         if (err) {
1557                 printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
1558                        err, cmd.resp[0]);
1559                 err = -EIO;
1560                 goto out;
1561         }
1562
1563         if (mmc_host_is_spi(card->host))
1564                 goto out;
1565
1566         do {
1567                 memset(&cmd, 0, sizeof(struct mmc_command));
1568                 cmd.opcode = MMC_SEND_STATUS;
1569                 cmd.arg = card->rca << 16;
1570                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1571                 /* Do not retry else we can't see errors */
1572                 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1573                 if (err || (cmd.resp[0] & 0xFDF92000)) {
1574                         printk(KERN_ERR "error %d requesting status %#x\n",
1575                                 err, cmd.resp[0]);
1576                         err = -EIO;
1577                         goto out;
1578                 }
1579         } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
1580                  R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
1581 out:
1582         return err;
1583 }
1584
1585 /**
1586  * mmc_erase - erase sectors.
1587  * @card: card to erase
1588  * @from: first sector to erase
1589  * @nr: number of sectors to erase
1590  * @arg: erase command argument (SD supports only %MMC_ERASE_ARG)
1591  *
1592  * Caller must claim host before calling this function.
1593  */
1594 int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
1595               unsigned int arg)
1596 {
1597         unsigned int rem, to = from + nr;
1598
1599         if (!(card->host->caps & MMC_CAP_ERASE) ||
1600             !(card->csd.cmdclass & CCC_ERASE))
1601                 return -EOPNOTSUPP;
1602
1603         if (!card->erase_size)
1604                 return -EOPNOTSUPP;
1605
1606         if (mmc_card_sd(card) && arg != MMC_ERASE_ARG)
1607                 return -EOPNOTSUPP;
1608
1609         if ((arg & MMC_SECURE_ARGS) &&
1610             !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
1611                 return -EOPNOTSUPP;
1612
1613         if ((arg & MMC_TRIM_ARGS) &&
1614             !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
1615                 return -EOPNOTSUPP;
1616
1617         if (arg == MMC_SECURE_ERASE_ARG) {
1618                 if (from % card->erase_size || nr % card->erase_size)
1619                         return -EINVAL;
1620         }
1621
1622         if (arg == MMC_ERASE_ARG) {
1623                 rem = from % card->erase_size;
1624                 if (rem) {
1625                         rem = card->erase_size - rem;
1626                         from += rem;
1627                         if (nr > rem)
1628                                 nr -= rem;
1629                         else
1630                                 return 0;
1631                 }
1632                 rem = nr % card->erase_size;
1633                 if (rem)
1634                         nr -= rem;
1635         }
1636
1637         if (nr == 0)
1638                 return 0;
1639
1640         to = from + nr;
1641
1642         if (to <= from)
1643                 return -EINVAL;
1644
1645         /* 'from' and 'to' are inclusive */
1646         to -= 1;
1647
1648         return mmc_do_erase(card, from, to, arg);
1649 }
1650 EXPORT_SYMBOL(mmc_erase);
1651
1652 int mmc_can_erase(struct mmc_card *card)
1653 {
1654         if ((card->host->caps & MMC_CAP_ERASE) &&
1655             (card->csd.cmdclass & CCC_ERASE) && card->erase_size)
1656                 return 1;
1657         return 0;
1658 }
1659 EXPORT_SYMBOL(mmc_can_erase);
1660
1661 int mmc_can_trim(struct mmc_card *card)
1662 {
1663         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
1664                 return 1;
1665         return 0;
1666 }
1667 EXPORT_SYMBOL(mmc_can_trim);
1668
1669 int mmc_can_secure_erase_trim(struct mmc_card *card)
1670 {
1671         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)
1672                 return 1;
1673         return 0;
1674 }
1675 EXPORT_SYMBOL(mmc_can_secure_erase_trim);
1676
1677 int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
1678                             unsigned int nr)
1679 {
1680         if (!card->erase_size)
1681                 return 0;
1682         if (from % card->erase_size || nr % card->erase_size)
1683                 return 0;
1684         return 1;
1685 }
1686 EXPORT_SYMBOL(mmc_erase_group_aligned);
1687
1688 static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
1689                                             unsigned int arg)
1690 {
1691         struct mmc_host *host = card->host;
1692         unsigned int max_discard, x, y, qty = 0, max_qty, timeout;
1693         unsigned int last_timeout = 0;
1694
1695         if (card->erase_shift)
1696                 max_qty = UINT_MAX >> card->erase_shift;
1697         else if (mmc_card_sd(card))
1698                 max_qty = UINT_MAX;
1699         else
1700                 max_qty = UINT_MAX / card->erase_size;
1701
1702         /* Find the largest qty with an OK timeout */
1703         do {
1704                 y = 0;
1705                 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
1706                         timeout = mmc_erase_timeout(card, arg, qty + x);
1707                         if (timeout > host->max_discard_to)
1708                                 break;
1709                         if (timeout < last_timeout)
1710                                 break;
1711                         last_timeout = timeout;
1712                         y = x;
1713                 }
1714                 qty += y;
1715         } while (y);
1716
1717         if (!qty)
1718                 return 0;
1719
1720         if (qty == 1)
1721                 return 1;
1722
1723         /* Convert qty to sectors */
1724         if (card->erase_shift)
1725                 max_discard = --qty << card->erase_shift;
1726         else if (mmc_card_sd(card))
1727                 max_discard = qty;
1728         else
1729                 max_discard = --qty * card->erase_size;
1730
1731         return max_discard;
1732 }
1733
1734 unsigned int mmc_calc_max_discard(struct mmc_card *card)
1735 {
1736         struct mmc_host *host = card->host;
1737         unsigned int max_discard, max_trim;
1738
1739         if (!host->max_discard_to)
1740                 return UINT_MAX;
1741
1742         /*
1743          * Without erase_group_def set, MMC erase timeout depends on clock
1744          * frequence which can change.  In that case, the best choice is
1745          * just the preferred erase size.
1746          */
1747         if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
1748                 return card->pref_erase;
1749
1750         max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
1751         if (mmc_can_trim(card)) {
1752                 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
1753                 if (max_trim < max_discard)
1754                         max_discard = max_trim;
1755         } else if (max_discard < card->erase_size) {
1756                 max_discard = 0;
1757         }
1758         pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
1759                  mmc_hostname(host), max_discard, host->max_discard_to);
1760         return max_discard;
1761 }
1762 EXPORT_SYMBOL(mmc_calc_max_discard);
1763
1764 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
1765 {
1766         struct mmc_command cmd = {0};
1767
1768         if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card))
1769                 return 0;
1770
1771         cmd.opcode = MMC_SET_BLOCKLEN;
1772         cmd.arg = blocklen;
1773         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1774         return mmc_wait_for_cmd(card->host, &cmd, 5);
1775 }
1776 EXPORT_SYMBOL(mmc_set_blocklen);
1777
1778 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
1779 {
1780         host->f_init = freq;
1781
1782 #ifdef CONFIG_MMC_DEBUG
1783         pr_info("%s: %s: trying to init card at %u Hz\n",
1784                 mmc_hostname(host), __func__, host->f_init);
1785 #endif
1786         mmc_power_up(host);
1787
1788         /*
1789          * sdio_reset sends CMD52 to reset card.  Since we do not know
1790          * if the card is being re-initialized, just send it.  CMD52
1791          * should be ignored by SD/eMMC cards.
1792          */
1793         sdio_reset(host);
1794         mmc_go_idle(host);
1795
1796         mmc_send_if_cond(host, host->ocr_avail);
1797
1798         /* Order's important: probe SDIO, then SD, then MMC */
1799         if (!mmc_attach_sdio(host))
1800                 return 0;
1801         if (!mmc_attach_sd(host))
1802                 return 0;
1803         if (!mmc_attach_mmc(host))
1804                 return 0;
1805
1806         mmc_power_off(host);
1807         return -EIO;
1808 }
1809
1810 void mmc_rescan(struct work_struct *work)
1811 {
1812         static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
1813         struct mmc_host *host =
1814                 container_of(work, struct mmc_host, detect.work);
1815         int i;
1816
1817         if (host->rescan_disable)
1818                 return;
1819
1820         mmc_bus_get(host);
1821
1822         /*
1823          * if there is a _removable_ card registered, check whether it is
1824          * still present
1825          */
1826         if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
1827             && !(host->caps & MMC_CAP_NONREMOVABLE))
1828                 host->bus_ops->detect(host);
1829
1830         /*
1831          * Let mmc_bus_put() free the bus/bus_ops if we've found that
1832          * the card is no longer present.
1833          */
1834         mmc_bus_put(host);
1835         mmc_bus_get(host);
1836
1837         /* if there still is a card present, stop here */
1838         if (host->bus_ops != NULL) {
1839                 mmc_bus_put(host);
1840                 goto out;
1841         }
1842
1843         /*
1844          * Only we can add a new handler, so it's safe to
1845          * release the lock here.
1846          */
1847         mmc_bus_put(host);
1848
1849         if (host->ops->get_cd && host->ops->get_cd(host) == 0)
1850                 goto out;
1851
1852         mmc_claim_host(host);
1853         for (i = 0; i < ARRAY_SIZE(freqs); i++) {
1854                 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
1855                         break;
1856                 if (freqs[i] <= host->f_min)
1857                         break;
1858         }
1859         mmc_release_host(host);
1860
1861  out:
1862         if (host->caps & MMC_CAP_NEEDS_POLL)
1863                 mmc_schedule_delayed_work(&host->detect, HZ);
1864 }
1865
1866 void mmc_start_host(struct mmc_host *host)
1867 {
1868         mmc_power_off(host);
1869         mmc_detect_change(host, 0);
1870 }
1871
1872 void mmc_stop_host(struct mmc_host *host)
1873 {
1874 #ifdef CONFIG_MMC_DEBUG
1875         unsigned long flags;
1876         spin_lock_irqsave(&host->lock, flags);
1877         host->removed = 1;
1878         spin_unlock_irqrestore(&host->lock, flags);
1879 #endif
1880
1881         if (host->caps & MMC_CAP_DISABLE)
1882                 cancel_delayed_work(&host->disable);
1883         cancel_delayed_work_sync(&host->detect);
1884         mmc_flush_scheduled_work();
1885
1886         /* clear pm flags now and let card drivers set them as needed */
1887         host->pm_flags = 0;
1888
1889         mmc_bus_get(host);
1890         if (host->bus_ops && !host->bus_dead) {
1891                 if (host->bus_ops->remove)
1892                         host->bus_ops->remove(host);
1893
1894                 mmc_claim_host(host);
1895                 mmc_detach_bus(host);
1896                 mmc_release_host(host);
1897                 mmc_bus_put(host);
1898                 return;
1899         }
1900         mmc_bus_put(host);
1901
1902         BUG_ON(host->card);
1903
1904         mmc_power_off(host);
1905 }
1906
1907 int mmc_power_save_host(struct mmc_host *host)
1908 {
1909         int ret = 0;
1910
1911 #ifdef CONFIG_MMC_DEBUG
1912         pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
1913 #endif
1914
1915         mmc_bus_get(host);
1916
1917         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1918                 mmc_bus_put(host);
1919                 return -EINVAL;
1920         }
1921
1922         if (host->bus_ops->power_save)
1923                 ret = host->bus_ops->power_save(host);
1924
1925         mmc_bus_put(host);
1926
1927         mmc_power_off(host);
1928
1929         return ret;
1930 }
1931 EXPORT_SYMBOL(mmc_power_save_host);
1932
1933 int mmc_power_restore_host(struct mmc_host *host)
1934 {
1935         int ret;
1936
1937 #ifdef CONFIG_MMC_DEBUG
1938         pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
1939 #endif
1940
1941         mmc_bus_get(host);
1942
1943         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1944                 mmc_bus_put(host);
1945                 return -EINVAL;
1946         }
1947
1948         mmc_power_up(host);
1949         ret = host->bus_ops->power_restore(host);
1950
1951         mmc_bus_put(host);
1952
1953         return ret;
1954 }
1955 EXPORT_SYMBOL(mmc_power_restore_host);
1956
1957 int mmc_card_awake(struct mmc_host *host)
1958 {
1959         int err = -ENOSYS;
1960
1961         mmc_bus_get(host);
1962
1963         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1964                 err = host->bus_ops->awake(host);
1965
1966         mmc_bus_put(host);
1967
1968         return err;
1969 }
1970 EXPORT_SYMBOL(mmc_card_awake);
1971
1972 int mmc_card_sleep(struct mmc_host *host)
1973 {
1974         int err = -ENOSYS;
1975
1976         mmc_bus_get(host);
1977
1978         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1979                 err = host->bus_ops->sleep(host);
1980
1981         mmc_bus_put(host);
1982
1983         return err;
1984 }
1985 EXPORT_SYMBOL(mmc_card_sleep);
1986
1987 int mmc_card_can_sleep(struct mmc_host *host)
1988 {
1989         struct mmc_card *card = host->card;
1990
1991         if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3)
1992                 return 1;
1993         return 0;
1994 }
1995 EXPORT_SYMBOL(mmc_card_can_sleep);
1996
1997 #ifdef CONFIG_PM
1998
1999 /**
2000  *      mmc_suspend_host - suspend a host
2001  *      @host: mmc host
2002  */
2003 int mmc_suspend_host(struct mmc_host *host)
2004 {
2005         int err = 0;
2006
2007         if (host->caps & MMC_CAP_DISABLE)
2008                 cancel_delayed_work(&host->disable);
2009         cancel_delayed_work(&host->detect);
2010         mmc_flush_scheduled_work();
2011
2012         mmc_bus_get(host);
2013         if (host->bus_ops && !host->bus_dead) {
2014                 if (host->bus_ops->suspend)
2015                         err = host->bus_ops->suspend(host);
2016                 if (err == -ENOSYS || !host->bus_ops->resume) {
2017                         /*
2018                          * We simply "remove" the card in this case.
2019                          * It will be redetected on resume.
2020                          */
2021                         if (host->bus_ops->remove)
2022                                 host->bus_ops->remove(host);
2023                         mmc_claim_host(host);
2024                         mmc_detach_bus(host);
2025                         mmc_release_host(host);
2026                         host->pm_flags = 0;
2027                         err = 0;
2028                 }
2029         }
2030         mmc_bus_put(host);
2031
2032         if (!err && !mmc_card_keep_power(host))
2033                 mmc_power_off(host);
2034
2035         return err;
2036 }
2037
2038 EXPORT_SYMBOL(mmc_suspend_host);
2039
2040 /**
2041  *      mmc_resume_host - resume a previously suspended host
2042  *      @host: mmc host
2043  */
2044 int mmc_resume_host(struct mmc_host *host)
2045 {
2046         int err = 0;
2047
2048         mmc_bus_get(host);
2049         if (host->bus_ops && !host->bus_dead) {
2050                 if (!mmc_card_keep_power(host)) {
2051                         mmc_power_up(host);
2052                         mmc_select_voltage(host, host->ocr);
2053                         /*
2054                          * Tell runtime PM core we just powered up the card,
2055                          * since it still believes the card is powered off.
2056                          * Note that currently runtime PM is only enabled
2057                          * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
2058                          */
2059                         if (mmc_card_sdio(host->card) &&
2060                             (host->caps & MMC_CAP_POWER_OFF_CARD)) {
2061                                 pm_runtime_disable(&host->card->dev);
2062                                 pm_runtime_set_active(&host->card->dev);
2063                                 pm_runtime_enable(&host->card->dev);
2064                         }
2065                 }
2066                 BUG_ON(!host->bus_ops->resume);
2067                 err = host->bus_ops->resume(host);
2068                 if (err) {
2069                         printk(KERN_WARNING "%s: error %d during resume "
2070                                             "(card was removed?)\n",
2071                                             mmc_hostname(host), err);
2072                         err = 0;
2073                 }
2074         }
2075         host->pm_flags &= ~MMC_PM_KEEP_POWER;
2076         mmc_bus_put(host);
2077
2078         return err;
2079 }
2080 EXPORT_SYMBOL(mmc_resume_host);
2081
2082 /* Do the card removal on suspend if card is assumed removeable
2083  * Do that in pm notifier while userspace isn't yet frozen, so we will be able
2084    to sync the card.
2085 */
2086 int mmc_pm_notify(struct notifier_block *notify_block,
2087                                         unsigned long mode, void *unused)
2088 {
2089         struct mmc_host *host = container_of(
2090                 notify_block, struct mmc_host, pm_notify);
2091         unsigned long flags;
2092
2093
2094         switch (mode) {
2095         case PM_HIBERNATION_PREPARE:
2096         case PM_SUSPEND_PREPARE:
2097
2098                 spin_lock_irqsave(&host->lock, flags);
2099                 host->rescan_disable = 1;
2100                 spin_unlock_irqrestore(&host->lock, flags);
2101                 cancel_delayed_work_sync(&host->detect);
2102
2103                 if (!host->bus_ops || host->bus_ops->suspend)
2104                         break;
2105
2106                 mmc_claim_host(host);
2107
2108                 if (host->bus_ops->remove)
2109                         host->bus_ops->remove(host);
2110
2111                 mmc_detach_bus(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");