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