2 * Copyright 2008, Freescale Semiconductor, Inc
5 * Based vaguely on the Linux code
7 * See file CREDITS for list of people who contributed to this
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.
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.
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,
32 #include <linux/list.h>
35 /* Set block count limit because of 16 bit register limit on some hardware*/
36 #ifndef CONFIG_SYS_MMC_MAX_BLK_COUNT
37 #define CONFIG_SYS_MMC_MAX_BLK_COUNT 65535
40 static struct list_head mmc_devices
;
41 static int cur_dev_num
= -1;
43 int __board_mmc_getcd(u8
*cd
, struct mmc
*mmc
) {
47 int board_mmc_getcd(u8
*cd
, struct mmc
*mmc
)__attribute__((weak
,
48 alias("__board_mmc_getcd")));
50 int mmc_send_cmd(struct mmc
*mmc
, struct mmc_cmd
*cmd
, struct mmc_data
*data
)
52 #ifdef CONFIG_MMC_TRACE
57 printf("CMD_SEND:%d\n", cmd
->cmdidx
);
58 printf("\t\tARG\t\t\t 0x%08X\n", cmd
->cmdarg
);
59 printf("\t\tFLAG\t\t\t %d\n", cmd
->flags
);
60 ret
= mmc
->send_cmd(mmc
, cmd
, data
);
61 switch (cmd
->resp_type
) {
63 printf("\t\tMMC_RSP_NONE\n");
66 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
70 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
74 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
76 printf("\t\t \t\t 0x%08X \n",
78 printf("\t\t \t\t 0x%08X \n",
80 printf("\t\t \t\t 0x%08X \n",
83 printf("\t\t\t\t\tDUMPING DATA\n");
84 for (i
= 0; i
< 4; i
++) {
86 printf("\t\t\t\t\t%03d - ", i
*4);
87 ptr
= &cmd
->response
[i
];
89 for (j
= 0; j
< 4; j
++)
90 printf("%02X ", *ptr
--);
95 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
99 printf("\t\tERROR MMC rsp not supported\n");
104 return mmc
->send_cmd(mmc
, cmd
, data
);
108 int mmc_send_status(struct mmc
*mmc
, int timeout
)
112 #ifdef CONFIG_MMC_TRACE
116 cmd
.cmdidx
= MMC_CMD_SEND_STATUS
;
117 cmd
.resp_type
= MMC_RSP_R1
;
118 if (!mmc_host_is_spi(mmc
))
119 cmd
.cmdarg
= mmc
->rca
<< 16;
123 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
126 else if (cmd
.response
[0] & MMC_STATUS_RDY_FOR_DATA
)
131 if (cmd
.response
[0] & MMC_STATUS_MASK
) {
132 printf("Status Error: 0x%08X\n", cmd
.response
[0]);
137 #ifdef CONFIG_MMC_TRACE
138 status
= (cmd
.response
[0] & MMC_STATUS_CURR_STATE
) >> 9;
139 printf("CURR STATE:%d\n", status
);
142 printf("Timeout waiting card ready\n");
149 int mmc_set_blocklen(struct mmc
*mmc
, int len
)
153 cmd
.cmdidx
= MMC_CMD_SET_BLOCKLEN
;
154 cmd
.resp_type
= MMC_RSP_R1
;
158 return mmc_send_cmd(mmc
, &cmd
, NULL
);
161 struct mmc
*find_mmc_device(int dev_num
)
164 struct list_head
*entry
;
166 list_for_each(entry
, &mmc_devices
) {
167 m
= list_entry(entry
, struct mmc
, link
);
169 if (m
->block_dev
.dev
== dev_num
)
173 printf("MMC Device %d not found\n", dev_num
);
178 static ulong
mmc_erase_t(struct mmc
*mmc
, ulong start
, lbaint_t blkcnt
)
182 int err
, start_cmd
, end_cmd
;
184 if (mmc
->high_capacity
)
185 end
= start
+ blkcnt
- 1;
187 end
= (start
+ blkcnt
- 1) * mmc
->write_bl_len
;
188 start
*= mmc
->write_bl_len
;
192 start_cmd
= SD_CMD_ERASE_WR_BLK_START
;
193 end_cmd
= SD_CMD_ERASE_WR_BLK_END
;
195 start_cmd
= MMC_CMD_ERASE_GROUP_START
;
196 end_cmd
= MMC_CMD_ERASE_GROUP_END
;
199 cmd
.cmdidx
= start_cmd
;
201 cmd
.resp_type
= MMC_RSP_R1
;
204 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
208 cmd
.cmdidx
= end_cmd
;
211 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
215 cmd
.cmdidx
= MMC_CMD_ERASE
;
216 cmd
.cmdarg
= SECURE_ERASE
;
217 cmd
.resp_type
= MMC_RSP_R1b
;
219 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
226 puts("mmc erase failed\n");
231 mmc_berase(int dev_num
, unsigned long start
, lbaint_t blkcnt
)
234 struct mmc
*mmc
= find_mmc_device(dev_num
);
235 lbaint_t blk
= 0, blk_r
= 0;
240 if ((start
% mmc
->erase_grp_size
) || (blkcnt
% mmc
->erase_grp_size
))
241 printf("\n\nCaution! Your devices Erase group is 0x%x\n"
242 "The erase range would be change to 0x%lx~0x%lx\n\n",
243 mmc
->erase_grp_size
, start
& ~(mmc
->erase_grp_size
- 1),
244 ((start
+ blkcnt
+ mmc
->erase_grp_size
)
245 & ~(mmc
->erase_grp_size
- 1)) - 1);
247 while (blk
< blkcnt
) {
248 blk_r
= ((blkcnt
- blk
) > mmc
->erase_grp_size
) ?
249 mmc
->erase_grp_size
: (blkcnt
- blk
);
250 err
= mmc_erase_t(mmc
, start
+ blk
, blk_r
);
261 mmc_write_blocks(struct mmc
*mmc
, ulong start
, lbaint_t blkcnt
, const void*src
)
264 struct mmc_data data
;
267 if ((start
+ blkcnt
) > mmc
->block_dev
.lba
) {
268 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
269 start
+ blkcnt
, mmc
->block_dev
.lba
);
274 cmd
.cmdidx
= MMC_CMD_WRITE_MULTIPLE_BLOCK
;
276 cmd
.cmdidx
= MMC_CMD_WRITE_SINGLE_BLOCK
;
278 if (mmc
->high_capacity
)
281 cmd
.cmdarg
= start
* mmc
->write_bl_len
;
283 cmd
.resp_type
= MMC_RSP_R1
;
287 data
.blocks
= blkcnt
;
288 data
.blocksize
= mmc
->write_bl_len
;
289 data
.flags
= MMC_DATA_WRITE
;
291 if (mmc_send_cmd(mmc
, &cmd
, &data
)) {
292 printf("mmc write failed\n");
296 /* SPI multiblock writes terminate using a special
297 * token, not a STOP_TRANSMISSION request.
299 if (!mmc_host_is_spi(mmc
) && blkcnt
> 1) {
300 cmd
.cmdidx
= MMC_CMD_STOP_TRANSMISSION
;
302 cmd
.resp_type
= MMC_RSP_R1b
;
304 if (mmc_send_cmd(mmc
, &cmd
, NULL
)) {
305 printf("mmc fail to send stop cmd\n");
309 /* Waiting for the ready status */
310 mmc_send_status(mmc
, timeout
);
317 mmc_bwrite(int dev_num
, ulong start
, lbaint_t blkcnt
, const void*src
)
319 lbaint_t cur
, blocks_todo
= blkcnt
;
321 struct mmc
*mmc
= find_mmc_device(dev_num
);
325 if (mmc_set_blocklen(mmc
, mmc
->write_bl_len
))
329 cur
= (blocks_todo
> mmc
->b_max
) ? mmc
->b_max
: blocks_todo
;
330 if(mmc_write_blocks(mmc
, start
, cur
, src
) != cur
)
334 src
+= cur
* mmc
->write_bl_len
;
335 } while (blocks_todo
> 0);
340 int mmc_read_blocks(struct mmc
*mmc
, void *dst
, ulong start
, lbaint_t blkcnt
)
343 struct mmc_data data
;
347 cmd
.cmdidx
= MMC_CMD_READ_MULTIPLE_BLOCK
;
349 cmd
.cmdidx
= MMC_CMD_READ_SINGLE_BLOCK
;
351 if (mmc
->high_capacity
)
354 cmd
.cmdarg
= start
* mmc
->read_bl_len
;
356 cmd
.resp_type
= MMC_RSP_R1
;
360 data
.blocks
= blkcnt
;
361 data
.blocksize
= mmc
->read_bl_len
;
362 data
.flags
= MMC_DATA_READ
;
364 if (mmc_send_cmd(mmc
, &cmd
, &data
))
368 cmd
.cmdidx
= MMC_CMD_STOP_TRANSMISSION
;
370 cmd
.resp_type
= MMC_RSP_R1b
;
372 if (mmc_send_cmd(mmc
, &cmd
, NULL
)) {
373 printf("mmc fail to send stop cmd\n");
377 /* Waiting for the ready status */
378 mmc_send_status(mmc
, timeout
);
384 static ulong
mmc_bread(int dev_num
, ulong start
, lbaint_t blkcnt
, void *dst
)
386 lbaint_t cur
, blocks_todo
= blkcnt
;
391 struct mmc
*mmc
= find_mmc_device(dev_num
);
395 if ((start
+ blkcnt
) > mmc
->block_dev
.lba
) {
396 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
397 start
+ blkcnt
, mmc
->block_dev
.lba
);
401 if (mmc_set_blocklen(mmc
, mmc
->read_bl_len
))
405 cur
= (blocks_todo
> mmc
->b_max
) ? mmc
->b_max
: blocks_todo
;
406 if(mmc_read_blocks(mmc
, dst
, start
, cur
) != cur
)
410 dst
+= cur
* mmc
->read_bl_len
;
411 } while (blocks_todo
> 0);
416 int mmc_go_idle(struct mmc
* mmc
)
423 cmd
.cmdidx
= MMC_CMD_GO_IDLE_STATE
;
425 cmd
.resp_type
= MMC_RSP_NONE
;
428 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
439 sd_send_op_cond(struct mmc
*mmc
)
446 cmd
.cmdidx
= MMC_CMD_APP_CMD
;
447 cmd
.resp_type
= MMC_RSP_R1
;
451 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
456 cmd
.cmdidx
= SD_CMD_APP_SEND_OP_COND
;
457 cmd
.resp_type
= MMC_RSP_R3
;
460 * Most cards do not answer if some reserved bits
461 * in the ocr are set. However, Some controller
462 * can set bit 7 (reserved for low voltages), but
463 * how to manage low voltages SD card is not yet
466 cmd
.cmdarg
= mmc_host_is_spi(mmc
) ? 0 :
467 (mmc
->voltages
& 0xff8000);
469 if (mmc
->version
== SD_VERSION_2
)
470 cmd
.cmdarg
|= OCR_HCS
;
472 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
478 } while ((!(cmd
.response
[0] & OCR_BUSY
)) && timeout
--);
483 if (mmc
->version
!= SD_VERSION_2
)
484 mmc
->version
= SD_VERSION_1_0
;
486 if (mmc_host_is_spi(mmc
)) { /* read OCR for spi */
487 cmd
.cmdidx
= MMC_CMD_SPI_READ_OCR
;
488 cmd
.resp_type
= MMC_RSP_R3
;
492 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
498 mmc
->ocr
= cmd
.response
[0];
500 mmc
->high_capacity
= ((mmc
->ocr
& OCR_HCS
) == OCR_HCS
);
506 int mmc_send_op_cond(struct mmc
*mmc
)
512 /* Some cards seem to need this */
515 /* Asking to the card its capabilities */
516 cmd
.cmdidx
= MMC_CMD_SEND_OP_COND
;
517 cmd
.resp_type
= MMC_RSP_R3
;
521 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
529 cmd
.cmdidx
= MMC_CMD_SEND_OP_COND
;
530 cmd
.resp_type
= MMC_RSP_R3
;
531 cmd
.cmdarg
= (mmc_host_is_spi(mmc
) ? 0 :
533 (cmd
.response
[0] & OCR_VOLTAGE_MASK
)) |
534 (cmd
.response
[0] & OCR_ACCESS_MODE
));
536 if (mmc
->host_caps
& MMC_MODE_HC
)
537 cmd
.cmdarg
|= OCR_HCS
;
541 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
547 } while (!(cmd
.response
[0] & OCR_BUSY
) && timeout
--);
552 if (mmc_host_is_spi(mmc
)) { /* read OCR for spi */
553 cmd
.cmdidx
= MMC_CMD_SPI_READ_OCR
;
554 cmd
.resp_type
= MMC_RSP_R3
;
558 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
564 mmc
->version
= MMC_VERSION_UNKNOWN
;
565 mmc
->ocr
= cmd
.response
[0];
567 mmc
->high_capacity
= ((mmc
->ocr
& OCR_HCS
) == OCR_HCS
);
574 int mmc_send_ext_csd(struct mmc
*mmc
, char *ext_csd
)
577 struct mmc_data data
;
580 /* Get the Card Status Register */
581 cmd
.cmdidx
= MMC_CMD_SEND_EXT_CSD
;
582 cmd
.resp_type
= MMC_RSP_R1
;
588 data
.blocksize
= 512;
589 data
.flags
= MMC_DATA_READ
;
591 err
= mmc_send_cmd(mmc
, &cmd
, &data
);
597 int mmc_switch(struct mmc
*mmc
, u8 set
, u8 index
, u8 value
)
603 cmd
.cmdidx
= MMC_CMD_SWITCH
;
604 cmd
.resp_type
= MMC_RSP_R1b
;
605 cmd
.cmdarg
= (MMC_SWITCH_MODE_WRITE_BYTE
<< 24) |
610 ret
= mmc_send_cmd(mmc
, &cmd
, NULL
);
612 /* Waiting for the ready status */
613 mmc_send_status(mmc
, timeout
);
619 int mmc_change_freq(struct mmc
*mmc
)
621 ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd
, 512);
627 if (mmc_host_is_spi(mmc
))
630 /* Only version 4 supports high-speed */
631 if (mmc
->version
< MMC_VERSION_4
)
634 err
= mmc_send_ext_csd(mmc
, ext_csd
);
639 cardtype
= ext_csd
[EXT_CSD_CARD_TYPE
] & 0xf;
641 err
= mmc_switch(mmc
, EXT_CSD_CMD_SET_NORMAL
, EXT_CSD_HS_TIMING
, 1);
646 /* Now check to see that it worked */
647 err
= mmc_send_ext_csd(mmc
, ext_csd
);
652 /* No high-speed support */
653 if (!ext_csd
[EXT_CSD_HS_TIMING
])
656 /* High Speed is set, there are two types: 52MHz and 26MHz */
657 if (cardtype
& MMC_HS_52MHZ
)
658 mmc
->card_caps
|= MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
660 mmc
->card_caps
|= MMC_MODE_HS
;
665 int mmc_switch_part(int dev_num
, unsigned int part_num
)
667 struct mmc
*mmc
= find_mmc_device(dev_num
);
672 return mmc_switch(mmc
, EXT_CSD_CMD_SET_NORMAL
, EXT_CSD_PART_CONF
,
673 (mmc
->part_config
& ~PART_ACCESS_MASK
)
674 | (part_num
& PART_ACCESS_MASK
));
677 int sd_switch(struct mmc
*mmc
, int mode
, int group
, u8 value
, u8
*resp
)
680 struct mmc_data data
;
682 /* Switch the frequency */
683 cmd
.cmdidx
= SD_CMD_SWITCH_FUNC
;
684 cmd
.resp_type
= MMC_RSP_R1
;
685 cmd
.cmdarg
= (mode
<< 31) | 0xffffff;
686 cmd
.cmdarg
&= ~(0xf << (group
* 4));
687 cmd
.cmdarg
|= value
<< (group
* 4);
690 data
.dest
= (char *)resp
;
693 data
.flags
= MMC_DATA_READ
;
695 return mmc_send_cmd(mmc
, &cmd
, &data
);
699 int sd_change_freq(struct mmc
*mmc
)
703 ALLOC_CACHE_ALIGN_BUFFER(uint
, scr
, 2);
704 ALLOC_CACHE_ALIGN_BUFFER(uint
, switch_status
, 16);
705 struct mmc_data data
;
710 if (mmc_host_is_spi(mmc
))
713 /* Read the SCR to find out if this card supports higher speeds */
714 cmd
.cmdidx
= MMC_CMD_APP_CMD
;
715 cmd
.resp_type
= MMC_RSP_R1
;
716 cmd
.cmdarg
= mmc
->rca
<< 16;
719 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
724 cmd
.cmdidx
= SD_CMD_APP_SEND_SCR
;
725 cmd
.resp_type
= MMC_RSP_R1
;
732 data
.dest
= (char *)scr
;
735 data
.flags
= MMC_DATA_READ
;
737 err
= mmc_send_cmd(mmc
, &cmd
, &data
);
746 mmc
->scr
[0] = __be32_to_cpu(scr
[0]);
747 mmc
->scr
[1] = __be32_to_cpu(scr
[1]);
749 switch ((mmc
->scr
[0] >> 24) & 0xf) {
751 mmc
->version
= SD_VERSION_1_0
;
754 mmc
->version
= SD_VERSION_1_10
;
757 mmc
->version
= SD_VERSION_2
;
760 mmc
->version
= SD_VERSION_1_0
;
764 if (mmc
->scr
[0] & SD_DATA_4BIT
)
765 mmc
->card_caps
|= MMC_MODE_4BIT
;
767 /* Version 1.0 doesn't support switching */
768 if (mmc
->version
== SD_VERSION_1_0
)
773 err
= sd_switch(mmc
, SD_SWITCH_CHECK
, 0, 1,
774 (u8
*)switch_status
);
779 /* The high-speed function is busy. Try again */
780 if (!(__be32_to_cpu(switch_status
[7]) & SD_HIGHSPEED_BUSY
))
784 /* If high-speed isn't supported, we return */
785 if (!(__be32_to_cpu(switch_status
[3]) & SD_HIGHSPEED_SUPPORTED
))
789 * If the host doesn't support SD_HIGHSPEED, do not switch card to
790 * HIGHSPEED mode even if the card support SD_HIGHSPPED.
791 * This can avoid furthur problem when the card runs in different
792 * mode between the host.
794 if (!((mmc
->host_caps
& MMC_MODE_HS_52MHz
) &&
795 (mmc
->host_caps
& MMC_MODE_HS
)))
798 err
= sd_switch(mmc
, SD_SWITCH_SWITCH
, 0, 1, (u8
*)switch_status
);
803 if ((__be32_to_cpu(switch_status
[4]) & 0x0f000000) == 0x01000000)
804 mmc
->card_caps
|= MMC_MODE_HS
;
809 /* frequency bases */
810 /* divided by 10 to be nice to platforms without floating point */
811 static const int fbase
[] = {
818 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice
819 * to platforms without floating point.
821 static const int multipliers
[] = {
840 void mmc_set_ios(struct mmc
*mmc
)
845 void mmc_set_clock(struct mmc
*mmc
, uint clock
)
847 if (clock
> mmc
->f_max
)
850 if (clock
< mmc
->f_min
)
858 void mmc_set_bus_width(struct mmc
*mmc
, uint width
)
860 mmc
->bus_width
= width
;
865 int mmc_startup(struct mmc
*mmc
)
869 u64 cmult
, csize
, capacity
;
871 ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd
, 512);
872 ALLOC_CACHE_ALIGN_BUFFER(char, test_csd
, 512);
875 #ifdef CONFIG_MMC_SPI_CRC_ON
876 if (mmc_host_is_spi(mmc
)) { /* enable CRC check for spi */
877 cmd
.cmdidx
= MMC_CMD_SPI_CRC_ON_OFF
;
878 cmd
.resp_type
= MMC_RSP_R1
;
881 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
888 /* Put the Card in Identify Mode */
889 cmd
.cmdidx
= mmc_host_is_spi(mmc
) ? MMC_CMD_SEND_CID
:
890 MMC_CMD_ALL_SEND_CID
; /* cmd not supported in spi */
891 cmd
.resp_type
= MMC_RSP_R2
;
895 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
900 memcpy(mmc
->cid
, cmd
.response
, 16);
903 * For MMC cards, set the Relative Address.
904 * For SD cards, get the Relatvie Address.
905 * This also puts the cards into Standby State
907 if (!mmc_host_is_spi(mmc
)) { /* cmd not supported in spi */
908 cmd
.cmdidx
= SD_CMD_SEND_RELATIVE_ADDR
;
909 cmd
.cmdarg
= mmc
->rca
<< 16;
910 cmd
.resp_type
= MMC_RSP_R6
;
913 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
919 mmc
->rca
= (cmd
.response
[0] >> 16) & 0xffff;
922 /* Get the Card-Specific Data */
923 cmd
.cmdidx
= MMC_CMD_SEND_CSD
;
924 cmd
.resp_type
= MMC_RSP_R2
;
925 cmd
.cmdarg
= mmc
->rca
<< 16;
928 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
930 /* Waiting for the ready status */
931 mmc_send_status(mmc
, timeout
);
936 mmc
->csd
[0] = cmd
.response
[0];
937 mmc
->csd
[1] = cmd
.response
[1];
938 mmc
->csd
[2] = cmd
.response
[2];
939 mmc
->csd
[3] = cmd
.response
[3];
941 if (mmc
->version
== MMC_VERSION_UNKNOWN
) {
942 int version
= (cmd
.response
[0] >> 26) & 0xf;
946 mmc
->version
= MMC_VERSION_1_2
;
949 mmc
->version
= MMC_VERSION_1_4
;
952 mmc
->version
= MMC_VERSION_2_2
;
955 mmc
->version
= MMC_VERSION_3
;
958 mmc
->version
= MMC_VERSION_4
;
961 mmc
->version
= MMC_VERSION_1_2
;
966 /* divide frequency by 10, since the mults are 10x bigger */
967 freq
= fbase
[(cmd
.response
[0] & 0x7)];
968 mult
= multipliers
[((cmd
.response
[0] >> 3) & 0xf)];
970 mmc
->tran_speed
= freq
* mult
;
972 mmc
->read_bl_len
= 1 << ((cmd
.response
[1] >> 16) & 0xf);
975 mmc
->write_bl_len
= mmc
->read_bl_len
;
977 mmc
->write_bl_len
= 1 << ((cmd
.response
[3] >> 22) & 0xf);
979 if (mmc
->high_capacity
) {
980 csize
= (mmc
->csd
[1] & 0x3f) << 16
981 | (mmc
->csd
[2] & 0xffff0000) >> 16;
984 csize
= (mmc
->csd
[1] & 0x3ff) << 2
985 | (mmc
->csd
[2] & 0xc0000000) >> 30;
986 cmult
= (mmc
->csd
[2] & 0x00038000) >> 15;
989 mmc
->capacity
= (csize
+ 1) << (cmult
+ 2);
990 mmc
->capacity
*= mmc
->read_bl_len
;
992 if (mmc
->read_bl_len
> 512)
993 mmc
->read_bl_len
= 512;
995 if (mmc
->write_bl_len
> 512)
996 mmc
->write_bl_len
= 512;
998 /* Select the card, and put it into Transfer Mode */
999 if (!mmc_host_is_spi(mmc
)) { /* cmd not supported in spi */
1000 cmd
.cmdidx
= MMC_CMD_SELECT_CARD
;
1001 cmd
.resp_type
= MMC_RSP_R1
;
1002 cmd
.cmdarg
= mmc
->rca
<< 16;
1004 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
1011 * For SD, its erase group is always one sector
1013 mmc
->erase_grp_size
= 1;
1014 mmc
->part_config
= MMCPART_NOAVAILABLE
;
1015 if (!IS_SD(mmc
) && (mmc
->version
>= MMC_VERSION_4
)) {
1016 /* check ext_csd version and capacity */
1017 err
= mmc_send_ext_csd(mmc
, ext_csd
);
1018 if (!err
& (ext_csd
[EXT_CSD_REV
] >= 2)) {
1020 * According to the JEDEC Standard, the value of
1021 * ext_csd's capacity is valid if the value is more
1024 capacity
= ext_csd
[EXT_CSD_SEC_CNT
] << 0
1025 | ext_csd
[EXT_CSD_SEC_CNT
+ 1] << 8
1026 | ext_csd
[EXT_CSD_SEC_CNT
+ 2] << 16
1027 | ext_csd
[EXT_CSD_SEC_CNT
+ 3] << 24;
1029 if ((capacity
>> 20) > 2 * 1024)
1030 mmc
->capacity
= capacity
;
1034 * Check whether GROUP_DEF is set, if yes, read out
1035 * group size from ext_csd directly, or calculate
1036 * the group size from the csd value.
1038 if (ext_csd
[EXT_CSD_ERASE_GROUP_DEF
])
1039 mmc
->erase_grp_size
=
1040 ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
] * 512 * 1024;
1042 int erase_gsz
, erase_gmul
;
1043 erase_gsz
= (mmc
->csd
[2] & 0x00007c00) >> 10;
1044 erase_gmul
= (mmc
->csd
[2] & 0x000003e0) >> 5;
1045 mmc
->erase_grp_size
= (erase_gsz
+ 1)
1049 /* store the partition info of emmc */
1050 if (ext_csd
[EXT_CSD_PARTITIONING_SUPPORT
] & PART_SUPPORT
)
1051 mmc
->part_config
= ext_csd
[EXT_CSD_PART_CONF
];
1055 err
= sd_change_freq(mmc
);
1057 err
= mmc_change_freq(mmc
);
1062 /* Restrict card's capabilities by what the host can do */
1063 mmc
->card_caps
&= mmc
->host_caps
;
1066 if (mmc
->card_caps
& MMC_MODE_4BIT
) {
1067 cmd
.cmdidx
= MMC_CMD_APP_CMD
;
1068 cmd
.resp_type
= MMC_RSP_R1
;
1069 cmd
.cmdarg
= mmc
->rca
<< 16;
1072 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
1076 cmd
.cmdidx
= SD_CMD_APP_SET_BUS_WIDTH
;
1077 cmd
.resp_type
= MMC_RSP_R1
;
1080 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
1084 mmc_set_bus_width(mmc
, 4);
1087 if (mmc
->card_caps
& MMC_MODE_HS
)
1088 mmc_set_clock(mmc
, 50000000);
1090 mmc_set_clock(mmc
, 25000000);
1092 for (width
= EXT_CSD_BUS_WIDTH_8
; width
>= 0; width
--) {
1093 /* Set the card to use 4 bit*/
1094 err
= mmc_switch(mmc
, EXT_CSD_CMD_SET_NORMAL
,
1095 EXT_CSD_BUS_WIDTH
, width
);
1101 mmc_set_bus_width(mmc
, 1);
1104 mmc_set_bus_width(mmc
, 4 * width
);
1106 err
= mmc_send_ext_csd(mmc
, test_csd
);
1107 if (!err
&& ext_csd
[EXT_CSD_PARTITIONING_SUPPORT
] \
1108 == test_csd
[EXT_CSD_PARTITIONING_SUPPORT
]
1109 && ext_csd
[EXT_CSD_ERASE_GROUP_DEF
] \
1110 == test_csd
[EXT_CSD_ERASE_GROUP_DEF
] \
1111 && ext_csd
[EXT_CSD_REV
] \
1112 == test_csd
[EXT_CSD_REV
]
1113 && ext_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
] \
1114 == test_csd
[EXT_CSD_HC_ERASE_GRP_SIZE
]
1115 && memcmp(&ext_csd
[EXT_CSD_SEC_CNT
], \
1116 &test_csd
[EXT_CSD_SEC_CNT
], 4) == 0) {
1118 mmc
->card_caps
|= width
;
1123 if (mmc
->card_caps
& MMC_MODE_HS
) {
1124 if (mmc
->card_caps
& MMC_MODE_HS_52MHz
)
1125 mmc_set_clock(mmc
, 52000000);
1127 mmc_set_clock(mmc
, 26000000);
1129 mmc_set_clock(mmc
, 20000000);
1132 /* fill in device description */
1133 mmc
->block_dev
.lun
= 0;
1134 mmc
->block_dev
.type
= 0;
1135 mmc
->block_dev
.blksz
= mmc
->read_bl_len
;
1136 mmc
->block_dev
.lba
= lldiv(mmc
->capacity
, mmc
->read_bl_len
);
1137 sprintf(mmc
->block_dev
.vendor
, "Man %06x Snr %08x", mmc
->cid
[0] >> 8,
1138 (mmc
->cid
[2] << 8) | (mmc
->cid
[3] >> 24));
1139 sprintf(mmc
->block_dev
.product
, "%c%c%c%c%c", mmc
->cid
[0] & 0xff,
1140 (mmc
->cid
[1] >> 24), (mmc
->cid
[1] >> 16) & 0xff,
1141 (mmc
->cid
[1] >> 8) & 0xff, mmc
->cid
[1] & 0xff);
1142 sprintf(mmc
->block_dev
.revision
, "%d.%d", mmc
->cid
[2] >> 28,
1143 (mmc
->cid
[2] >> 24) & 0xf);
1144 init_part(&mmc
->block_dev
);
1149 int mmc_send_if_cond(struct mmc
*mmc
)
1154 cmd
.cmdidx
= SD_CMD_SEND_IF_COND
;
1155 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1156 cmd
.cmdarg
= ((mmc
->voltages
& 0xff8000) != 0) << 8 | 0xaa;
1157 cmd
.resp_type
= MMC_RSP_R7
;
1160 err
= mmc_send_cmd(mmc
, &cmd
, NULL
);
1165 if ((cmd
.response
[0] & 0xff) != 0xaa)
1166 return UNUSABLE_ERR
;
1168 mmc
->version
= SD_VERSION_2
;
1173 int mmc_register(struct mmc
*mmc
)
1175 /* Setup the universal parts of the block interface just once */
1176 mmc
->block_dev
.if_type
= IF_TYPE_MMC
;
1177 mmc
->block_dev
.dev
= cur_dev_num
++;
1178 mmc
->block_dev
.removable
= 1;
1179 mmc
->block_dev
.block_read
= mmc_bread
;
1180 mmc
->block_dev
.block_write
= mmc_bwrite
;
1181 mmc
->block_dev
.block_erase
= mmc_berase
;
1183 mmc
->b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
1185 INIT_LIST_HEAD (&mmc
->link
);
1187 list_add_tail (&mmc
->link
, &mmc_devices
);
1192 #ifdef CONFIG_PARTITIONS
1193 block_dev_desc_t
*mmc_get_dev(int dev
)
1195 struct mmc
*mmc
= find_mmc_device(dev
);
1197 return mmc
? &mmc
->block_dev
: NULL
;
1201 int mmc_init(struct mmc
*mmc
)
1208 err
= mmc
->init(mmc
);
1213 mmc_set_bus_width(mmc
, 1);
1214 mmc_set_clock(mmc
, 1);
1216 /* Reset the Card */
1217 err
= mmc_go_idle(mmc
);
1222 /* The internal partition reset to user partition(0) at every CMD0*/
1225 /* Test for SD version 2 */
1226 err
= mmc_send_if_cond(mmc
);
1228 /* Now try to get the SD card's operating condition */
1229 err
= sd_send_op_cond(mmc
);
1231 /* If the command timed out, we check for an MMC card */
1232 if (err
== TIMEOUT
) {
1233 err
= mmc_send_op_cond(mmc
);
1236 printf("Card did not respond to voltage select!\n");
1237 return UNUSABLE_ERR
;
1241 err
= mmc_startup(mmc
);
1250 * CPU and board-specific MMC initializations. Aliased function
1251 * signals caller to move on
1253 static int __def_mmc_init(bd_t
*bis
)
1258 int cpu_mmc_init(bd_t
*bis
) __attribute__((weak
, alias("__def_mmc_init")));
1259 int board_mmc_init(bd_t
*bis
) __attribute__((weak
, alias("__def_mmc_init")));
1261 void print_mmc_devices(char separator
)
1264 struct list_head
*entry
;
1266 list_for_each(entry
, &mmc_devices
) {
1267 m
= list_entry(entry
, struct mmc
, link
);
1269 printf("%s: %d", m
->name
, m
->block_dev
.dev
);
1271 if (entry
->next
!= &mmc_devices
)
1272 printf("%c ", separator
);
1278 int get_mmc_num(void)
1283 int mmc_initialize(bd_t
*bis
)
1285 INIT_LIST_HEAD (&mmc_devices
);
1288 if (board_mmc_init(bis
) < 0)
1291 print_mmc_devices(',');