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