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