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>
34 #include <asm/errno.h>
36 #if defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
37 #include <asm/arch/sprd_reg_base.h>
39 #include <asm/arch/sc8810_reg_base.h>
41 #include <asm/arch/mfp.h>
42 #if defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
43 #include <asm/arch/sprd_reg_ahb.h>
45 #include <asm/arch/sc8810_reg_ahb.h>
47 #include <asm/arch/ldo.h>
48 #include <asm/arch/sdio_reg_v3.h>
49 #include <asm/arch/chip_drv_common_io.h>
50 #if defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
51 #include <asm/arch/sprd_reg_global.h>
52 #include <asm/arch/sprd_module_config.h>
54 #include <asm/arch/sc8810_reg_global.h>
55 #include <asm/arch/sc8810_module_config.h>
57 #include "card_sdio.h"
59 static struct list_head mmc_devices;
60 static int cur_dev_num = -1;
61 #ifdef CONFIG_EMMC_BOOT
62 static block_dev_desc_t sprd_mmc_dev;
65 int __board_mmc_getcd(u8 *cd, struct mmc *mmc) {
69 int board_mmc_getcd(u8 *cd, struct mmc *mmc)__attribute__((weak,
70 alias("__board_mmc_getcd")));
72 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
74 return mmc->send_cmd(mmc, cmd, data);
77 int mmc_set_blocklen(struct mmc *mmc, int len)
81 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
82 cmd.resp_type = MMC_RSP_R1;
86 return mmc_send_cmd(mmc, &cmd, NULL);
89 struct mmc *find_mmc_device(int dev_num)
92 struct list_head *entry;
94 list_for_each(entry, &mmc_devices) {
95 m = list_entry(entry, struct mmc, link);
97 if (m->block_dev.dev == dev_num)
101 printf("MMC Device %d not found\n", dev_num);
107 mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src)
110 struct mmc_data data;
112 if ((start + blkcnt) > mmc->block_dev.lba) {
113 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
114 start + blkcnt, mmc->block_dev.lba);
119 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
121 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
123 if (mmc->high_capacity)
126 cmd.cmdarg = start * mmc->write_bl_len;
128 cmd.resp_type = MMC_RSP_R1;
132 data.blocks = blkcnt;
133 data.blocksize = mmc->write_bl_len;
134 data.flags = MMC_DATA_WRITE;
136 if (mmc_send_cmd(mmc, &cmd, &data)) {
137 printf("mmc write failed\n");
142 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
144 cmd.resp_type = MMC_RSP_R1b;
146 if (mmc_send_cmd(mmc, &cmd, NULL)) {
147 printf("mmc fail to send stop cmd\n");
156 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
158 #ifdef CONFIG_EMMC_BOOT
161 if(Emmc_Write(0, start, blkcnt, (uint8*)src))
171 lbaint_t cur, blocks_todo = blkcnt;
173 struct mmc *mmc = find_mmc_device(dev_num);
177 if (mmc_set_blocklen(mmc, mmc->write_bl_len))
182 * The 65535 constraint comes from some hardware has
183 * only 16 bit width block number counter
185 cur = (blocks_todo > 8192) ? 8192 : blocks_todo;
186 if(mmc_write_blocks(mmc, start, cur, src) != cur)
190 src += cur * mmc->write_bl_len;
191 } while (blocks_todo > 0);
196 int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, lbaint_t blkcnt)
199 struct mmc_data data;
202 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
204 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
206 if (mmc->high_capacity)
209 cmd.cmdarg = start * mmc->read_bl_len;
211 cmd.resp_type = MMC_RSP_R1;
215 data.blocks = blkcnt;
216 data.blocksize = mmc->read_bl_len;
217 data.flags = MMC_DATA_READ;
219 if (mmc_send_cmd(mmc, &cmd, &data))
223 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
225 cmd.resp_type = MMC_RSP_R1b;
227 if (mmc_send_cmd(mmc, &cmd, NULL)) {
228 printf("mmc fail to send stop cmd\n");
236 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
238 #ifdef CONFIG_EMMC_BOOT
241 if(Emmc_Read(0, start, blkcnt, (uint8*)dst))
251 lbaint_t cur, blocks_todo = blkcnt;
256 struct mmc *mmc = find_mmc_device(dev_num);
260 if ((start + blkcnt) > mmc->block_dev.lba) {
261 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
262 start + blkcnt, mmc->block_dev.lba);
266 if (mmc_set_blocklen(mmc, mmc->read_bl_len))
271 * The 65535 constraint comes from some hardware has
272 * only 16 bit width block number counter
274 cur = (blocks_todo > 8192) ? 8192 : blocks_todo;
275 if(mmc_read_blocks(mmc, dst, start, cur) != cur)
279 dst += cur * mmc->read_bl_len;
280 } while (blocks_todo > 0);
285 int mmc_go_idle(struct mmc* mmc)
292 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
294 cmd.resp_type = MMC_RSP_NONE;
297 err = mmc_send_cmd(mmc, &cmd, NULL);
308 sd_send_op_cond(struct mmc *mmc)
315 cmd.cmdidx = MMC_CMD_APP_CMD;
316 cmd.resp_type = MMC_RSP_R1;
320 err = mmc_send_cmd(mmc, &cmd, NULL);
325 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
326 cmd.resp_type = MMC_RSP_R3;
329 * Most cards do not answer if some reserved bits
330 * in the ocr are set. However, Some controller
331 * can set bit 7 (reserved for low voltages), but
332 * how to manage low voltages SD card is not yet
335 cmd.cmdarg = mmc->voltages & 0xff8000;
337 if (mmc->version == SD_VERSION_2)
338 cmd.cmdarg |= OCR_HCS;
340 err = mmc_send_cmd(mmc, &cmd, NULL);
346 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
351 if (mmc->version != SD_VERSION_2)
352 mmc->version = SD_VERSION_1_0;
354 mmc->ocr = cmd.response[0];
356 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
362 int mmc_send_op_cond(struct mmc *mmc)
368 /* Some cards seem to need this */
372 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
373 cmd.resp_type = MMC_RSP_R3;
374 cmd.cmdarg = OCR_HCS | mmc->voltages;
377 err = mmc_send_cmd(mmc, &cmd, NULL);
383 } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
388 mmc->version = MMC_VERSION_UNKNOWN;
389 mmc->ocr = cmd.response[0];
391 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
398 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
401 struct mmc_data data;
404 /* Get the Card Status Register */
405 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
406 cmd.resp_type = MMC_RSP_R1;
412 data.blocksize = 512;
413 data.flags = MMC_DATA_READ;
415 err = mmc_send_cmd(mmc, &cmd, &data);
421 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
425 cmd.cmdidx = MMC_CMD_SWITCH;
426 cmd.resp_type = MMC_RSP_R1b;
427 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
432 return mmc_send_cmd(mmc, &cmd, NULL);
435 int mmc_change_freq(struct mmc *mmc)
443 /* Only version 4 supports high-speed */
444 if (mmc->version < MMC_VERSION_4)
447 mmc->card_caps |= MMC_MODE_4BIT;
449 err = mmc_send_ext_csd(mmc, ext_csd);
454 if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
455 mmc->high_capacity = 1;
457 cardtype = ext_csd[196] & 0xf;
459 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
464 /* Now check to see that it worked */
465 err = mmc_send_ext_csd(mmc, ext_csd);
470 /* No high-speed support */
474 /* High Speed is set, there are two types: 52MHz and 26MHz */
475 if (cardtype & MMC_HS_52MHZ)
476 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
478 mmc->card_caps |= MMC_MODE_HS;
483 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
486 struct mmc_data data;
488 /* Switch the frequency */
489 cmd.cmdidx = SD_CMD_SWITCH_FUNC;
490 cmd.resp_type = MMC_RSP_R1;
491 cmd.cmdarg = (mode << 31) | 0xffffff;
492 cmd.cmdarg &= ~(0xf << (group * 4));
493 cmd.cmdarg |= value << (group * 4);
496 data.dest = (char *)resp;
499 data.flags = MMC_DATA_READ;
501 return mmc_send_cmd(mmc, &cmd, &data);
505 int sd_change_freq(struct mmc *mmc)
510 uint switch_status[16];
511 struct mmc_data data;
516 /* Read the SCR to find out if this card supports higher speeds */
517 cmd.cmdidx = MMC_CMD_APP_CMD;
518 cmd.resp_type = MMC_RSP_R1;
519 cmd.cmdarg = mmc->rca << 16;
522 err = mmc_send_cmd(mmc, &cmd, NULL);
527 cmd.cmdidx = SD_CMD_APP_SEND_SCR;
528 cmd.resp_type = MMC_RSP_R1;
536 data.dest = (char *)&scr;
539 data.flags = MMC_DATA_READ;
541 err = mmc_send_cmd(mmc, &cmd, &data);
550 mmc->scr[0] = __be32_to_cpu(scr[0]);
551 mmc->scr[1] = __be32_to_cpu(scr[1]);
553 switch ((mmc->scr[0] >> 24) & 0xf) {
555 mmc->version = SD_VERSION_1_0;
558 mmc->version = SD_VERSION_1_10;
561 mmc->version = SD_VERSION_2;
564 mmc->version = SD_VERSION_1_0;
568 /* Version 1.0 doesn't support switching */
569 if (mmc->version == SD_VERSION_1_0)
574 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
575 (u8 *)&switch_status);
580 /* The high-speed function is busy. Try again */
581 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
585 if (mmc->scr[0] & SD_DATA_4BIT)
586 mmc->card_caps |= MMC_MODE_4BIT;
588 /* If high-speed isn't supported, we return */
589 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
592 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
597 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
598 mmc->card_caps |= MMC_MODE_HS;
603 /* frequency bases */
604 /* divided by 10 to be nice to platforms without floating point */
612 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice
613 * to platforms without floating point.
615 int multipliers[] = {
634 void mmc_set_ios(struct mmc *mmc)
639 void mmc_set_clock(struct mmc *mmc, uint clock)
641 if (clock > mmc->f_max)
644 if (clock < mmc->f_min)
652 void mmc_set_bus_width(struct mmc *mmc, uint width)
654 mmc->bus_width = width;
659 int mmc_startup(struct mmc *mmc)
667 /* Put the Card in Identify Mode */
668 cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
669 cmd.resp_type = MMC_RSP_R2;
673 err = mmc_send_cmd(mmc, &cmd, NULL);
678 memcpy(mmc->cid, cmd.response, 16);
681 * For MMC cards, set the Relative Address.
682 * For SD cards, get the Relatvie Address.
683 * This also puts the cards into Standby State
685 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
686 cmd.cmdarg = mmc->rca << 16;
687 cmd.resp_type = MMC_RSP_R6;
690 err = mmc_send_cmd(mmc, &cmd, NULL);
696 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
698 /* Get the Card-Specific Data */
699 cmd.cmdidx = MMC_CMD_SEND_CSD;
700 cmd.resp_type = MMC_RSP_R2;
701 cmd.cmdarg = mmc->rca << 16;
704 err = mmc_send_cmd(mmc, &cmd, NULL);
709 mmc->csd[0] = cmd.response[0];
710 mmc->csd[1] = cmd.response[1];
711 mmc->csd[2] = cmd.response[2];
712 mmc->csd[3] = cmd.response[3];
714 if (mmc->version == MMC_VERSION_UNKNOWN) {
715 int version = (cmd.response[0] >> 26) & 0xf;
719 mmc->version = MMC_VERSION_1_2;
722 mmc->version = MMC_VERSION_1_4;
725 mmc->version = MMC_VERSION_2_2;
728 mmc->version = MMC_VERSION_3;
731 mmc->version = MMC_VERSION_4;
734 mmc->version = MMC_VERSION_1_2;
739 /* divide frequency by 10, since the mults are 10x bigger */
740 freq = fbase[(cmd.response[0] & 0x7)];
741 mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
743 mmc->tran_speed = freq * mult;
745 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
748 mmc->write_bl_len = mmc->read_bl_len;
750 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
752 if (mmc->high_capacity) {
753 csize = (mmc->csd[1] & 0x3f) << 16
754 | (mmc->csd[2] & 0xffff0000) >> 16;
757 csize = (mmc->csd[1] & 0x3ff) << 2
758 | (mmc->csd[2] & 0xc0000000) >> 30;
759 cmult = (mmc->csd[2] & 0x00038000) >> 15;
762 mmc->capacity = (csize + 1) << (cmult + 2);
763 mmc->capacity *= mmc->read_bl_len;
765 if (mmc->read_bl_len > 512)
766 mmc->read_bl_len = 512;
768 if (mmc->write_bl_len > 512)
769 mmc->write_bl_len = 512;
771 /* Select the card, and put it into Transfer Mode */
772 cmd.cmdidx = MMC_CMD_SELECT_CARD;
773 cmd.resp_type = MMC_RSP_R1b;
774 cmd.cmdarg = mmc->rca << 16;
776 err = mmc_send_cmd(mmc, &cmd, NULL);
781 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
782 /* check ext_csd version and capacity */
783 err = mmc_send_ext_csd(mmc, ext_csd);
784 if (!err & (ext_csd[192] >= 2)) {
785 mmc->capacity = ext_csd[212] << 0 | ext_csd[213] << 8 |
786 ext_csd[214] << 16 | ext_csd[215] << 24;
787 mmc->capacity *= 512;
792 err = sd_change_freq(mmc);
794 err = mmc_change_freq(mmc);
799 /* Restrict card's capabilities by what the host can do */
800 mmc->card_caps &= mmc->host_caps;
803 if (mmc->card_caps & MMC_MODE_4BIT) {
804 cmd.cmdidx = MMC_CMD_APP_CMD;
805 cmd.resp_type = MMC_RSP_R1;
806 cmd.cmdarg = mmc->rca << 16;
809 err = mmc_send_cmd(mmc, &cmd, NULL);
813 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
814 cmd.resp_type = MMC_RSP_R1;
817 err = mmc_send_cmd(mmc, &cmd, NULL);
821 mmc_set_bus_width(mmc, 4);
824 if (mmc->card_caps & MMC_MODE_HS)
825 mmc_set_clock(mmc, 50000000);
827 mmc_set_clock(mmc, 25000000);
829 if (mmc->card_caps & MMC_MODE_4BIT) {
830 /* Set the card to use 4 bit*/
831 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
833 EXT_CSD_BUS_WIDTH_4);
838 mmc_set_bus_width(mmc, 4);
839 } else if (mmc->card_caps & MMC_MODE_8BIT) {
840 /* Set the card to use 8 bit*/
841 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
843 EXT_CSD_BUS_WIDTH_8);
848 mmc_set_bus_width(mmc, 8);
851 if (mmc->card_caps & MMC_MODE_HS) {
852 if (mmc->card_caps & MMC_MODE_HS_52MHz)
853 mmc_set_clock(mmc, 52000000);
855 mmc_set_clock(mmc, 26000000);
857 mmc_set_clock(mmc, 20000000);
860 /* fill in device description */
861 mmc->block_dev.lun = 0;
862 mmc->block_dev.type = 0;
863 mmc->block_dev.blksz = mmc->read_bl_len;
864 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
865 sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
866 (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
867 sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
868 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
869 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
870 sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
871 (mmc->cid[2] >> 24) & 0xf);
872 init_part(&mmc->block_dev);
877 int mmc_send_if_cond(struct mmc *mmc)
882 cmd.cmdidx = SD_CMD_SEND_IF_COND;
883 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
884 cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
885 cmd.resp_type = MMC_RSP_R7;
888 err = mmc_send_cmd(mmc, &cmd, NULL);
893 if ((cmd.response[0] & 0xff) != 0xaa)
896 mmc->version = SD_VERSION_2;
901 int mmc_register(struct mmc *mmc)
903 /* Setup the universal parts of the block interface just once */
904 mmc->block_dev.if_type = IF_TYPE_MMC;
905 mmc->block_dev.dev = cur_dev_num++;
906 mmc->block_dev.removable = 1;
907 #ifdef CONFIG_EMMC_BOOT
908 if(cur_dev_num == 2){
909 mmc->block_dev.part_type = PART_TYPE_EFI;
910 mmc->block_dev.lun = 0;
911 mmc->block_dev.type = 0;
913 /* FIXME fill in the correct size (is set to 32MByte) */
914 mmc->block_dev.blksz = 512;
916 mmc->block_dev.lba = Emmc_GetCapacity(0);;
919 mmc->block_dev.block_read = mmc_bread;
920 mmc->block_dev.block_write = mmc_bwrite;
922 INIT_LIST_HEAD (&mmc->link);
924 list_add_tail (&mmc->link, &mmc_devices);
929 block_dev_desc_t *mmc_get_dev(int dev)
931 #ifdef CONFIG_EMMC_BOOT
933 return ((block_dev_desc_t *) & sprd_mmc_dev);
935 struct mmc *mmc = find_mmc_device(dev);
937 return mmc ? &mmc->block_dev : NULL;
940 int mmc_init(struct mmc *mmc)
944 err = mmc->init(mmc);
949 mmc_set_bus_width(mmc, 1);
950 mmc_set_clock(mmc, 1);
953 err = mmc_go_idle(mmc);
958 /* Test for SD version 2 */
959 err = mmc_send_if_cond(mmc);
961 /* Now try to get the SD card's operating condition */
962 err = sd_send_op_cond(mmc);
964 /* If the command timed out, we check for an MMC card */
965 if (err == TIMEOUT) {
966 err = mmc_send_op_cond(mmc);
969 printf("Card did not respond to voltage select!\n");
974 return mmc_startup(mmc);
978 * CPU and board-specific MMC initializations. Aliased function
979 * signals caller to move on
981 static int __def_mmc_init(bd_t *bis)
986 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
987 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
989 void print_mmc_devices(char separator)
992 struct list_head *entry;
994 list_for_each(entry, &mmc_devices) {
995 m = list_entry(entry, struct mmc, link);
997 printf("%s: %d", m->name, m->block_dev.dev);
999 if (entry->next != &mmc_devices)
1000 printf("%c ", separator);
1006 int mmc_initialize(bd_t *bis)
1008 INIT_LIST_HEAD (&mmc_devices);
1011 if (board_mmc_init(bis) < 0)
1014 print_mmc_devices(',');
1018 #ifdef CONFIG_EMMC_BOOT
1019 #define MMCSD_SECTOR_SIZE 512
1020 int mmc_legacy_init(int dev)
1023 printf("mmc_legacy_init\n");
1025 if(TRUE == Emmc_Init())
1027 sprd_mmc_dev.if_type = IF_TYPE_UNKNOWN;
1028 sprd_mmc_dev.if_type = IF_TYPE_MMC;
1029 #ifdef CONFIG_EBR_PARTITION
1030 sprd_mmc_dev.part_type = PART_TYPE_DOS;
1032 sprd_mmc_dev.part_type = PART_TYPE_EFI;
1034 sprd_mmc_dev.dev = 1;
1035 sprd_mmc_dev.lun = 0;
1036 sprd_mmc_dev.type = 0;
1038 /* FIXME fill in the correct size (is set to 32MByte) */
1039 sprd_mmc_dev.blksz = MMCSD_SECTOR_SIZE;
1041 sprd_mmc_dev.lba = Emmc_GetCapacity(0);;
1042 sprd_mmc_dev.removable = 1;
1043 sprd_mmc_dev.block_read = mmc_bread;
1044 sprd_mmc_dev.block_write = mmc_bwrite;
1050 #ifdef CONFIG_GENERIC_MMC
1051 int mmc_sdcard_init(void)
1053 #if defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1054 if (TRUE == SDCARD_PowerOn()) {
1055 printf("SDCARD_PowerOn finished\n");
1058 printf("SDCARD_PowerOn failed\n");