Merge master.kernel.org:/pub/scm/linux/kernel/git/bart/ide-2.6
[linux-2.6] / 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-2007 Pierre Ossman, All Rights Reserved.
7  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/completion.h>
17 #include <linux/device.h>
18 #include <linux/delay.h>
19 #include <linux/pagemap.h>
20 #include <linux/err.h>
21 #include <asm/scatterlist.h>
22 #include <linux/scatterlist.h>
23
24 #include <linux/mmc/card.h>
25 #include <linux/mmc/host.h>
26 #include <linux/mmc/mmc.h>
27 #include <linux/mmc/sd.h>
28
29 #include "core.h"
30 #include "sysfs.h"
31
32 #include "mmc_ops.h"
33 #include "sd_ops.h"
34
35 extern int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
36 extern int mmc_attach_sd(struct mmc_host *host, u32 ocr);
37
38 /**
39  *      mmc_request_done - finish processing an MMC request
40  *      @host: MMC host which completed request
41  *      @mrq: MMC request which request
42  *
43  *      MMC drivers should call this function when they have completed
44  *      their processing of a request.
45  */
46 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
47 {
48         struct mmc_command *cmd = mrq->cmd;
49         int err = cmd->error;
50
51         pr_debug("%s: req done (CMD%u): %d/%d/%d: %08x %08x %08x %08x\n",
52                  mmc_hostname(host), cmd->opcode, err,
53                  mrq->data ? mrq->data->error : 0,
54                  mrq->stop ? mrq->stop->error : 0,
55                  cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
56
57         if (err && cmd->retries) {
58                 cmd->retries--;
59                 cmd->error = 0;
60                 host->ops->request(host, mrq);
61         } else if (mrq->done) {
62                 mrq->done(mrq);
63         }
64 }
65
66 EXPORT_SYMBOL(mmc_request_done);
67
68 /**
69  *      mmc_start_request - start a command on a host
70  *      @host: MMC host to start command on
71  *      @mrq: MMC request to start
72  *
73  *      Queue a command on the specified host.  We expect the
74  *      caller to be holding the host lock with interrupts disabled.
75  */
76 void
77 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
78 {
79 #ifdef CONFIG_MMC_DEBUG
80         unsigned int i, sz;
81 #endif
82
83         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
84                  mmc_hostname(host), mrq->cmd->opcode,
85                  mrq->cmd->arg, mrq->cmd->flags);
86
87         WARN_ON(!host->claimed);
88
89         mrq->cmd->error = 0;
90         mrq->cmd->mrq = mrq;
91         if (mrq->data) {
92                 BUG_ON(mrq->data->blksz > host->max_blk_size);
93                 BUG_ON(mrq->data->blocks > host->max_blk_count);
94                 BUG_ON(mrq->data->blocks * mrq->data->blksz >
95                         host->max_req_size);
96
97 #ifdef CONFIG_MMC_DEBUG
98                 sz = 0;
99                 for (i = 0;i < mrq->data->sg_len;i++)
100                         sz += mrq->data->sg[i].length;
101                 BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
102 #endif
103
104                 mrq->cmd->data = mrq->data;
105                 mrq->data->error = 0;
106                 mrq->data->mrq = mrq;
107                 if (mrq->stop) {
108                         mrq->data->stop = mrq->stop;
109                         mrq->stop->error = 0;
110                         mrq->stop->mrq = mrq;
111                 }
112         }
113         host->ops->request(host, mrq);
114 }
115
116 EXPORT_SYMBOL(mmc_start_request);
117
118 static void mmc_wait_done(struct mmc_request *mrq)
119 {
120         complete(mrq->done_data);
121 }
122
123 int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
124 {
125         DECLARE_COMPLETION_ONSTACK(complete);
126
127         mrq->done_data = &complete;
128         mrq->done = mmc_wait_done;
129
130         mmc_start_request(host, mrq);
131
132         wait_for_completion(&complete);
133
134         return 0;
135 }
136
137 EXPORT_SYMBOL(mmc_wait_for_req);
138
139 /**
140  *      mmc_wait_for_cmd - start a command and wait for completion
141  *      @host: MMC host to start command
142  *      @cmd: MMC command to start
143  *      @retries: maximum number of retries
144  *
145  *      Start a new MMC command for a host, and wait for the command
146  *      to complete.  Return any error that occurred while the command
147  *      was executing.  Do not attempt to parse the response.
148  */
149 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
150 {
151         struct mmc_request mrq;
152
153         BUG_ON(!host->claimed);
154
155         memset(&mrq, 0, sizeof(struct mmc_request));
156
157         memset(cmd->resp, 0, sizeof(cmd->resp));
158         cmd->retries = retries;
159
160         mrq.cmd = cmd;
161         cmd->data = NULL;
162
163         mmc_wait_for_req(host, &mrq);
164
165         return cmd->error;
166 }
167
168 EXPORT_SYMBOL(mmc_wait_for_cmd);
169
170 /**
171  *      mmc_set_data_timeout - set the timeout for a data command
172  *      @data: data phase for command
173  *      @card: the MMC card associated with the data transfer
174  *      @write: flag to differentiate reads from writes
175  */
176 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card,
177                           int write)
178 {
179         unsigned int mult;
180
181         /*
182          * SD cards use a 100 multiplier rather than 10
183          */
184         mult = mmc_card_sd(card) ? 100 : 10;
185
186         /*
187          * Scale up the multiplier (and therefore the timeout) by
188          * the r2w factor for writes.
189          */
190         if (write)
191                 mult <<= card->csd.r2w_factor;
192
193         data->timeout_ns = card->csd.tacc_ns * mult;
194         data->timeout_clks = card->csd.tacc_clks * mult;
195
196         /*
197          * SD cards also have an upper limit on the timeout.
198          */
199         if (mmc_card_sd(card)) {
200                 unsigned int timeout_us, limit_us;
201
202                 timeout_us = data->timeout_ns / 1000;
203                 timeout_us += data->timeout_clks * 1000 /
204                         (card->host->ios.clock / 1000);
205
206                 if (write)
207                         limit_us = 250000;
208                 else
209                         limit_us = 100000;
210
211                 /*
212                  * SDHC cards always use these fixed values.
213                  */
214                 if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
215                         data->timeout_ns = limit_us * 1000;
216                         data->timeout_clks = 0;
217                 }
218         }
219 }
220 EXPORT_SYMBOL(mmc_set_data_timeout);
221
222 /**
223  *      __mmc_claim_host - exclusively claim a host
224  *      @host: mmc host to claim
225  *      @card: mmc card to claim host for
226  *
227  *      Claim a host for a set of operations.  If a valid card
228  *      is passed and this wasn't the last card selected, select
229  *      the card before returning.
230  *
231  *      Note: you should use mmc_card_claim_host or mmc_claim_host.
232  */
233 void mmc_claim_host(struct mmc_host *host)
234 {
235         DECLARE_WAITQUEUE(wait, current);
236         unsigned long flags;
237
238         add_wait_queue(&host->wq, &wait);
239         spin_lock_irqsave(&host->lock, flags);
240         while (1) {
241                 set_current_state(TASK_UNINTERRUPTIBLE);
242                 if (!host->claimed)
243                         break;
244                 spin_unlock_irqrestore(&host->lock, flags);
245                 schedule();
246                 spin_lock_irqsave(&host->lock, flags);
247         }
248         set_current_state(TASK_RUNNING);
249         host->claimed = 1;
250         spin_unlock_irqrestore(&host->lock, flags);
251         remove_wait_queue(&host->wq, &wait);
252 }
253
254 EXPORT_SYMBOL(mmc_claim_host);
255
256 /**
257  *      mmc_release_host - release a host
258  *      @host: mmc host to release
259  *
260  *      Release a MMC host, allowing others to claim the host
261  *      for their operations.
262  */
263 void mmc_release_host(struct mmc_host *host)
264 {
265         unsigned long flags;
266
267         BUG_ON(!host->claimed);
268
269         spin_lock_irqsave(&host->lock, flags);
270         host->claimed = 0;
271         spin_unlock_irqrestore(&host->lock, flags);
272
273         wake_up(&host->wq);
274 }
275
276 EXPORT_SYMBOL(mmc_release_host);
277
278 /*
279  * Internal function that does the actual ios call to the host driver,
280  * optionally printing some debug output.
281  */
282 static inline void mmc_set_ios(struct mmc_host *host)
283 {
284         struct mmc_ios *ios = &host->ios;
285
286         pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
287                 "width %u timing %u\n",
288                  mmc_hostname(host), ios->clock, ios->bus_mode,
289                  ios->power_mode, ios->chip_select, ios->vdd,
290                  ios->bus_width, ios->timing);
291
292         host->ops->set_ios(host, ios);
293 }
294
295 /*
296  * Control chip select pin on a host.
297  */
298 void mmc_set_chip_select(struct mmc_host *host, int mode)
299 {
300         host->ios.chip_select = mode;
301         mmc_set_ios(host);
302 }
303
304 /*
305  * Sets the host clock to the highest possible frequency that
306  * is below "hz".
307  */
308 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
309 {
310         WARN_ON(hz < host->f_min);
311
312         if (hz > host->f_max)
313                 hz = host->f_max;
314
315         host->ios.clock = hz;
316         mmc_set_ios(host);
317 }
318
319 /*
320  * Change the bus mode (open drain/push-pull) of a host.
321  */
322 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
323 {
324         host->ios.bus_mode = mode;
325         mmc_set_ios(host);
326 }
327
328 /*
329  * Change data bus width of a host.
330  */
331 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
332 {
333         host->ios.bus_width = width;
334         mmc_set_ios(host);
335 }
336
337 /*
338  * Mask off any voltages we don't support and select
339  * the lowest voltage
340  */
341 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
342 {
343         int bit;
344
345         ocr &= host->ocr_avail;
346
347         bit = ffs(ocr);
348         if (bit) {
349                 bit -= 1;
350
351                 ocr &= 3 << bit;
352
353                 host->ios.vdd = bit;
354                 mmc_set_ios(host);
355         } else {
356                 ocr = 0;
357         }
358
359         return ocr;
360 }
361
362 /*
363  * Select timing parameters for host.
364  */
365 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
366 {
367         host->ios.timing = timing;
368         mmc_set_ios(host);
369 }
370
371 /*
372  * Allocate a new MMC card
373  */
374 struct mmc_card *mmc_alloc_card(struct mmc_host *host)
375 {
376         struct mmc_card *card;
377
378         card = kmalloc(sizeof(struct mmc_card), GFP_KERNEL);
379         if (!card)
380                 return ERR_PTR(-ENOMEM);
381
382         mmc_init_card(card, host);
383
384         return card;
385 }
386
387 /*
388  * Apply power to the MMC stack.  This is a two-stage process.
389  * First, we enable power to the card without the clock running.
390  * We then wait a bit for the power to stabilise.  Finally,
391  * enable the bus drivers and clock to the card.
392  *
393  * We must _NOT_ enable the clock prior to power stablising.
394  *
395  * If a host does all the power sequencing itself, ignore the
396  * initial MMC_POWER_UP stage.
397  */
398 static void mmc_power_up(struct mmc_host *host)
399 {
400         int bit = fls(host->ocr_avail) - 1;
401
402         host->ios.vdd = bit;
403         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
404         host->ios.chip_select = MMC_CS_DONTCARE;
405         host->ios.power_mode = MMC_POWER_UP;
406         host->ios.bus_width = MMC_BUS_WIDTH_1;
407         host->ios.timing = MMC_TIMING_LEGACY;
408         mmc_set_ios(host);
409
410         mmc_delay(1);
411
412         host->ios.clock = host->f_min;
413         host->ios.power_mode = MMC_POWER_ON;
414         mmc_set_ios(host);
415
416         mmc_delay(2);
417 }
418
419 static void mmc_power_off(struct mmc_host *host)
420 {
421         host->ios.clock = 0;
422         host->ios.vdd = 0;
423         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
424         host->ios.chip_select = MMC_CS_DONTCARE;
425         host->ios.power_mode = MMC_POWER_OFF;
426         host->ios.bus_width = MMC_BUS_WIDTH_1;
427         host->ios.timing = MMC_TIMING_LEGACY;
428         mmc_set_ios(host);
429 }
430
431 /*
432  * Assign a mmc bus handler to a host. Only one bus handler may control a
433  * host at any given time.
434  */
435 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
436 {
437         unsigned long flags;
438
439         BUG_ON(!host);
440         BUG_ON(!ops);
441
442         BUG_ON(!host->claimed);
443
444         spin_lock_irqsave(&host->lock, flags);
445
446         BUG_ON(host->bus_ops);
447         BUG_ON(host->bus_refs);
448
449         host->bus_ops = ops;
450         host->bus_refs = 1;
451         host->bus_dead = 0;
452
453         spin_unlock_irqrestore(&host->lock, flags);
454 }
455
456 /*
457  * Remove the current bus handler from a host. Assumes that there are
458  * no interesting cards left, so the bus is powered down.
459  */
460 void mmc_detach_bus(struct mmc_host *host)
461 {
462         unsigned long flags;
463
464         BUG_ON(!host);
465
466         BUG_ON(!host->claimed);
467         BUG_ON(!host->bus_ops);
468
469         spin_lock_irqsave(&host->lock, flags);
470
471         host->bus_dead = 1;
472
473         spin_unlock_irqrestore(&host->lock, flags);
474
475         mmc_power_off(host);
476
477         mmc_bus_put(host);
478 }
479
480 /*
481  * Cleanup when the last reference to the bus operator is dropped.
482  */
483 void __mmc_release_bus(struct mmc_host *host)
484 {
485         BUG_ON(!host);
486         BUG_ON(host->bus_refs);
487         BUG_ON(!host->bus_dead);
488
489         host->bus_ops = NULL;
490 }
491
492 /**
493  *      mmc_detect_change - process change of state on a MMC socket
494  *      @host: host which changed state.
495  *      @delay: optional delay to wait before detection (jiffies)
496  *
497  *      All we know is that card(s) have been inserted or removed
498  *      from the socket(s).  We don't know which socket or cards.
499  */
500 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
501 {
502 #ifdef CONFIG_MMC_DEBUG
503         unsigned long flags;
504         spin_lock_irqsave(&host->lock, flags);
505         BUG_ON(host->removed);
506         spin_unlock_irqrestore(&host->lock, flags);
507 #endif
508
509         mmc_schedule_delayed_work(&host->detect, delay);
510 }
511
512 EXPORT_SYMBOL(mmc_detect_change);
513
514
515 static void mmc_rescan(struct work_struct *work)
516 {
517         struct mmc_host *host =
518                 container_of(work, struct mmc_host, detect.work);
519         u32 ocr;
520         int err;
521
522         mmc_bus_get(host);
523
524         if (host->bus_ops == NULL) {
525                 /*
526                  * Only we can add a new handler, so it's safe to
527                  * release the lock here.
528                  */
529                 mmc_bus_put(host);
530
531                 mmc_claim_host(host);
532
533                 mmc_power_up(host);
534                 mmc_go_idle(host);
535
536                 mmc_send_if_cond(host, host->ocr_avail);
537
538                 err = mmc_send_app_op_cond(host, 0, &ocr);
539                 if (err == MMC_ERR_NONE) {
540                         if (mmc_attach_sd(host, ocr))
541                                 mmc_power_off(host);
542                 } else {
543                         /*
544                          * If we fail to detect any SD cards then try
545                          * searching for MMC cards.
546                          */
547                         err = mmc_send_op_cond(host, 0, &ocr);
548                         if (err == MMC_ERR_NONE) {
549                                 if (mmc_attach_mmc(host, ocr))
550                                         mmc_power_off(host);
551                         } else {
552                                 mmc_power_off(host);
553                                 mmc_release_host(host);
554                         }
555                 }
556         } else {
557                 if (host->bus_ops->detect && !host->bus_dead)
558                         host->bus_ops->detect(host);
559
560                 mmc_bus_put(host);
561         }
562 }
563
564
565 /**
566  *      mmc_alloc_host - initialise the per-host structure.
567  *      @extra: sizeof private data structure
568  *      @dev: pointer to host device model structure
569  *
570  *      Initialise the per-host structure.
571  */
572 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
573 {
574         struct mmc_host *host;
575
576         host = mmc_alloc_host_sysfs(extra, dev);
577         if (host) {
578                 spin_lock_init(&host->lock);
579                 init_waitqueue_head(&host->wq);
580                 INIT_DELAYED_WORK(&host->detect, mmc_rescan);
581
582                 /*
583                  * By default, hosts do not support SGIO or large requests.
584                  * They have to set these according to their abilities.
585                  */
586                 host->max_hw_segs = 1;
587                 host->max_phys_segs = 1;
588                 host->max_seg_size = PAGE_CACHE_SIZE;
589
590                 host->max_req_size = PAGE_CACHE_SIZE;
591                 host->max_blk_size = 512;
592                 host->max_blk_count = PAGE_CACHE_SIZE / 512;
593         }
594
595         return host;
596 }
597
598 EXPORT_SYMBOL(mmc_alloc_host);
599
600 /**
601  *      mmc_add_host - initialise host hardware
602  *      @host: mmc host
603  */
604 int mmc_add_host(struct mmc_host *host)
605 {
606         int ret;
607
608         ret = mmc_add_host_sysfs(host);
609         if (ret == 0) {
610                 mmc_power_off(host);
611                 mmc_detect_change(host, 0);
612         }
613
614         return ret;
615 }
616
617 EXPORT_SYMBOL(mmc_add_host);
618
619 /**
620  *      mmc_remove_host - remove host hardware
621  *      @host: mmc host
622  *
623  *      Unregister and remove all cards associated with this host,
624  *      and power down the MMC bus.
625  */
626 void mmc_remove_host(struct mmc_host *host)
627 {
628 #ifdef CONFIG_MMC_DEBUG
629         unsigned long flags;
630         spin_lock_irqsave(&host->lock, flags);
631         host->removed = 1;
632         spin_unlock_irqrestore(&host->lock, flags);
633 #endif
634
635         mmc_flush_scheduled_work();
636
637         mmc_bus_get(host);
638         if (host->bus_ops && !host->bus_dead) {
639                 if (host->bus_ops->remove)
640                         host->bus_ops->remove(host);
641
642                 mmc_claim_host(host);
643                 mmc_detach_bus(host);
644                 mmc_release_host(host);
645         }
646         mmc_bus_put(host);
647
648         BUG_ON(host->card);
649
650         mmc_power_off(host);
651         mmc_remove_host_sysfs(host);
652 }
653
654 EXPORT_SYMBOL(mmc_remove_host);
655
656 /**
657  *      mmc_free_host - free the host structure
658  *      @host: mmc host
659  *
660  *      Free the host once all references to it have been dropped.
661  */
662 void mmc_free_host(struct mmc_host *host)
663 {
664         mmc_free_host_sysfs(host);
665 }
666
667 EXPORT_SYMBOL(mmc_free_host);
668
669 #ifdef CONFIG_PM
670
671 /**
672  *      mmc_suspend_host - suspend a host
673  *      @host: mmc host
674  *      @state: suspend mode (PM_SUSPEND_xxx)
675  */
676 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
677 {
678         mmc_flush_scheduled_work();
679
680         mmc_bus_get(host);
681         if (host->bus_ops && !host->bus_dead) {
682                 if (host->bus_ops->suspend)
683                         host->bus_ops->suspend(host);
684                 if (!host->bus_ops->resume) {
685                         if (host->bus_ops->remove)
686                                 host->bus_ops->remove(host);
687
688                         mmc_claim_host(host);
689                         mmc_detach_bus(host);
690                         mmc_release_host(host);
691                 }
692         }
693         mmc_bus_put(host);
694
695         mmc_power_off(host);
696
697         return 0;
698 }
699
700 EXPORT_SYMBOL(mmc_suspend_host);
701
702 /**
703  *      mmc_resume_host - resume a previously suspended host
704  *      @host: mmc host
705  */
706 int mmc_resume_host(struct mmc_host *host)
707 {
708         mmc_bus_get(host);
709         if (host->bus_ops && !host->bus_dead) {
710                 mmc_power_up(host);
711                 BUG_ON(!host->bus_ops->resume);
712                 host->bus_ops->resume(host);
713         }
714         mmc_bus_put(host);
715
716         /*
717          * We add a slight delay here so that resume can progress
718          * in parallel.
719          */
720         mmc_detect_change(host, 1);
721
722         return 0;
723 }
724
725 EXPORT_SYMBOL(mmc_resume_host);
726
727 #endif
728
729 MODULE_LICENSE("GPL");