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