blob: 7791c3896e98a00461bda3d4f18bb55d599bad82 [file] [log] [blame]
Andy Fleming272cc702008-10-30 16:41:01 -05001/*
2 * Copyright 2008, Freescale Semiconductor, Inc
3 * Andy Fleming
4 *
5 * Based vaguely on the Linux code
6 *
7 * See file CREDITS for list of people who contributed to this
8 * project.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 * MA 02111-1307 USA
24 */
25
26#include <config.h>
27#include <common.h>
28#include <command.h>
29#include <mmc.h>
30#include <part.h>
31#include <malloc.h>
32#include <linux/list.h>
33#include <mmc.h>
34
35static struct list_head mmc_devices;
36static int cur_dev_num = -1;
37
38int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
39{
40 return mmc->send_cmd(mmc, cmd, data);
41}
42
43int mmc_set_blocklen(struct mmc *mmc, int len)
44{
45 struct mmc_cmd cmd;
46
47 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
48 cmd.resp_type = MMC_RSP_R1;
49 cmd.cmdarg = len;
50 cmd.flags = 0;
51
52 return mmc_send_cmd(mmc, &cmd, NULL);
53}
54
55struct mmc *find_mmc_device(int dev_num)
56{
57 struct mmc *m;
58 struct list_head *entry;
59
60 list_for_each(entry, &mmc_devices) {
61 m = list_entry(entry, struct mmc, link);
62
63 if (m->block_dev.dev == dev_num)
64 return m;
65 }
66
67 printf("MMC Device %d not found\n", dev_num);
68
69 return NULL;
70}
71
72static ulong
73mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
74{
75 struct mmc_cmd cmd;
76 struct mmc_data data;
77 int err;
78 int stoperr = 0;
79 struct mmc *mmc = find_mmc_device(dev_num);
80 int blklen;
81
82 if (!mmc)
83 return -1;
84
85 blklen = mmc->write_bl_len;
86
87 err = mmc_set_blocklen(mmc, mmc->write_bl_len);
88
89 if (err) {
90 printf("set write bl len failed\n\r");
91 return err;
92 }
93
94 if (blkcnt > 1)
95 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
96 else
97 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
98
99 if (mmc->high_capacity)
100 cmd.cmdarg = start;
101 else
102 cmd.cmdarg = start * blklen;
103
104 cmd.resp_type = MMC_RSP_R1;
105 cmd.flags = 0;
106
107 data.src = src;
108 data.blocks = blkcnt;
109 data.blocksize = blklen;
110 data.flags = MMC_DATA_WRITE;
111
112 err = mmc_send_cmd(mmc, &cmd, &data);
113
114 if (err) {
115 printf("mmc write failed\n\r");
116 return err;
117 }
118
119 if (blkcnt > 1) {
120 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
121 cmd.cmdarg = 0;
122 cmd.resp_type = MMC_RSP_R1b;
123 cmd.flags = 0;
124 stoperr = mmc_send_cmd(mmc, &cmd, NULL);
125 }
126
127 return blkcnt;
128}
129
130int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum)
131{
132 struct mmc_cmd cmd;
133 struct mmc_data data;
134
135 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
136
137 if (mmc->high_capacity)
138 cmd.cmdarg = blocknum;
139 else
140 cmd.cmdarg = blocknum * mmc->read_bl_len;
141
142 cmd.resp_type = MMC_RSP_R1;
143 cmd.flags = 0;
144
145 data.dest = dst;
146 data.blocks = 1;
147 data.blocksize = mmc->read_bl_len;
148 data.flags = MMC_DATA_READ;
149
150 return mmc_send_cmd(mmc, &cmd, &data);
151}
152
153int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size)
154{
155 char *buffer;
156 int i;
157 int blklen = mmc->read_bl_len;
158 int startblock = src / blklen;
159 int endblock = (src + size - 1) / blklen;
160 int err = 0;
161
162 /* Make a buffer big enough to hold all the blocks we might read */
163 buffer = malloc(blklen);
164
165 if (!buffer) {
166 printf("Could not allocate buffer for MMC read!\n");
167 return -1;
168 }
169
170 /* We always do full block reads from the card */
171 err = mmc_set_blocklen(mmc, mmc->read_bl_len);
172
173 if (err)
174 return err;
175
176 for (i = startblock; i <= endblock; i++) {
177 int segment_size;
178 int offset;
179
180 err = mmc_read_block(mmc, buffer, i);
181
182 if (err)
183 goto free_buffer;
184
185 /*
186 * The first block may not be aligned, so we
187 * copy from the desired point in the block
188 */
189 offset = (src & (blklen - 1));
190 segment_size = MIN(blklen - offset, size);
191
192 memcpy(dst, buffer + offset, segment_size);
193
194 dst += segment_size;
195 src += segment_size;
196 size -= segment_size;
197 }
198
199free_buffer:
200 free(buffer);
201
202 return err;
203}
204
205static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
206{
207 int err;
208 int i;
209 struct mmc *mmc = find_mmc_device(dev_num);
210
211 if (!mmc)
212 return 0;
213
214 /* We always do full block reads from the card */
215 err = mmc_set_blocklen(mmc, mmc->read_bl_len);
216
217 if (err) {
218 return 0;
219 }
220
221 for (i = start; i < start + blkcnt; i++, dst += mmc->read_bl_len) {
222 err = mmc_read_block(mmc, dst, i);
223
224 if (err) {
225 printf("block read failed: %d\n", err);
226 return i - start;
227 }
228 }
229
230 return blkcnt;
231}
232
233int mmc_go_idle(struct mmc* mmc)
234{
235 struct mmc_cmd cmd;
236 int err;
237
238 udelay(1000);
239
240 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
241 cmd.cmdarg = 0;
242 cmd.resp_type = MMC_RSP_NONE;
243 cmd.flags = 0;
244
245 err = mmc_send_cmd(mmc, &cmd, NULL);
246
247 if (err)
248 return err;
249
250 udelay(2000);
251
252 return 0;
253}
254
255int
256sd_send_op_cond(struct mmc *mmc)
257{
258 int timeout = 1000;
259 int err;
260 struct mmc_cmd cmd;
261
262 do {
263 cmd.cmdidx = MMC_CMD_APP_CMD;
264 cmd.resp_type = MMC_RSP_R1;
265 cmd.cmdarg = 0;
266 cmd.flags = 0;
267
268 err = mmc_send_cmd(mmc, &cmd, NULL);
269
270 if (err)
271 return err;
272
273 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
274 cmd.resp_type = MMC_RSP_R3;
275 cmd.cmdarg = mmc->voltages;
276
277 if (mmc->version == SD_VERSION_2)
278 cmd.cmdarg |= OCR_HCS;
279
280 err = mmc_send_cmd(mmc, &cmd, NULL);
281
282 if (err)
283 return err;
284
285 udelay(1000);
286 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
287
288 if (timeout <= 0)
289 return UNUSABLE_ERR;
290
291 if (mmc->version != SD_VERSION_2)
292 mmc->version = SD_VERSION_1_0;
293
294 mmc->ocr = ((uint *)(cmd.response))[0];
295
296 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
297 mmc->rca = 0;
298
299 return 0;
300}
301
302int mmc_send_op_cond(struct mmc *mmc)
303{
304 int timeout = 1000;
305 struct mmc_cmd cmd;
306 int err;
307
308 /* Some cards seem to need this */
309 mmc_go_idle(mmc);
310
311 do {
312 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
313 cmd.resp_type = MMC_RSP_R3;
314 cmd.cmdarg = OCR_HCS | mmc->voltages;
315 cmd.flags = 0;
316
317 err = mmc_send_cmd(mmc, &cmd, NULL);
318
319 if (err)
320 return err;
321
322 udelay(1000);
323 } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
324
325 if (timeout <= 0)
326 return UNUSABLE_ERR;
327
328 mmc->version = MMC_VERSION_UNKNOWN;
329 mmc->ocr = ((uint *)(cmd.response))[0];
330
331 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
332 mmc->rca = 0;
333
334 return 0;
335}
336
337
338int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
339{
340 struct mmc_cmd cmd;
341 struct mmc_data data;
342 int err;
343
344 /* Get the Card Status Register */
345 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
346 cmd.resp_type = MMC_RSP_R1;
347 cmd.cmdarg = 0;
348 cmd.flags = 0;
349
350 data.dest = ext_csd;
351 data.blocks = 1;
352 data.blocksize = 512;
353 data.flags = MMC_DATA_READ;
354
355 err = mmc_send_cmd(mmc, &cmd, &data);
356
357 return err;
358}
359
360
361int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
362{
363 struct mmc_cmd cmd;
364
365 cmd.cmdidx = MMC_CMD_SWITCH;
366 cmd.resp_type = MMC_RSP_R1b;
367 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
368 (index << 16) |
369 (value << 8);
370 cmd.flags = 0;
371
372 return mmc_send_cmd(mmc, &cmd, NULL);
373}
374
375int mmc_change_freq(struct mmc *mmc)
376{
377 char ext_csd[512];
378 char cardtype;
379 int err;
380
381 mmc->card_caps = 0;
382
383 /* Only version 4 supports high-speed */
384 if (mmc->version < MMC_VERSION_4)
385 return 0;
386
387 mmc->card_caps |= MMC_MODE_4BIT;
388
389 err = mmc_send_ext_csd(mmc, ext_csd);
390
391 if (err)
392 return err;
393
394 if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
395 mmc->high_capacity = 1;
396
397 cardtype = ext_csd[196] & 0xf;
398
399 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
400
401 if (err)
402 return err;
403
404 /* Now check to see that it worked */
405 err = mmc_send_ext_csd(mmc, ext_csd);
406
407 if (err)
408 return err;
409
410 /* No high-speed support */
411 if (!ext_csd[185])
412 return 0;
413
414 /* High Speed is set, there are two types: 52MHz and 26MHz */
415 if (cardtype & MMC_HS_52MHZ)
416 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
417 else
418 mmc->card_caps |= MMC_MODE_HS;
419
420 return 0;
421}
422
423int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
424{
425 struct mmc_cmd cmd;
426 struct mmc_data data;
427
428 /* Switch the frequency */
429 cmd.cmdidx = SD_CMD_SWITCH_FUNC;
430 cmd.resp_type = MMC_RSP_R1;
431 cmd.cmdarg = (mode << 31) | 0xffffff;
432 cmd.cmdarg &= ~(0xf << (group * 4));
433 cmd.cmdarg |= value << (group * 4);
434 cmd.flags = 0;
435
436 data.dest = (char *)resp;
437 data.blocksize = 64;
438 data.blocks = 1;
439 data.flags = MMC_DATA_READ;
440
441 return mmc_send_cmd(mmc, &cmd, &data);
442}
443
444
445int sd_change_freq(struct mmc *mmc)
446{
447 int err;
448 struct mmc_cmd cmd;
449 uint scr[2];
450 uint switch_status[16];
451 struct mmc_data data;
452 int timeout;
453
454 mmc->card_caps = 0;
455
456 /* Read the SCR to find out if this card supports higher speeds */
457 cmd.cmdidx = MMC_CMD_APP_CMD;
458 cmd.resp_type = MMC_RSP_R1;
459 cmd.cmdarg = mmc->rca << 16;
460 cmd.flags = 0;
461
462 err = mmc_send_cmd(mmc, &cmd, NULL);
463
464 if (err)
465 return err;
466
467 cmd.cmdidx = SD_CMD_APP_SEND_SCR;
468 cmd.resp_type = MMC_RSP_R1;
469 cmd.cmdarg = 0;
470 cmd.flags = 0;
471
472 timeout = 3;
473
474retry_scr:
475 data.dest = (char *)&scr;
476 data.blocksize = 8;
477 data.blocks = 1;
478 data.flags = MMC_DATA_READ;
479
480 err = mmc_send_cmd(mmc, &cmd, &data);
481
482 if (err) {
483 if (timeout--)
484 goto retry_scr;
485
486 return err;
487 }
488
489 mmc->scr[0] = scr[0];
490 mmc->scr[1] = scr[1];
491
492 switch ((mmc->scr[0] >> 24) & 0xf) {
493 case 0:
494 mmc->version = SD_VERSION_1_0;
495 break;
496 case 1:
497 mmc->version = SD_VERSION_1_10;
498 break;
499 case 2:
500 mmc->version = SD_VERSION_2;
501 break;
502 default:
503 mmc->version = SD_VERSION_1_0;
504 break;
505 }
506
507 /* Version 1.0 doesn't support switching */
508 if (mmc->version == SD_VERSION_1_0)
509 return 0;
510
511 timeout = 4;
512 while (timeout--) {
513 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
514 (u8 *)&switch_status);
515
516 if (err)
517 return err;
518
519 /* The high-speed function is busy. Try again */
520 if (!switch_status[7] & SD_HIGHSPEED_BUSY)
521 break;
522 }
523
524 if (mmc->scr[0] & SD_DATA_4BIT)
525 mmc->card_caps |= MMC_MODE_4BIT;
526
527 /* If high-speed isn't supported, we return */
528 if (!(switch_status[3] & SD_HIGHSPEED_SUPPORTED))
529 return 0;
530
531 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
532
533 if (err)
534 return err;
535
536 if ((switch_status[4] & 0x0f000000) == 0x01000000)
537 mmc->card_caps |= MMC_MODE_HS;
538
539 return 0;
540}
541
542/* frequency bases */
543/* divided by 10 to be nice to platforms without floating point */
544int fbase[] = {
545 10000,
546 100000,
547 1000000,
548 10000000,
549};
550
551/* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice
552 * to platforms without floating point.
553 */
554int multipliers[] = {
555 0, /* reserved */
556 10,
557 12,
558 13,
559 15,
560 20,
561 25,
562 30,
563 35,
564 40,
565 45,
566 50,
567 55,
568 60,
569 70,
570 80,
571};
572
573void mmc_set_ios(struct mmc *mmc)
574{
575 mmc->set_ios(mmc);
576}
577
578void mmc_set_clock(struct mmc *mmc, uint clock)
579{
580 if (clock > mmc->f_max)
581 clock = mmc->f_max;
582
583 if (clock < mmc->f_min)
584 clock = mmc->f_min;
585
586 mmc->clock = clock;
587
588 mmc_set_ios(mmc);
589}
590
591void mmc_set_bus_width(struct mmc *mmc, uint width)
592{
593 mmc->bus_width = width;
594
595 mmc_set_ios(mmc);
596}
597
598int mmc_startup(struct mmc *mmc)
599{
600 int err;
601 uint mult, freq;
602 u64 cmult, csize;
603 struct mmc_cmd cmd;
604
605 /* Put the Card in Identify Mode */
606 cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
607 cmd.resp_type = MMC_RSP_R2;
608 cmd.cmdarg = 0;
609 cmd.flags = 0;
610
611 err = mmc_send_cmd(mmc, &cmd, NULL);
612
613 if (err)
614 return err;
615
616 memcpy(mmc->cid, cmd.response, 16);
617
618 /*
619 * For MMC cards, set the Relative Address.
620 * For SD cards, get the Relatvie Address.
621 * This also puts the cards into Standby State
622 */
623 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
624 cmd.cmdarg = mmc->rca << 16;
625 cmd.resp_type = MMC_RSP_R6;
626 cmd.flags = 0;
627
628 err = mmc_send_cmd(mmc, &cmd, NULL);
629
630 if (err)
631 return err;
632
633 if (IS_SD(mmc))
634 mmc->rca = (((uint *)(cmd.response))[0] >> 16) & 0xffff;
635
636 /* Get the Card-Specific Data */
637 cmd.cmdidx = MMC_CMD_SEND_CSD;
638 cmd.resp_type = MMC_RSP_R2;
639 cmd.cmdarg = mmc->rca << 16;
640 cmd.flags = 0;
641
642 err = mmc_send_cmd(mmc, &cmd, NULL);
643
644 if (err)
645 return err;
646
647 mmc->csd[0] = ((uint *)(cmd.response))[0];
648 mmc->csd[1] = ((uint *)(cmd.response))[1];
649 mmc->csd[2] = ((uint *)(cmd.response))[2];
650 mmc->csd[3] = ((uint *)(cmd.response))[3];
651
652 if (mmc->version == MMC_VERSION_UNKNOWN) {
653 int version = (cmd.response[0] >> 2) & 0xf;
654
655 switch (version) {
656 case 0:
657 mmc->version = MMC_VERSION_1_2;
658 break;
659 case 1:
660 mmc->version = MMC_VERSION_1_4;
661 break;
662 case 2:
663 mmc->version = MMC_VERSION_2_2;
664 break;
665 case 3:
666 mmc->version = MMC_VERSION_3;
667 break;
668 case 4:
669 mmc->version = MMC_VERSION_4;
670 break;
671 default:
672 mmc->version = MMC_VERSION_1_2;
673 break;
674 }
675 }
676
677 /* divide frequency by 10, since the mults are 10x bigger */
678 freq = fbase[(cmd.response[3] & 0x7)];
679 mult = multipliers[((cmd.response[3] >> 3) & 0xf)];
680
681 mmc->tran_speed = freq * mult;
682
683 mmc->read_bl_len = 1 << ((((uint *)(cmd.response))[1] >> 16) & 0xf);
684
685 if (IS_SD(mmc))
686 mmc->write_bl_len = mmc->read_bl_len;
687 else
688 mmc->write_bl_len = 1 << ((((uint *)(cmd.response))[3] >> 22) & 0xf);
689
690 if (mmc->high_capacity) {
691 csize = (mmc->csd[1] & 0x3f) << 16
692 | (mmc->csd[2] & 0xffff0000) >> 16;
693 cmult = 8;
694 } else {
695 csize = (mmc->csd[1] & 0x3ff) << 2
696 | (mmc->csd[2] & 0xc0000000) >> 30;
697 cmult = (mmc->csd[2] & 0x00038000) >> 15;
698 }
699
700 mmc->capacity = (csize + 1) << (cmult + 2);
701 mmc->capacity *= mmc->read_bl_len;
702
703 if (mmc->read_bl_len > 512)
704 mmc->read_bl_len = 512;
705
706 if (mmc->write_bl_len > 512)
707 mmc->write_bl_len = 512;
708
709 /* Select the card, and put it into Transfer Mode */
710 cmd.cmdidx = MMC_CMD_SELECT_CARD;
711 cmd.resp_type = MMC_RSP_R1b;
712 cmd.cmdarg = mmc->rca << 16;
713 cmd.flags = 0;
714 err = mmc_send_cmd(mmc, &cmd, NULL);
715
716 if (err)
717 return err;
718
719 if (IS_SD(mmc))
720 err = sd_change_freq(mmc);
721 else
722 err = mmc_change_freq(mmc);
723
724 if (err)
725 return err;
726
727 /* Restrict card's capabilities by what the host can do */
728 mmc->card_caps &= mmc->host_caps;
729
730 if (IS_SD(mmc)) {
731 if (mmc->card_caps & MMC_MODE_4BIT) {
732 cmd.cmdidx = MMC_CMD_APP_CMD;
733 cmd.resp_type = MMC_RSP_R1;
734 cmd.cmdarg = mmc->rca << 16;
735 cmd.flags = 0;
736
737 err = mmc_send_cmd(mmc, &cmd, NULL);
738 if (err)
739 return err;
740
741 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
742 cmd.resp_type = MMC_RSP_R1;
743 cmd.cmdarg = 2;
744 cmd.flags = 0;
745 err = mmc_send_cmd(mmc, &cmd, NULL);
746 if (err)
747 return err;
748
749 mmc_set_bus_width(mmc, 4);
750 }
751
752 if (mmc->card_caps & MMC_MODE_HS)
753 mmc_set_clock(mmc, 50000000);
754 else
755 mmc_set_clock(mmc, 25000000);
756 } else {
757 if (mmc->card_caps & MMC_MODE_4BIT) {
758 /* Set the card to use 4 bit*/
759 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
760 EXT_CSD_BUS_WIDTH,
761 EXT_CSD_BUS_WIDTH_4);
762
763 if (err)
764 return err;
765
766 mmc_set_bus_width(mmc, 4);
767 } else if (mmc->card_caps & MMC_MODE_8BIT) {
768 /* Set the card to use 8 bit*/
769 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
770 EXT_CSD_BUS_WIDTH,
771 EXT_CSD_BUS_WIDTH_8);
772
773 if (err)
774 return err;
775
776 mmc_set_bus_width(mmc, 8);
777 }
778
779 if (mmc->card_caps & MMC_MODE_HS) {
780 if (mmc->card_caps & MMC_MODE_HS_52MHz)
781 mmc_set_clock(mmc, 52000000);
782 else
783 mmc_set_clock(mmc, 26000000);
784 } else
785 mmc_set_clock(mmc, 20000000);
786 }
787
788 /* fill in device description */
789 mmc->block_dev.lun = 0;
790 mmc->block_dev.type = 0;
791 mmc->block_dev.blksz = mmc->read_bl_len;
792 mmc->block_dev.lba = mmc->capacity/mmc->read_bl_len;
793 sprintf(mmc->block_dev.vendor,"Man %02x%02x%02x Snr %02x%02x%02x%02x",
794 mmc->cid[0], mmc->cid[1], mmc->cid[2],
795 mmc->cid[9], mmc->cid[10], mmc->cid[11], mmc->cid[12]);
796 sprintf(mmc->block_dev.product,"%c%c%c%c%c", mmc->cid[3],
797 mmc->cid[4], mmc->cid[5], mmc->cid[6], mmc->cid[7]);
798 sprintf(mmc->block_dev.revision,"%d.%d", mmc->cid[8] >> 4,
799 mmc->cid[8] & 0xf);
800 init_part(&mmc->block_dev);
801
802 return 0;
803}
804
805int mmc_send_if_cond(struct mmc *mmc)
806{
807 struct mmc_cmd cmd;
808 int err;
809
810 cmd.cmdidx = SD_CMD_SEND_IF_COND;
811 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
812 cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
813 cmd.resp_type = MMC_RSP_R7;
814 cmd.flags = 0;
815
816 err = mmc_send_cmd(mmc, &cmd, NULL);
817
818 if (err)
819 return err;
820
821 if ((((uint *)(cmd.response))[0] & 0xff) != 0xaa)
822 return UNUSABLE_ERR;
823 else
824 mmc->version = SD_VERSION_2;
825
826 return 0;
827}
828
829int mmc_register(struct mmc *mmc)
830{
831 /* Setup the universal parts of the block interface just once */
832 mmc->block_dev.if_type = IF_TYPE_MMC;
833 mmc->block_dev.dev = cur_dev_num++;
834 mmc->block_dev.removable = 1;
835 mmc->block_dev.block_read = mmc_bread;
836 mmc->block_dev.block_write = mmc_bwrite;
837
838 INIT_LIST_HEAD (&mmc->link);
839
840 list_add_tail (&mmc->link, &mmc_devices);
841
842 return 0;
843}
844
845block_dev_desc_t *mmc_get_dev(int dev)
846{
847 struct mmc *mmc = find_mmc_device(dev);
848
849 return &mmc->block_dev;
850}
851
852int mmc_init(struct mmc *mmc)
853{
854 int err;
855
856 err = mmc->init(mmc);
857
858 if (err)
859 return err;
860
861 /* Reset the Card */
862 err = mmc_go_idle(mmc);
863
864 if (err)
865 return err;
866
867 /* Test for SD version 2 */
868 err = mmc_send_if_cond(mmc);
869
870 /* If we got an error other than timeout, we bail */
871 if (err && err != TIMEOUT)
872 return err;
873
874 /* Now try to get the SD card's operating condition */
875 err = sd_send_op_cond(mmc);
876
877 /* If the command timed out, we check for an MMC card */
878 if (err == TIMEOUT) {
879 err = mmc_send_op_cond(mmc);
880
881 if (err) {
882 printf("Card did not respond to voltage select!\n");
883 return UNUSABLE_ERR;
884 }
885 }
886
887 return mmc_startup(mmc);
888}
889
890/*
891 * CPU and board-specific MMC initializations. Aliased function
892 * signals caller to move on
893 */
894static int __def_mmc_init(bd_t *bis)
895{
896 return -1;
897}
898
Peter Tyserf9a109b2009-04-20 11:08:46 -0500899int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
900int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
Andy Fleming272cc702008-10-30 16:41:01 -0500901
902void print_mmc_devices(char separator)
903{
904 struct mmc *m;
905 struct list_head *entry;
906
907 list_for_each(entry, &mmc_devices) {
908 m = list_entry(entry, struct mmc, link);
909
910 printf("%s: %d", m->name, m->block_dev.dev);
911
912 if (entry->next != &mmc_devices)
913 printf("%c ", separator);
914 }
915
916 printf("\n");
917}
918
919int mmc_initialize(bd_t *bis)
920{
921 INIT_LIST_HEAD (&mmc_devices);
922 cur_dev_num = 0;
923
924 if (board_mmc_init(bis) < 0)
925 cpu_mmc_init(bis);
926
927 print_mmc_devices(',');
928
929 return 0;
930}