mmc: add ability to save power by powering off cards
[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
26 #include <linux/mmc/card.h>
27 #include <linux/mmc/host.h>
28 #include <linux/mmc/mmc.h>
29 #include <linux/mmc/sd.h>
30
31 #include "core.h"
32 #include "bus.h"
33 #include "host.h"
34 #include "sdio_bus.h"
35
36 #include "mmc_ops.h"
37 #include "sd_ops.h"
38 #include "sdio_ops.h"
39
40 static struct workqueue_struct *workqueue;
41
42 /*
43  * Enabling software CRCs on the data blocks can be a significant (30%)
44  * performance cost, and for other reasons may not always be desired.
45  * So we allow it it to be disabled.
46  */
47 int use_spi_crc = 1;
48 module_param(use_spi_crc, bool, 0);
49
50 /*
51  * Internal function. Schedule delayed work in the MMC work queue.
52  */
53 static int mmc_schedule_delayed_work(struct delayed_work *work,
54                                      unsigned long delay)
55 {
56         return queue_delayed_work(workqueue, work, delay);
57 }
58
59 /*
60  * Internal function. Flush all scheduled work from the MMC work queue.
61  */
62 static void mmc_flush_scheduled_work(void)
63 {
64         flush_workqueue(workqueue);
65 }
66
67 /**
68  *      mmc_request_done - finish processing an MMC request
69  *      @host: MMC host which completed request
70  *      @mrq: MMC request which request
71  *
72  *      MMC drivers should call this function when they have completed
73  *      their processing of a request.
74  */
75 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
76 {
77         struct mmc_command *cmd = mrq->cmd;
78         int err = cmd->error;
79
80         if (err && cmd->retries && mmc_host_is_spi(host)) {
81                 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
82                         cmd->retries = 0;
83         }
84
85         if (err && cmd->retries) {
86                 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
87                         mmc_hostname(host), cmd->opcode, err);
88
89                 cmd->retries--;
90                 cmd->error = 0;
91                 host->ops->request(host, mrq);
92         } else {
93                 led_trigger_event(host->led, LED_OFF);
94
95                 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
96                         mmc_hostname(host), cmd->opcode, err,
97                         cmd->resp[0], cmd->resp[1],
98                         cmd->resp[2], cmd->resp[3]);
99
100                 if (mrq->data) {
101                         pr_debug("%s:     %d bytes transferred: %d\n",
102                                 mmc_hostname(host),
103                                 mrq->data->bytes_xfered, mrq->data->error);
104                 }
105
106                 if (mrq->stop) {
107                         pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
108                                 mmc_hostname(host), mrq->stop->opcode,
109                                 mrq->stop->error,
110                                 mrq->stop->resp[0], mrq->stop->resp[1],
111                                 mrq->stop->resp[2], mrq->stop->resp[3]);
112                 }
113
114                 if (mrq->done)
115                         mrq->done(mrq);
116         }
117 }
118
119 EXPORT_SYMBOL(mmc_request_done);
120
121 static void
122 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
123 {
124 #ifdef CONFIG_MMC_DEBUG
125         unsigned int i, sz;
126         struct scatterlist *sg;
127 #endif
128
129         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
130                  mmc_hostname(host), mrq->cmd->opcode,
131                  mrq->cmd->arg, mrq->cmd->flags);
132
133         if (mrq->data) {
134                 pr_debug("%s:     blksz %d blocks %d flags %08x "
135                         "tsac %d ms nsac %d\n",
136                         mmc_hostname(host), mrq->data->blksz,
137                         mrq->data->blocks, mrq->data->flags,
138                         mrq->data->timeout_ns / 1000000,
139                         mrq->data->timeout_clks);
140         }
141
142         if (mrq->stop) {
143                 pr_debug("%s:     CMD%u arg %08x flags %08x\n",
144                          mmc_hostname(host), mrq->stop->opcode,
145                          mrq->stop->arg, mrq->stop->flags);
146         }
147
148         WARN_ON(!host->claimed);
149
150         led_trigger_event(host->led, LED_FULL);
151
152         mrq->cmd->error = 0;
153         mrq->cmd->mrq = mrq;
154         if (mrq->data) {
155                 BUG_ON(mrq->data->blksz > host->max_blk_size);
156                 BUG_ON(mrq->data->blocks > host->max_blk_count);
157                 BUG_ON(mrq->data->blocks * mrq->data->blksz >
158                         host->max_req_size);
159
160 #ifdef CONFIG_MMC_DEBUG
161                 sz = 0;
162                 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
163                         sz += sg->length;
164                 BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
165 #endif
166
167                 mrq->cmd->data = mrq->data;
168                 mrq->data->error = 0;
169                 mrq->data->mrq = mrq;
170                 if (mrq->stop) {
171                         mrq->data->stop = mrq->stop;
172                         mrq->stop->error = 0;
173                         mrq->stop->mrq = mrq;
174                 }
175         }
176         host->ops->request(host, mrq);
177 }
178
179 static void mmc_wait_done(struct mmc_request *mrq)
180 {
181         complete(mrq->done_data);
182 }
183
184 /**
185  *      mmc_wait_for_req - start a request and wait for completion
186  *      @host: MMC host to start command
187  *      @mrq: MMC request to start
188  *
189  *      Start a new MMC custom command request for a host, and wait
190  *      for the command to complete. Does not attempt to parse the
191  *      response.
192  */
193 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
194 {
195         DECLARE_COMPLETION_ONSTACK(complete);
196
197         mrq->done_data = &complete;
198         mrq->done = mmc_wait_done;
199
200         mmc_start_request(host, mrq);
201
202         wait_for_completion(&complete);
203 }
204
205 EXPORT_SYMBOL(mmc_wait_for_req);
206
207 /**
208  *      mmc_wait_for_cmd - start a command and wait for completion
209  *      @host: MMC host to start command
210  *      @cmd: MMC command to start
211  *      @retries: maximum number of retries
212  *
213  *      Start a new MMC command for a host, and wait for the command
214  *      to complete.  Return any error that occurred while the command
215  *      was executing.  Do not attempt to parse the response.
216  */
217 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
218 {
219         struct mmc_request mrq;
220
221         WARN_ON(!host->claimed);
222
223         memset(&mrq, 0, sizeof(struct mmc_request));
224
225         memset(cmd->resp, 0, sizeof(cmd->resp));
226         cmd->retries = retries;
227
228         mrq.cmd = cmd;
229         cmd->data = NULL;
230
231         mmc_wait_for_req(host, &mrq);
232
233         return cmd->error;
234 }
235
236 EXPORT_SYMBOL(mmc_wait_for_cmd);
237
238 /**
239  *      mmc_set_data_timeout - set the timeout for a data command
240  *      @data: data phase for command
241  *      @card: the MMC card associated with the data transfer
242  *
243  *      Computes the data timeout parameters according to the
244  *      correct algorithm given the card type.
245  */
246 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
247 {
248         unsigned int mult;
249
250         /*
251          * SDIO cards only define an upper 1 s limit on access.
252          */
253         if (mmc_card_sdio(card)) {
254                 data->timeout_ns = 1000000000;
255                 data->timeout_clks = 0;
256                 return;
257         }
258
259         /*
260          * SD cards use a 100 multiplier rather than 10
261          */
262         mult = mmc_card_sd(card) ? 100 : 10;
263
264         /*
265          * Scale up the multiplier (and therefore the timeout) by
266          * the r2w factor for writes.
267          */
268         if (data->flags & MMC_DATA_WRITE)
269                 mult <<= card->csd.r2w_factor;
270
271         data->timeout_ns = card->csd.tacc_ns * mult;
272         data->timeout_clks = card->csd.tacc_clks * mult;
273
274         /*
275          * SD cards also have an upper limit on the timeout.
276          */
277         if (mmc_card_sd(card)) {
278                 unsigned int timeout_us, limit_us;
279
280                 timeout_us = data->timeout_ns / 1000;
281                 timeout_us += data->timeout_clks * 1000 /
282                         (card->host->ios.clock / 1000);
283
284                 if (data->flags & MMC_DATA_WRITE)
285                         /*
286                          * The limit is really 250 ms, but that is
287                          * insufficient for some crappy cards.
288                          */
289                         limit_us = 300000;
290                 else
291                         limit_us = 100000;
292
293                 /*
294                  * SDHC cards always use these fixed values.
295                  */
296                 if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
297                         data->timeout_ns = limit_us * 1000;
298                         data->timeout_clks = 0;
299                 }
300         }
301         /*
302          * Some cards need very high timeouts if driven in SPI mode.
303          * The worst observed timeout was 900ms after writing a
304          * continuous stream of data until the internal logic
305          * overflowed.
306          */
307         if (mmc_host_is_spi(card->host)) {
308                 if (data->flags & MMC_DATA_WRITE) {
309                         if (data->timeout_ns < 1000000000)
310                                 data->timeout_ns = 1000000000;  /* 1s */
311                 } else {
312                         if (data->timeout_ns < 100000000)
313                                 data->timeout_ns =  100000000;  /* 100ms */
314                 }
315         }
316 }
317 EXPORT_SYMBOL(mmc_set_data_timeout);
318
319 /**
320  *      mmc_align_data_size - pads a transfer size to a more optimal value
321  *      @card: the MMC card associated with the data transfer
322  *      @sz: original transfer size
323  *
324  *      Pads the original data size with a number of extra bytes in
325  *      order to avoid controller bugs and/or performance hits
326  *      (e.g. some controllers revert to PIO for certain sizes).
327  *
328  *      Returns the improved size, which might be unmodified.
329  *
330  *      Note that this function is only relevant when issuing a
331  *      single scatter gather entry.
332  */
333 unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
334 {
335         /*
336          * FIXME: We don't have a system for the controller to tell
337          * the core about its problems yet, so for now we just 32-bit
338          * align the size.
339          */
340         sz = ((sz + 3) / 4) * 4;
341
342         return sz;
343 }
344 EXPORT_SYMBOL(mmc_align_data_size);
345
346 /**
347  *      mmc_host_enable - enable a host.
348  *      @host: mmc host to enable
349  *
350  *      Hosts that support power saving can use the 'enable' and 'disable'
351  *      methods to exit and enter power saving states. For more information
352  *      see comments for struct mmc_host_ops.
353  */
354 int mmc_host_enable(struct mmc_host *host)
355 {
356         if (!(host->caps & MMC_CAP_DISABLE))
357                 return 0;
358
359         if (host->en_dis_recurs)
360                 return 0;
361
362         if (host->nesting_cnt++)
363                 return 0;
364
365         cancel_delayed_work_sync(&host->disable);
366
367         if (host->enabled)
368                 return 0;
369
370         if (host->ops->enable) {
371                 int err;
372
373                 host->en_dis_recurs = 1;
374                 err = host->ops->enable(host);
375                 host->en_dis_recurs = 0;
376
377                 if (err) {
378                         pr_debug("%s: enable error %d\n",
379                                  mmc_hostname(host), err);
380                         return err;
381                 }
382         }
383         host->enabled = 1;
384         return 0;
385 }
386 EXPORT_SYMBOL(mmc_host_enable);
387
388 static int mmc_host_do_disable(struct mmc_host *host, int lazy)
389 {
390         if (host->ops->disable) {
391                 int err;
392
393                 host->en_dis_recurs = 1;
394                 err = host->ops->disable(host, lazy);
395                 host->en_dis_recurs = 0;
396
397                 if (err < 0) {
398                         pr_debug("%s: disable error %d\n",
399                                  mmc_hostname(host), err);
400                         return err;
401                 }
402                 if (err > 0) {
403                         unsigned long delay = msecs_to_jiffies(err);
404
405                         mmc_schedule_delayed_work(&host->disable, delay);
406                 }
407         }
408         host->enabled = 0;
409         return 0;
410 }
411
412 /**
413  *      mmc_host_disable - disable a host.
414  *      @host: mmc host to disable
415  *
416  *      Hosts that support power saving can use the 'enable' and 'disable'
417  *      methods to exit and enter power saving states. For more information
418  *      see comments for struct mmc_host_ops.
419  */
420 int mmc_host_disable(struct mmc_host *host)
421 {
422         int err;
423
424         if (!(host->caps & MMC_CAP_DISABLE))
425                 return 0;
426
427         if (host->en_dis_recurs)
428                 return 0;
429
430         if (--host->nesting_cnt)
431                 return 0;
432
433         if (!host->enabled)
434                 return 0;
435
436         err = mmc_host_do_disable(host, 0);
437         return err;
438 }
439 EXPORT_SYMBOL(mmc_host_disable);
440
441 /**
442  *      __mmc_claim_host - exclusively claim a host
443  *      @host: mmc host to claim
444  *      @abort: whether or not the operation should be aborted
445  *
446  *      Claim a host for a set of operations.  If @abort is non null and
447  *      dereference a non-zero value then this will return prematurely with
448  *      that non-zero value without acquiring the lock.  Returns zero
449  *      with the lock held otherwise.
450  */
451 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
452 {
453         DECLARE_WAITQUEUE(wait, current);
454         unsigned long flags;
455         int stop;
456
457         might_sleep();
458
459         add_wait_queue(&host->wq, &wait);
460         spin_lock_irqsave(&host->lock, flags);
461         while (1) {
462                 set_current_state(TASK_UNINTERRUPTIBLE);
463                 stop = abort ? atomic_read(abort) : 0;
464                 if (stop || !host->claimed || host->claimer == current)
465                         break;
466                 spin_unlock_irqrestore(&host->lock, flags);
467                 schedule();
468                 spin_lock_irqsave(&host->lock, flags);
469         }
470         set_current_state(TASK_RUNNING);
471         if (!stop) {
472                 host->claimed = 1;
473                 host->claimer = current;
474                 host->claim_cnt += 1;
475         } else
476                 wake_up(&host->wq);
477         spin_unlock_irqrestore(&host->lock, flags);
478         remove_wait_queue(&host->wq, &wait);
479         if (!stop)
480                 mmc_host_enable(host);
481         return stop;
482 }
483
484 EXPORT_SYMBOL(__mmc_claim_host);
485
486 /**
487  *      mmc_try_claim_host - try exclusively to claim a host
488  *      @host: mmc host to claim
489  *
490  *      Returns %1 if the host is claimed, %0 otherwise.
491  */
492 int mmc_try_claim_host(struct mmc_host *host)
493 {
494         int claimed_host = 0;
495         unsigned long flags;
496
497         spin_lock_irqsave(&host->lock, flags);
498         if (!host->claimed || host->claimer == current) {
499                 host->claimed = 1;
500                 host->claimer = current;
501                 host->claim_cnt += 1;
502                 claimed_host = 1;
503         }
504         spin_unlock_irqrestore(&host->lock, flags);
505         return claimed_host;
506 }
507 EXPORT_SYMBOL(mmc_try_claim_host);
508
509 static void mmc_do_release_host(struct mmc_host *host)
510 {
511         unsigned long flags;
512
513         spin_lock_irqsave(&host->lock, flags);
514         if (--host->claim_cnt) {
515                 /* Release for nested claim */
516                 spin_unlock_irqrestore(&host->lock, flags);
517         } else {
518                 host->claimed = 0;
519                 host->claimer = NULL;
520                 spin_unlock_irqrestore(&host->lock, flags);
521                 wake_up(&host->wq);
522         }
523 }
524
525 void mmc_host_deeper_disable(struct work_struct *work)
526 {
527         struct mmc_host *host =
528                 container_of(work, struct mmc_host, disable.work);
529
530         /* If the host is claimed then we do not want to disable it anymore */
531         if (!mmc_try_claim_host(host))
532                 return;
533         mmc_host_do_disable(host, 1);
534         mmc_do_release_host(host);
535 }
536
537 /**
538  *      mmc_host_lazy_disable - lazily disable a host.
539  *      @host: mmc host to disable
540  *
541  *      Hosts that support power saving can use the 'enable' and 'disable'
542  *      methods to exit and enter power saving states. For more information
543  *      see comments for struct mmc_host_ops.
544  */
545 int mmc_host_lazy_disable(struct mmc_host *host)
546 {
547         if (!(host->caps & MMC_CAP_DISABLE))
548                 return 0;
549
550         if (host->en_dis_recurs)
551                 return 0;
552
553         if (--host->nesting_cnt)
554                 return 0;
555
556         if (!host->enabled)
557                 return 0;
558
559         if (host->disable_delay) {
560                 mmc_schedule_delayed_work(&host->disable,
561                                 msecs_to_jiffies(host->disable_delay));
562                 return 0;
563         } else
564                 return mmc_host_do_disable(host, 1);
565 }
566 EXPORT_SYMBOL(mmc_host_lazy_disable);
567
568 /**
569  *      mmc_release_host - release a host
570  *      @host: mmc host to release
571  *
572  *      Release a MMC host, allowing others to claim the host
573  *      for their operations.
574  */
575 void mmc_release_host(struct mmc_host *host)
576 {
577         WARN_ON(!host->claimed);
578
579         mmc_host_lazy_disable(host);
580
581         mmc_do_release_host(host);
582 }
583
584 EXPORT_SYMBOL(mmc_release_host);
585
586 /*
587  * Internal function that does the actual ios call to the host driver,
588  * optionally printing some debug output.
589  */
590 static inline void mmc_set_ios(struct mmc_host *host)
591 {
592         struct mmc_ios *ios = &host->ios;
593
594         pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
595                 "width %u timing %u\n",
596                  mmc_hostname(host), ios->clock, ios->bus_mode,
597                  ios->power_mode, ios->chip_select, ios->vdd,
598                  ios->bus_width, ios->timing);
599
600         host->ops->set_ios(host, ios);
601 }
602
603 /*
604  * Control chip select pin on a host.
605  */
606 void mmc_set_chip_select(struct mmc_host *host, int mode)
607 {
608         host->ios.chip_select = mode;
609         mmc_set_ios(host);
610 }
611
612 /*
613  * Sets the host clock to the highest possible frequency that
614  * is below "hz".
615  */
616 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
617 {
618         WARN_ON(hz < host->f_min);
619
620         if (hz > host->f_max)
621                 hz = host->f_max;
622
623         host->ios.clock = hz;
624         mmc_set_ios(host);
625 }
626
627 /*
628  * Change the bus mode (open drain/push-pull) of a host.
629  */
630 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
631 {
632         host->ios.bus_mode = mode;
633         mmc_set_ios(host);
634 }
635
636 /*
637  * Change data bus width of a host.
638  */
639 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
640 {
641         host->ios.bus_width = width;
642         mmc_set_ios(host);
643 }
644
645 /**
646  * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
647  * @vdd:        voltage (mV)
648  * @low_bits:   prefer low bits in boundary cases
649  *
650  * This function returns the OCR bit number according to the provided @vdd
651  * value. If conversion is not possible a negative errno value returned.
652  *
653  * Depending on the @low_bits flag the function prefers low or high OCR bits
654  * on boundary voltages. For example,
655  * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
656  * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
657  *
658  * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
659  */
660 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
661 {
662         const int max_bit = ilog2(MMC_VDD_35_36);
663         int bit;
664
665         if (vdd < 1650 || vdd > 3600)
666                 return -EINVAL;
667
668         if (vdd >= 1650 && vdd <= 1950)
669                 return ilog2(MMC_VDD_165_195);
670
671         if (low_bits)
672                 vdd -= 1;
673
674         /* Base 2000 mV, step 100 mV, bit's base 8. */
675         bit = (vdd - 2000) / 100 + 8;
676         if (bit > max_bit)
677                 return max_bit;
678         return bit;
679 }
680
681 /**
682  * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
683  * @vdd_min:    minimum voltage value (mV)
684  * @vdd_max:    maximum voltage value (mV)
685  *
686  * This function returns the OCR mask bits according to the provided @vdd_min
687  * and @vdd_max values. If conversion is not possible the function returns 0.
688  *
689  * Notes wrt boundary cases:
690  * This function sets the OCR bits for all boundary voltages, for example
691  * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
692  * MMC_VDD_34_35 mask.
693  */
694 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
695 {
696         u32 mask = 0;
697
698         if (vdd_max < vdd_min)
699                 return 0;
700
701         /* Prefer high bits for the boundary vdd_max values. */
702         vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
703         if (vdd_max < 0)
704                 return 0;
705
706         /* Prefer low bits for the boundary vdd_min values. */
707         vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
708         if (vdd_min < 0)
709                 return 0;
710
711         /* Fill the mask, from max bit to min bit. */
712         while (vdd_max >= vdd_min)
713                 mask |= 1 << vdd_max--;
714
715         return mask;
716 }
717 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
718
719 #ifdef CONFIG_REGULATOR
720
721 /**
722  * mmc_regulator_get_ocrmask - return mask of supported voltages
723  * @supply: regulator to use
724  *
725  * This returns either a negative errno, or a mask of voltages that
726  * can be provided to MMC/SD/SDIO devices using the specified voltage
727  * regulator.  This would normally be called before registering the
728  * MMC host adapter.
729  */
730 int mmc_regulator_get_ocrmask(struct regulator *supply)
731 {
732         int                     result = 0;
733         int                     count;
734         int                     i;
735
736         count = regulator_count_voltages(supply);
737         if (count < 0)
738                 return count;
739
740         for (i = 0; i < count; i++) {
741                 int             vdd_uV;
742                 int             vdd_mV;
743
744                 vdd_uV = regulator_list_voltage(supply, i);
745                 if (vdd_uV <= 0)
746                         continue;
747
748                 vdd_mV = vdd_uV / 1000;
749                 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
750         }
751
752         return result;
753 }
754 EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
755
756 /**
757  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
758  * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
759  * @supply: regulator to use
760  *
761  * Returns zero on success, else negative errno.
762  *
763  * MMC host drivers may use this to enable or disable a regulator using
764  * a particular supply voltage.  This would normally be called from the
765  * set_ios() method.
766  */
767 int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
768 {
769         int                     result = 0;
770         int                     min_uV, max_uV;
771         int                     enabled;
772
773         enabled = regulator_is_enabled(supply);
774         if (enabled < 0)
775                 return enabled;
776
777         if (vdd_bit) {
778                 int             tmp;
779                 int             voltage;
780
781                 /* REVISIT mmc_vddrange_to_ocrmask() may have set some
782                  * bits this regulator doesn't quite support ... don't
783                  * be too picky, most cards and regulators are OK with
784                  * a 0.1V range goof (it's a small error percentage).
785                  */
786                 tmp = vdd_bit - ilog2(MMC_VDD_165_195);
787                 if (tmp == 0) {
788                         min_uV = 1650 * 1000;
789                         max_uV = 1950 * 1000;
790                 } else {
791                         min_uV = 1900 * 1000 + tmp * 100 * 1000;
792                         max_uV = min_uV + 100 * 1000;
793                 }
794
795                 /* avoid needless changes to this voltage; the regulator
796                  * might not allow this operation
797                  */
798                 voltage = regulator_get_voltage(supply);
799                 if (voltage < 0)
800                         result = voltage;
801                 else if (voltage < min_uV || voltage > max_uV)
802                         result = regulator_set_voltage(supply, min_uV, max_uV);
803                 else
804                         result = 0;
805
806                 if (result == 0 && !enabled)
807                         result = regulator_enable(supply);
808         } else if (enabled) {
809                 result = regulator_disable(supply);
810         }
811
812         return result;
813 }
814 EXPORT_SYMBOL(mmc_regulator_set_ocr);
815
816 #endif
817
818 /*
819  * Mask off any voltages we don't support and select
820  * the lowest voltage
821  */
822 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
823 {
824         int bit;
825
826         ocr &= host->ocr_avail;
827
828         bit = ffs(ocr);
829         if (bit) {
830                 bit -= 1;
831
832                 ocr &= 3 << bit;
833
834                 host->ios.vdd = bit;
835                 mmc_set_ios(host);
836         } else {
837                 pr_warning("%s: host doesn't support card's voltages\n",
838                                 mmc_hostname(host));
839                 ocr = 0;
840         }
841
842         return ocr;
843 }
844
845 /*
846  * Select timing parameters for host.
847  */
848 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
849 {
850         host->ios.timing = timing;
851         mmc_set_ios(host);
852 }
853
854 /*
855  * Apply power to the MMC stack.  This is a two-stage process.
856  * First, we enable power to the card without the clock running.
857  * We then wait a bit for the power to stabilise.  Finally,
858  * enable the bus drivers and clock to the card.
859  *
860  * We must _NOT_ enable the clock prior to power stablising.
861  *
862  * If a host does all the power sequencing itself, ignore the
863  * initial MMC_POWER_UP stage.
864  */
865 static void mmc_power_up(struct mmc_host *host)
866 {
867         int bit;
868
869         /* If ocr is set, we use it */
870         if (host->ocr)
871                 bit = ffs(host->ocr) - 1;
872         else
873                 bit = fls(host->ocr_avail) - 1;
874
875         host->ios.vdd = bit;
876         if (mmc_host_is_spi(host)) {
877                 host->ios.chip_select = MMC_CS_HIGH;
878                 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
879         } else {
880                 host->ios.chip_select = MMC_CS_DONTCARE;
881                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
882         }
883         host->ios.power_mode = MMC_POWER_UP;
884         host->ios.bus_width = MMC_BUS_WIDTH_1;
885         host->ios.timing = MMC_TIMING_LEGACY;
886         mmc_set_ios(host);
887
888         /*
889          * This delay should be sufficient to allow the power supply
890          * to reach the minimum voltage.
891          */
892         mmc_delay(10);
893
894         if (host->f_min > 400000) {
895                 pr_warning("%s: Minimum clock frequency too high for "
896                                 "identification mode\n", mmc_hostname(host));
897                 host->ios.clock = host->f_min;
898         } else
899                 host->ios.clock = 400000;
900
901         host->ios.power_mode = MMC_POWER_ON;
902         mmc_set_ios(host);
903
904         /*
905          * This delay must be at least 74 clock sizes, or 1 ms, or the
906          * time required to reach a stable voltage.
907          */
908         mmc_delay(10);
909 }
910
911 static void mmc_power_off(struct mmc_host *host)
912 {
913         host->ios.clock = 0;
914         host->ios.vdd = 0;
915         if (!mmc_host_is_spi(host)) {
916                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
917                 host->ios.chip_select = MMC_CS_DONTCARE;
918         }
919         host->ios.power_mode = MMC_POWER_OFF;
920         host->ios.bus_width = MMC_BUS_WIDTH_1;
921         host->ios.timing = MMC_TIMING_LEGACY;
922         mmc_set_ios(host);
923 }
924
925 /*
926  * Cleanup when the last reference to the bus operator is dropped.
927  */
928 static void __mmc_release_bus(struct mmc_host *host)
929 {
930         BUG_ON(!host);
931         BUG_ON(host->bus_refs);
932         BUG_ON(!host->bus_dead);
933
934         host->bus_ops = NULL;
935 }
936
937 /*
938  * Increase reference count of bus operator
939  */
940 static inline void mmc_bus_get(struct mmc_host *host)
941 {
942         unsigned long flags;
943
944         spin_lock_irqsave(&host->lock, flags);
945         host->bus_refs++;
946         spin_unlock_irqrestore(&host->lock, flags);
947 }
948
949 /*
950  * Decrease reference count of bus operator and free it if
951  * it is the last reference.
952  */
953 static inline void mmc_bus_put(struct mmc_host *host)
954 {
955         unsigned long flags;
956
957         spin_lock_irqsave(&host->lock, flags);
958         host->bus_refs--;
959         if ((host->bus_refs == 0) && host->bus_ops)
960                 __mmc_release_bus(host);
961         spin_unlock_irqrestore(&host->lock, flags);
962 }
963
964 /*
965  * Assign a mmc bus handler to a host. Only one bus handler may control a
966  * host at any given time.
967  */
968 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
969 {
970         unsigned long flags;
971
972         BUG_ON(!host);
973         BUG_ON(!ops);
974
975         WARN_ON(!host->claimed);
976
977         spin_lock_irqsave(&host->lock, flags);
978
979         BUG_ON(host->bus_ops);
980         BUG_ON(host->bus_refs);
981
982         host->bus_ops = ops;
983         host->bus_refs = 1;
984         host->bus_dead = 0;
985
986         spin_unlock_irqrestore(&host->lock, flags);
987 }
988
989 /*
990  * Remove the current bus handler from a host. Assumes that there are
991  * no interesting cards left, so the bus is powered down.
992  */
993 void mmc_detach_bus(struct mmc_host *host)
994 {
995         unsigned long flags;
996
997         BUG_ON(!host);
998
999         WARN_ON(!host->claimed);
1000         WARN_ON(!host->bus_ops);
1001
1002         spin_lock_irqsave(&host->lock, flags);
1003
1004         host->bus_dead = 1;
1005
1006         spin_unlock_irqrestore(&host->lock, flags);
1007
1008         mmc_power_off(host);
1009
1010         mmc_bus_put(host);
1011 }
1012
1013 /**
1014  *      mmc_detect_change - process change of state on a MMC socket
1015  *      @host: host which changed state.
1016  *      @delay: optional delay to wait before detection (jiffies)
1017  *
1018  *      MMC drivers should call this when they detect a card has been
1019  *      inserted or removed. The MMC layer will confirm that any
1020  *      present card is still functional, and initialize any newly
1021  *      inserted.
1022  */
1023 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1024 {
1025 #ifdef CONFIG_MMC_DEBUG
1026         unsigned long flags;
1027         spin_lock_irqsave(&host->lock, flags);
1028         WARN_ON(host->removed);
1029         spin_unlock_irqrestore(&host->lock, flags);
1030 #endif
1031
1032         mmc_schedule_delayed_work(&host->detect, delay);
1033 }
1034
1035 EXPORT_SYMBOL(mmc_detect_change);
1036
1037
1038 void mmc_rescan(struct work_struct *work)
1039 {
1040         struct mmc_host *host =
1041                 container_of(work, struct mmc_host, detect.work);
1042         u32 ocr;
1043         int err;
1044
1045         mmc_bus_get(host);
1046
1047         /* if there is a card registered, check whether it is still present */
1048         if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)
1049                 host->bus_ops->detect(host);
1050
1051         mmc_bus_put(host);
1052
1053
1054         mmc_bus_get(host);
1055
1056         /* if there still is a card present, stop here */
1057         if (host->bus_ops != NULL) {
1058                 mmc_bus_put(host);
1059                 goto out;
1060         }
1061
1062         /* detect a newly inserted card */
1063
1064         /*
1065          * Only we can add a new handler, so it's safe to
1066          * release the lock here.
1067          */
1068         mmc_bus_put(host);
1069
1070         if (host->ops->get_cd && host->ops->get_cd(host) == 0)
1071                 goto out;
1072
1073         mmc_claim_host(host);
1074
1075         mmc_power_up(host);
1076         mmc_go_idle(host);
1077
1078         mmc_send_if_cond(host, host->ocr_avail);
1079
1080         /*
1081          * First we search for SDIO...
1082          */
1083         err = mmc_send_io_op_cond(host, 0, &ocr);
1084         if (!err) {
1085                 if (mmc_attach_sdio(host, ocr))
1086                         mmc_power_off(host);
1087                 goto out;
1088         }
1089
1090         /*
1091          * ...then normal SD...
1092          */
1093         err = mmc_send_app_op_cond(host, 0, &ocr);
1094         if (!err) {
1095                 if (mmc_attach_sd(host, ocr))
1096                         mmc_power_off(host);
1097                 goto out;
1098         }
1099
1100         /*
1101          * ...and finally MMC.
1102          */
1103         err = mmc_send_op_cond(host, 0, &ocr);
1104         if (!err) {
1105                 if (mmc_attach_mmc(host, ocr))
1106                         mmc_power_off(host);
1107                 goto out;
1108         }
1109
1110         mmc_release_host(host);
1111         mmc_power_off(host);
1112
1113 out:
1114         if (host->caps & MMC_CAP_NEEDS_POLL)
1115                 mmc_schedule_delayed_work(&host->detect, HZ);
1116 }
1117
1118 void mmc_start_host(struct mmc_host *host)
1119 {
1120         mmc_power_off(host);
1121         mmc_detect_change(host, 0);
1122 }
1123
1124 void mmc_stop_host(struct mmc_host *host)
1125 {
1126 #ifdef CONFIG_MMC_DEBUG
1127         unsigned long flags;
1128         spin_lock_irqsave(&host->lock, flags);
1129         host->removed = 1;
1130         spin_unlock_irqrestore(&host->lock, flags);
1131 #endif
1132
1133         if (host->caps & MMC_CAP_DISABLE)
1134                 cancel_delayed_work(&host->disable);
1135         cancel_delayed_work(&host->detect);
1136         mmc_flush_scheduled_work();
1137
1138         mmc_bus_get(host);
1139         if (host->bus_ops && !host->bus_dead) {
1140                 if (host->bus_ops->remove)
1141                         host->bus_ops->remove(host);
1142
1143                 mmc_claim_host(host);
1144                 mmc_detach_bus(host);
1145                 mmc_release_host(host);
1146         }
1147         mmc_bus_put(host);
1148
1149         BUG_ON(host->card);
1150
1151         mmc_power_off(host);
1152 }
1153
1154 void mmc_power_save_host(struct mmc_host *host)
1155 {
1156         mmc_bus_get(host);
1157
1158         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1159                 mmc_bus_put(host);
1160                 return;
1161         }
1162
1163         if (host->bus_ops->power_save)
1164                 host->bus_ops->power_save(host);
1165
1166         mmc_bus_put(host);
1167
1168         mmc_power_off(host);
1169 }
1170 EXPORT_SYMBOL(mmc_power_save_host);
1171
1172 void mmc_power_restore_host(struct mmc_host *host)
1173 {
1174         mmc_bus_get(host);
1175
1176         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1177                 mmc_bus_put(host);
1178                 return;
1179         }
1180
1181         mmc_power_up(host);
1182         host->bus_ops->power_restore(host);
1183
1184         mmc_bus_put(host);
1185 }
1186 EXPORT_SYMBOL(mmc_power_restore_host);
1187
1188 #ifdef CONFIG_PM
1189
1190 /**
1191  *      mmc_suspend_host - suspend a host
1192  *      @host: mmc host
1193  *      @state: suspend mode (PM_SUSPEND_xxx)
1194  */
1195 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
1196 {
1197         if (host->caps & MMC_CAP_DISABLE)
1198                 cancel_delayed_work(&host->disable);
1199         cancel_delayed_work(&host->detect);
1200         mmc_flush_scheduled_work();
1201
1202         mmc_bus_get(host);
1203         if (host->bus_ops && !host->bus_dead) {
1204                 if (host->bus_ops->suspend)
1205                         host->bus_ops->suspend(host);
1206                 if (!host->bus_ops->resume) {
1207                         if (host->bus_ops->remove)
1208                                 host->bus_ops->remove(host);
1209
1210                         mmc_claim_host(host);
1211                         mmc_detach_bus(host);
1212                         mmc_release_host(host);
1213                 }
1214         }
1215         mmc_bus_put(host);
1216
1217         mmc_power_off(host);
1218
1219         return 0;
1220 }
1221
1222 EXPORT_SYMBOL(mmc_suspend_host);
1223
1224 /**
1225  *      mmc_resume_host - resume a previously suspended host
1226  *      @host: mmc host
1227  */
1228 int mmc_resume_host(struct mmc_host *host)
1229 {
1230         mmc_bus_get(host);
1231         if (host->bus_ops && !host->bus_dead) {
1232                 mmc_power_up(host);
1233                 mmc_select_voltage(host, host->ocr);
1234                 BUG_ON(!host->bus_ops->resume);
1235                 host->bus_ops->resume(host);
1236         }
1237         mmc_bus_put(host);
1238
1239         /*
1240          * We add a slight delay here so that resume can progress
1241          * in parallel.
1242          */
1243         mmc_detect_change(host, 1);
1244
1245         return 0;
1246 }
1247
1248 EXPORT_SYMBOL(mmc_resume_host);
1249
1250 #endif
1251
1252 static int __init mmc_init(void)
1253 {
1254         int ret;
1255
1256         workqueue = create_singlethread_workqueue("kmmcd");
1257         if (!workqueue)
1258                 return -ENOMEM;
1259
1260         ret = mmc_register_bus();
1261         if (ret)
1262                 goto destroy_workqueue;
1263
1264         ret = mmc_register_host_class();
1265         if (ret)
1266                 goto unregister_bus;
1267
1268         ret = sdio_register_bus();
1269         if (ret)
1270                 goto unregister_host_class;
1271
1272         return 0;
1273
1274 unregister_host_class:
1275         mmc_unregister_host_class();
1276 unregister_bus:
1277         mmc_unregister_bus();
1278 destroy_workqueue:
1279         destroy_workqueue(workqueue);
1280
1281         return ret;
1282 }
1283
1284 static void __exit mmc_exit(void)
1285 {
1286         sdio_unregister_bus();
1287         mmc_unregister_host_class();
1288         mmc_unregister_bus();
1289         destroy_workqueue(workqueue);
1290 }
1291
1292 subsys_initcall(mmc_init);
1293 module_exit(mmc_exit);
1294
1295 MODULE_LICENSE("GPL");