mmc: MMC 4.4 DDR support
[linux-2.6.git] / drivers / mmc / core / mmc.c
1 /*
2  *  linux/drivers/mmc/core/mmc.c
3  *
4  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
5  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
6  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <linux/err.h>
14 #include <linux/slab.h>
15
16 #include <linux/mmc/host.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/mmc.h>
19
20 #include "core.h"
21 #include "bus.h"
22 #include "mmc_ops.h"
23
24 static const unsigned int tran_exp[] = {
25         10000,          100000,         1000000,        10000000,
26         0,              0,              0,              0
27 };
28
29 static const unsigned char tran_mant[] = {
30         0,      10,     12,     13,     15,     20,     25,     30,
31         35,     40,     45,     50,     55,     60,     70,     80,
32 };
33
34 static const unsigned int tacc_exp[] = {
35         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
36 };
37
38 static const unsigned int tacc_mant[] = {
39         0,      10,     12,     13,     15,     20,     25,     30,
40         35,     40,     45,     50,     55,     60,     70,     80,
41 };
42
43 #define UNSTUFF_BITS(resp,start,size)                                   \
44         ({                                                              \
45                 const int __size = size;                                \
46                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
47                 const int __off = 3 - ((start) / 32);                   \
48                 const int __shft = (start) & 31;                        \
49                 u32 __res;                                              \
50                                                                         \
51                 __res = resp[__off] >> __shft;                          \
52                 if (__size + __shft > 32)                               \
53                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
54                 __res & __mask;                                         \
55         })
56
57 /*
58  * Given the decoded CSD structure, decode the raw CID to our CID structure.
59  */
60 static int mmc_decode_cid(struct mmc_card *card)
61 {
62         u32 *resp = card->raw_cid;
63
64         /*
65          * The selection of the format here is based upon published
66          * specs from sandisk and from what people have reported.
67          */
68         switch (card->csd.mmca_vsn) {
69         case 0: /* MMC v1.0 - v1.2 */
70         case 1: /* MMC v1.4 */
71                 card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
72                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
73                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
74                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
75                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
76                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
77                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
78                 card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
79                 card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
80                 card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
81                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
82                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
83                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
84                 break;
85
86         case 2: /* MMC v2.0 - v2.2 */
87         case 3: /* MMC v3.1 - v3.3 */
88         case 4: /* MMC v4 */
89                 card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
90                 card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
91                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
92                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
93                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
94                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
95                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
96                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
97                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
98                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
99                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
100                 break;
101
102         default:
103                 printk(KERN_ERR "%s: card has unknown MMCA version %d\n",
104                         mmc_hostname(card->host), card->csd.mmca_vsn);
105                 return -EINVAL;
106         }
107
108         return 0;
109 }
110
111 static void mmc_set_erase_size(struct mmc_card *card)
112 {
113         if (card->ext_csd.erase_group_def & 1)
114                 card->erase_size = card->ext_csd.hc_erase_size;
115         else
116                 card->erase_size = card->csd.erase_size;
117
118         mmc_init_erase(card);
119 }
120
121 /*
122  * Given a 128-bit response, decode to our card CSD structure.
123  */
124 static int mmc_decode_csd(struct mmc_card *card)
125 {
126         struct mmc_csd *csd = &card->csd;
127         unsigned int e, m, a, b;
128         u32 *resp = card->raw_csd;
129
130         /*
131          * We only understand CSD structure v1.1 and v1.2.
132          * v1.2 has extra information in bits 15, 11 and 10.
133          * We also support eMMC v4.4 & v4.41.
134          */
135         csd->structure = UNSTUFF_BITS(resp, 126, 2);
136         if (csd->structure == 0) {
137                 printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
138                         mmc_hostname(card->host), csd->structure);
139                 return -EINVAL;
140         }
141
142         csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
143         m = UNSTUFF_BITS(resp, 115, 4);
144         e = UNSTUFF_BITS(resp, 112, 3);
145         csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
146         csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
147
148         m = UNSTUFF_BITS(resp, 99, 4);
149         e = UNSTUFF_BITS(resp, 96, 3);
150         csd->max_dtr      = tran_exp[e] * tran_mant[m];
151         csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
152
153         e = UNSTUFF_BITS(resp, 47, 3);
154         m = UNSTUFF_BITS(resp, 62, 12);
155         csd->capacity     = (1 + m) << (e + 2);
156
157         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
158         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
159         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
160         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
161         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
162         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
163         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
164
165         if (csd->write_blkbits >= 9) {
166                 a = UNSTUFF_BITS(resp, 42, 5);
167                 b = UNSTUFF_BITS(resp, 37, 5);
168                 csd->erase_size = (a + 1) * (b + 1);
169                 csd->erase_size <<= csd->write_blkbits - 9;
170         }
171
172         return 0;
173 }
174
175 /*
176  * Read and decode extended CSD.
177  */
178 static int mmc_read_ext_csd(struct mmc_card *card)
179 {
180         int err;
181         u8 *ext_csd;
182
183         BUG_ON(!card);
184
185         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
186                 return 0;
187
188         /*
189          * As the ext_csd is so large and mostly unused, we don't store the
190          * raw block in mmc_card.
191          */
192         ext_csd = kmalloc(512, GFP_KERNEL);
193         if (!ext_csd) {
194                 printk(KERN_ERR "%s: could not allocate a buffer to "
195                         "receive the ext_csd.\n", mmc_hostname(card->host));
196                 return -ENOMEM;
197         }
198
199         err = mmc_send_ext_csd(card, ext_csd);
200         if (err) {
201                 /* If the host or the card can't do the switch,
202                  * fail more gracefully. */
203                 if ((err != -EINVAL)
204                  && (err != -ENOSYS)
205                  && (err != -EFAULT))
206                         goto out;
207
208                 /*
209                  * High capacity cards should have this "magic" size
210                  * stored in their CSD.
211                  */
212                 if (card->csd.capacity == (4096 * 512)) {
213                         printk(KERN_ERR "%s: unable to read EXT_CSD "
214                                 "on a possible high capacity card. "
215                                 "Card will be ignored.\n",
216                                 mmc_hostname(card->host));
217                 } else {
218                         printk(KERN_WARNING "%s: unable to read "
219                                 "EXT_CSD, performance might "
220                                 "suffer.\n",
221                                 mmc_hostname(card->host));
222                         err = 0;
223                 }
224
225                 goto out;
226         }
227
228         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
229         if (card->csd.structure == 3) {
230                 int ext_csd_struct = ext_csd[EXT_CSD_STRUCTURE];
231                 if (ext_csd_struct > 2) {
232                         printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
233                                 "version %d\n", mmc_hostname(card->host),
234                                         ext_csd_struct);
235                         err = -EINVAL;
236                         goto out;
237                 }
238         }
239
240         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
241         if (card->ext_csd.rev > 5) {
242                 printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n",
243                         mmc_hostname(card->host), card->ext_csd.rev);
244                 err = -EINVAL;
245                 goto out;
246         }
247
248         if (card->ext_csd.rev >= 2) {
249                 card->ext_csd.sectors =
250                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
251                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
252                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
253                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
254
255                 /* Cards with density > 2GiB are sector addressed */
256                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
257                         mmc_card_set_blockaddr(card);
258         }
259
260         switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
261         case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
262              EXT_CSD_CARD_TYPE_26:
263                 card->ext_csd.hs_max_dtr = 52000000;
264                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52;
265                 break;
266         case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 |
267              EXT_CSD_CARD_TYPE_26:
268                 card->ext_csd.hs_max_dtr = 52000000;
269                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V;
270                 break;
271         case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 |
272              EXT_CSD_CARD_TYPE_26:
273                 card->ext_csd.hs_max_dtr = 52000000;
274                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V;
275                 break;
276         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
277                 card->ext_csd.hs_max_dtr = 52000000;
278                 break;
279         case EXT_CSD_CARD_TYPE_26:
280                 card->ext_csd.hs_max_dtr = 26000000;
281                 break;
282         default:
283                 /* MMC v4 spec says this cannot happen */
284                 printk(KERN_WARNING "%s: card is mmc v4 but doesn't "
285                         "support any high-speed modes.\n",
286                         mmc_hostname(card->host));
287         }
288
289         if (card->ext_csd.rev >= 3) {
290                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
291
292                 /* Sleep / awake timeout in 100ns units */
293                 if (sa_shift > 0 && sa_shift <= 0x17)
294                         card->ext_csd.sa_timeout =
295                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
296                 card->ext_csd.erase_group_def =
297                         ext_csd[EXT_CSD_ERASE_GROUP_DEF];
298                 card->ext_csd.hc_erase_timeout = 300 *
299                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
300                 card->ext_csd.hc_erase_size =
301                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
302         }
303
304         if (card->ext_csd.rev >= 4) {
305                 card->ext_csd.sec_trim_mult =
306                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
307                 card->ext_csd.sec_erase_mult =
308                         ext_csd[EXT_CSD_SEC_ERASE_MULT];
309                 card->ext_csd.sec_feature_support =
310                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
311                 card->ext_csd.trim_timeout = 300 *
312                         ext_csd[EXT_CSD_TRIM_MULT];
313         }
314
315         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
316                 card->erased_byte = 0xFF;
317         else
318                 card->erased_byte = 0x0;
319
320 out:
321         kfree(ext_csd);
322
323         return err;
324 }
325
326 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
327         card->raw_cid[2], card->raw_cid[3]);
328 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
329         card->raw_csd[2], card->raw_csd[3]);
330 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
331 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
332 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
333 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
334 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
335 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
336 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
337 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
338 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
339
340 static struct attribute *mmc_std_attrs[] = {
341         &dev_attr_cid.attr,
342         &dev_attr_csd.attr,
343         &dev_attr_date.attr,
344         &dev_attr_erase_size.attr,
345         &dev_attr_preferred_erase_size.attr,
346         &dev_attr_fwrev.attr,
347         &dev_attr_hwrev.attr,
348         &dev_attr_manfid.attr,
349         &dev_attr_name.attr,
350         &dev_attr_oemid.attr,
351         &dev_attr_serial.attr,
352         NULL,
353 };
354
355 static struct attribute_group mmc_std_attr_group = {
356         .attrs = mmc_std_attrs,
357 };
358
359 static const struct attribute_group *mmc_attr_groups[] = {
360         &mmc_std_attr_group,
361         NULL,
362 };
363
364 static struct device_type mmc_type = {
365         .groups = mmc_attr_groups,
366 };
367
368 /*
369  * Handle the detection and initialisation of a card.
370  *
371  * In the case of a resume, "oldcard" will contain the card
372  * we're trying to reinitialise.
373  */
374 static int mmc_init_card(struct mmc_host *host, u32 ocr,
375         struct mmc_card *oldcard)
376 {
377         struct mmc_card *card;
378         int err;
379         u32 cid[4];
380         unsigned int max_dtr;
381
382         BUG_ON(!host);
383         WARN_ON(!host->claimed);
384
385         /*
386          * Since we're changing the OCR value, we seem to
387          * need to tell some cards to go back to the idle
388          * state.  We wait 1ms to give cards time to
389          * respond.
390          */
391         mmc_go_idle(host);
392
393         /* The extra bit indicates that we support high capacity */
394         err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
395         if (err)
396                 goto err;
397
398         /*
399          * For SPI, enable CRC as appropriate.
400          */
401         if (mmc_host_is_spi(host)) {
402                 err = mmc_spi_set_crc(host, use_spi_crc);
403                 if (err)
404                         goto err;
405         }
406
407         /*
408          * Fetch CID from card.
409          */
410         if (mmc_host_is_spi(host))
411                 err = mmc_send_cid(host, cid);
412         else
413                 err = mmc_all_send_cid(host, cid);
414         if (err)
415                 goto err;
416
417         if (oldcard) {
418                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
419                         err = -ENOENT;
420                         goto err;
421                 }
422
423                 card = oldcard;
424         } else {
425                 /*
426                  * Allocate card structure.
427                  */
428                 card = mmc_alloc_card(host, &mmc_type);
429                 if (IS_ERR(card)) {
430                         err = PTR_ERR(card);
431                         goto err;
432                 }
433
434                 card->type = MMC_TYPE_MMC;
435                 card->rca = 1;
436                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
437         }
438
439         /*
440          * For native busses:  set card RCA and quit open drain mode.
441          */
442         if (!mmc_host_is_spi(host)) {
443                 err = mmc_set_relative_addr(card);
444                 if (err)
445                         goto free_card;
446
447                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
448         }
449
450         if (!oldcard) {
451                 /*
452                  * Fetch CSD from card.
453                  */
454                 err = mmc_send_csd(card, card->raw_csd);
455                 if (err)
456                         goto free_card;
457
458                 err = mmc_decode_csd(card);
459                 if (err)
460                         goto free_card;
461                 err = mmc_decode_cid(card);
462                 if (err)
463                         goto free_card;
464         }
465
466         /*
467          * Select card, as all following commands rely on that.
468          */
469         if (!mmc_host_is_spi(host)) {
470                 err = mmc_select_card(card);
471                 if (err)
472                         goto free_card;
473         }
474
475         if (!oldcard) {
476                 /*
477                  * Fetch and process extended CSD.
478                  */
479                 err = mmc_read_ext_csd(card);
480                 if (err)
481                         goto free_card;
482                 /* Erase size depends on CSD and Extended CSD */
483                 mmc_set_erase_size(card);
484         }
485
486         /*
487          * Activate high speed (if supported)
488          */
489         if ((card->ext_csd.hs_max_dtr != 0) &&
490                 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
491                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
492                         EXT_CSD_HS_TIMING, 1);
493                 if (err && err != -EBADMSG)
494                         goto free_card;
495
496                 if (err) {
497                         printk(KERN_WARNING "%s: switch to highspeed failed\n",
498                                mmc_hostname(card->host));
499                         err = 0;
500                 } else {
501                         mmc_card_set_highspeed(card);
502                         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
503                 }
504         }
505
506         /*
507          * Compute bus speed.
508          */
509         max_dtr = (unsigned int)-1;
510
511         if (mmc_card_highspeed(card)) {
512                 if (max_dtr > card->ext_csd.hs_max_dtr)
513                         max_dtr = card->ext_csd.hs_max_dtr;
514         } else if (max_dtr > card->csd.max_dtr) {
515                 max_dtr = card->csd.max_dtr;
516         }
517
518         mmc_set_clock(host, max_dtr);
519
520         /*
521          * Activate DDR50 mode (if supported).
522          */
523         if (mmc_card_highspeed(card)) {
524                 if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
525                         && (host->caps & (MMC_CAP_1_8V_DDR)))
526                                 mmc_card_set_ddr_mode(card);
527                 else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
528                         && (host->caps & (MMC_CAP_1_2V_DDR)))
529                                 mmc_card_set_ddr_mode(card);
530         }
531
532         /*
533          * Activate wide bus (if supported).
534          */
535         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
536             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
537                 unsigned ext_csd_bit, bus_width;
538
539                 if (host->caps & MMC_CAP_8_BIT_DATA) {
540                         if (mmc_card_ddr_mode(card))
541                                 ext_csd_bit = EXT_CSD_DDR_BUS_WIDTH_8;
542                         else
543                                 ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
544                         bus_width = MMC_BUS_WIDTH_8;
545                 } else {
546                         if (mmc_card_ddr_mode(card))
547                                 ext_csd_bit = EXT_CSD_DDR_BUS_WIDTH_4;
548                         else
549                                 ext_csd_bit = EXT_CSD_BUS_WIDTH_4;
550                         bus_width = MMC_BUS_WIDTH_4;
551                 }
552
553                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
554                                  EXT_CSD_BUS_WIDTH, ext_csd_bit);
555
556                 if (err && err != -EBADMSG)
557                         goto free_card;
558
559                 if (err) {
560                         printk(KERN_WARNING "%s: switch to bus width %d "
561                                "failed\n", mmc_hostname(card->host),
562                                1 << bus_width);
563                         err = 0;
564                 } else {
565                         mmc_set_bus_width(card->host, bus_width);
566                 }
567         }
568
569         if (!oldcard)
570                 host->card = card;
571
572         return 0;
573
574 free_card:
575         if (!oldcard)
576                 mmc_remove_card(card);
577 err:
578
579         return err;
580 }
581
582 /*
583  * Host is being removed. Free up the current card.
584  */
585 static void mmc_remove(struct mmc_host *host)
586 {
587         BUG_ON(!host);
588         BUG_ON(!host->card);
589
590         mmc_remove_card(host->card);
591         host->card = NULL;
592 }
593
594 /*
595  * Card detection callback from host.
596  */
597 static void mmc_detect(struct mmc_host *host)
598 {
599         int err;
600
601         BUG_ON(!host);
602         BUG_ON(!host->card);
603
604         mmc_claim_host(host);
605
606         /*
607          * Just check if our card has been removed.
608          */
609         err = mmc_send_status(host->card, NULL);
610
611         mmc_release_host(host);
612
613         if (err) {
614                 mmc_remove(host);
615
616                 mmc_claim_host(host);
617                 mmc_detach_bus(host);
618                 mmc_release_host(host);
619         }
620 }
621
622 /*
623  * Suspend callback from host.
624  */
625 static int mmc_suspend(struct mmc_host *host)
626 {
627         BUG_ON(!host);
628         BUG_ON(!host->card);
629
630         mmc_claim_host(host);
631         if (!mmc_host_is_spi(host))
632                 mmc_deselect_cards(host);
633         host->card->state &= ~MMC_STATE_HIGHSPEED;
634         mmc_release_host(host);
635
636         return 0;
637 }
638
639 /*
640  * Resume callback from host.
641  *
642  * This function tries to determine if the same card is still present
643  * and, if so, restore all state to it.
644  */
645 static int mmc_resume(struct mmc_host *host)
646 {
647         int err;
648
649         BUG_ON(!host);
650         BUG_ON(!host->card);
651
652         mmc_claim_host(host);
653         err = mmc_init_card(host, host->ocr, host->card);
654         mmc_release_host(host);
655
656         return err;
657 }
658
659 static void mmc_power_restore(struct mmc_host *host)
660 {
661         host->card->state &= ~MMC_STATE_HIGHSPEED;
662         mmc_claim_host(host);
663         mmc_init_card(host, host->ocr, host->card);
664         mmc_release_host(host);
665 }
666
667 static int mmc_sleep(struct mmc_host *host)
668 {
669         struct mmc_card *card = host->card;
670         int err = -ENOSYS;
671
672         if (card && card->ext_csd.rev >= 3) {
673                 err = mmc_card_sleepawake(host, 1);
674                 if (err < 0)
675                         pr_debug("%s: Error %d while putting card into sleep",
676                                  mmc_hostname(host), err);
677         }
678
679         return err;
680 }
681
682 static int mmc_awake(struct mmc_host *host)
683 {
684         struct mmc_card *card = host->card;
685         int err = -ENOSYS;
686
687         if (card && card->ext_csd.rev >= 3) {
688                 err = mmc_card_sleepawake(host, 0);
689                 if (err < 0)
690                         pr_debug("%s: Error %d while awaking sleeping card",
691                                  mmc_hostname(host), err);
692         }
693
694         return err;
695 }
696
697 static const struct mmc_bus_ops mmc_ops = {
698         .awake = mmc_awake,
699         .sleep = mmc_sleep,
700         .remove = mmc_remove,
701         .detect = mmc_detect,
702         .suspend = NULL,
703         .resume = NULL,
704         .power_restore = mmc_power_restore,
705 };
706
707 static const struct mmc_bus_ops mmc_ops_unsafe = {
708         .awake = mmc_awake,
709         .sleep = mmc_sleep,
710         .remove = mmc_remove,
711         .detect = mmc_detect,
712         .suspend = mmc_suspend,
713         .resume = mmc_resume,
714         .power_restore = mmc_power_restore,
715 };
716
717 static void mmc_attach_bus_ops(struct mmc_host *host)
718 {
719         const struct mmc_bus_ops *bus_ops;
720
721         if (!mmc_card_is_removable(host))
722                 bus_ops = &mmc_ops_unsafe;
723         else
724                 bus_ops = &mmc_ops;
725         mmc_attach_bus(host, bus_ops);
726 }
727
728 /*
729  * Starting point for MMC card init.
730  */
731 int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
732 {
733         int err;
734
735         BUG_ON(!host);
736         WARN_ON(!host->claimed);
737
738         mmc_attach_bus_ops(host);
739
740         /*
741          * We need to get OCR a different way for SPI.
742          */
743         if (mmc_host_is_spi(host)) {
744                 err = mmc_spi_read_ocr(host, 1, &ocr);
745                 if (err)
746                         goto err;
747         }
748
749         /*
750          * Sanity check the voltages that the card claims to
751          * support.
752          */
753         if (ocr & 0x7F) {
754                 printk(KERN_WARNING "%s: card claims to support voltages "
755                        "below the defined range. These will be ignored.\n",
756                        mmc_hostname(host));
757                 ocr &= ~0x7F;
758         }
759
760         host->ocr = mmc_select_voltage(host, ocr);
761
762         /*
763          * Can we support the voltage of the card?
764          */
765         if (!host->ocr) {
766                 err = -EINVAL;
767                 goto err;
768         }
769
770         /*
771          * Detect and init the card.
772          */
773         err = mmc_init_card(host, host->ocr, NULL);
774         if (err)
775                 goto err;
776
777         mmc_release_host(host);
778
779         err = mmc_add_card(host->card);
780         if (err)
781                 goto remove_card;
782
783         return 0;
784
785 remove_card:
786         mmc_remove_card(host->card);
787         host->card = NULL;
788         mmc_claim_host(host);
789 err:
790         mmc_detach_bus(host);
791         mmc_release_host(host);
792
793         printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
794                 mmc_hostname(host), err);
795
796         return err;
797 }