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