add mv_sdio driver for sheevaplug

Add mvsdio driver to Kirkwood SoC
Add SDIO support to SHEEVAPLUG
Fix environments for SHEEVAPLUG

---
Changes in v1:
* Fix errors from SD/SDHC detect
* Minor fixes in boot env

 arch/arm/cpu/arm926ejs/kirkwood/timer.c       |   23 +
 arch/arm/include/asm/arch-kirkwood/kirkwood.h |    1 +
 drivers/mmc/Makefile                          |    1 +
 drivers/mmc/mv_sdio.c                         |  747
+++++++++++++++++++++++++
 drivers/mmc/mv_sdio.h                         |  296 ++++++++++
 include/configs/sheevaplug.h                  |   65 ++-
 6 files changed, 1124 insertions(+), 9 deletions(-)

b/arch/arm/cpu/arm926ejs/kirkwood/timer.c
index 2ec6a93..c8f932b 100644

@@ -166,3 +166,26 @@ int timer_init(void)
 
 	return 0;
 }
+
+
+/*
+ * This function is derived from PowerPC code (read timebase as long long).
+ * On ARM it just returns the timer value.
+ */
+unsigned long long get_ticks(void)
+{
+	return get_timer(0);
+}
+
+/*
+ * This function is derived from PowerPC code (timebase clock frequency).
+ * On ARM it returns the number of timer ticks per second.
+ */
+ulong get_tbclk (void)
+{
+	ulong tbclk;
+
+	tbclk = CONFIG_SYS_HZ;
+	return tbclk;
+}
+

b/arch/arm/include/asm/arch-kirkwood/kirkwood.h
index 0104418..4f9fe7e 100644

@@ -60,6 +60,7 @@
 #define KW_EGIGA0_BASE			(KW_REGISTER(0x72000))
 #define KW_EGIGA1_BASE			(KW_REGISTER(0x76000))
 #define KW_SATA_BASE			(KW_REGISTER(0x80000))
+#define KW_SDIO_BASE			(KW_REGISTER(0x90000))
 
 /* Kirkwood Sata controller has two ports */
 #define KW_SATA_PORT0_OFFSET		0x2000

index 8dfd8a3..f1e7db6 100644
@@ -31,6 +31,7 @@ COBJS-$(CONFIG_BFIN_SDH) += bfin_sdh.o
 COBJS-$(CONFIG_OMAP3_MMC) += omap3_mmc.o
 COBJS-$(CONFIG_FSL_ESDHC) += fsl_esdhc.o
 COBJS-$(CONFIG_MXC_MMC) += mxcmmc.o
+COBJS-$(CONFIG_MV_SDIO) += mv_sdio.o
 COBJS-$(CONFIG_PXA_MMC) += pxa_mmc.o
 COBJS-$(CONFIG_S5P_MMC) += s5p_mmc.o
 

resptype, ushort waittype) +/****************************************************/
+{
+ static ulong resp[4];
+ ushort done ;
+ int err = 0 ;
+ ulong curr, start, diff, hz;
+ ushort response[8], resp_indx = 0;
+
+ debug("mv_mmc_cmd %x, arg: %x,xfer: %x,resp: %x, wait : %x\n"
+ , (unsigned int)cmd, (unsigned int)arg, xfermode, resptype, waittype);
+
+
+ //clear status
+ SDIO_REG_WRITE16(SDIO_NOR_INTR_STATUS, 0xffff);
+ SDIO_REG_WRITE16(SDIO_ERR_INTR_STATUS, 0xffff);
+
+ start = get_ticks();
+ hz = get_tbclk();
+
+ while((SDIO_REG_READ16(SDIO_PRESENT_STATE0) & CARD_BUSY)) {
+ curr = get_ticks();
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ // 3 seconds timeout, card busy, can't sent cmd
+ printf("card too busy \n");
+ return 0;
+ }
+ }
+
+ SDIO_REG_WRITE16(SDIO_ARG_LOW, (ushort)(arg&0xffff) );
+ SDIO_REG_WRITE16(SDIO_ARG_HI, (ushort)(arg>>16) );
+ SDIO_REG_WRITE16(SDIO_XFER_MODE, xfermode);
+ if( (cmd == MMC_CMD_READ_BLOCK) || (cmd == 25) )
+ {
+ SDIO_REG_WRITE16(SDIO_CMD, ((cmd << 8) | resptype | 0x3c ) );
+ debug("cmd reg : %x\n", SDIO_REG_READ16( SDIO_CMD )) ;
+
+ }
+ else
+ {
+ SDIO_REG_WRITE16(SDIO_CMD, ((cmd << 8) | resptype ) );
+ }
+
+ done = SDIO_REG_READ16(SDIO_NOR_INTR_STATUS) & waittype;
+ start = get_ticks();
+
+ while( done!=waittype)
+ {
+ done = SDIO_REG_READ16(SDIO_NOR_INTR_STATUS) & waittype;
+
+ if( SDIO_REG_READ16(SDIO_NOR_INTR_STATUS) & 0x8000 )
+ {
+ debug("Error! cmd : %d, err : %04x\n", (unsigned int)cmd,
SDIO_REG_READ16(SDIO_ERR_INTR_STATUS) ) ;
+
+ return 0 ; // error happen
+ }
+
+ curr = get_ticks();
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ debug("cmd timeout, status : %04x\n",
SDIO_REG_READ16(SDIO_NOR_INTR_STATUS));
+ debug("xfer mode : %04x\n", SDIO_REG_READ16(SDIO_XFER_MODE));
+
+ err = 1 ;
+ break;
+ }
+ }
+
+ for (resp_indx = 0 ; resp_indx < 8; resp_indx++)
+ response[resp_indx] = SDIO_REG_READ16(SDIO_RSP(resp_indx));
+
+ memset(resp, 0, sizeof(resp));
+
+ switch (resptype & 0x3) {
+ case SDIO_CMD_RSP_48:
+ case SDIO_CMD_RSP_48BUSY:
+ resp[0] = ((response[2] & 0x3f) << (8 - 8)) |
+ ((response[1] & 0xffff) << (14 - 8)) |
+ ((response[0] & 0x3ff) << (30 - 8));
+ resp[1] = ((response[0] & 0xfc00) >> 10);
+ break;
+
+ case SDIO_CMD_RSP_136:
+ resp[3] = ((response[7] & 0x3fff) << 8) |
+ ((response[6] & 0x3ff) << 22);
+ resp[2] = ((response[6] & 0xfc00) >> 10) |
+ ((response[5] & 0xffff) << 6) |
+ ((response[4] & 0x3ff) << 22);
+ resp[1] = ((response[4] & 0xfc00) >> 10) |
+ ((response[3] & 0xffff) << 6) |
+ ((response[2] & 0x3ff) << 22);
+ resp[0] = ((response[2] & 0xfc00) >> 10) |
+ ((response[1] & 0xffff) << 6) |
+ ((response[0] & 0x3ff) << 22);
+ break;
+ default:
+ return 0;
+ }
+ int i;
+ debug("MMC resp :");
+ for (i=0; i<4; ++i ) {
+ debug(" %08x", (unsigned int)resp[i]);
+ }
+ debug("\n");
+ if( err )
+ return NULL ;
+ else
+ return resp;
+}
+
+/****************************************************/ +static int mv_mmc_block_read(uchar *dst, ulong src, ulong len) +/****************************************************/
+{
+ ulong *resp;
+ //ushort argh, argl;
+ //ulong status;
+
+ if (len == 0) {
+ return 0;
+ }
+
+ if (is_sdhc) {
+ /* SDHC: use block address */
+ src >>= 9;
+ }
+
+ debug("mmc_block_rd dst %lx src %lx len %d\n", (ulong)dst, src, (int)len);
+
+ // prepare for dma transfer
+ SDIO_REG_WRITE16(SDIO_SYS_ADDR_LOW,((ulong)(dst))&0xffff);
+ SDIO_REG_WRITE16(SDIO_SYS_ADDR_HI,(((ulong)dst)>>16)&0xffff);
+ SDIO_REG_WRITE16(SDIO_BLK_SIZE,len);
+ SDIO_REG_WRITE16(SDIO_BLK_COUNT,1);
+
+ /* send read command */
+ resp = mv_mmc_cmd(MMC_CMD_READ_BLOCK, src, 0x10 , // 0x12,
+ SDIO_CMD_RSP_48, SDIO_NOR_XFER_DONE);
+ if (!resp) {
+ debug("mv_mmc_block_read: mmc read block cmd fails\n");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/****************************************************/ +static int mv_mmc_block_write(ulong dst, uchar *src, int len) +/****************************************************/
+{
+ return -1 ;
+}
+
+/****************************************************/
+int mv_mmc_read(ulong src, uchar *dst, int size) +/****************************************************/
+{
+ ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
+ ulong mmc_block_size, mmc_block_address;
+
+ if (size == 0) {
+ return 0;
+ }
+
+ if (!mmc_ready) {
+ printf("Please initial the MMC first\n");
+ return -1;
+ }
+
+ mmc_block_size = MMC_BLOCK_SIZE;
+ mmc_block_address = ~(mmc_block_size - 1);
+
+ end = src + size;
+ part_start = ~mmc_block_address & src;
+ part_end = ~mmc_block_address & end;
+ aligned_start = mmc_block_address & src;
+ aligned_end = mmc_block_address & end;
+
+ /* all block aligned accesses */
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_start) {
+ part_len = mmc_block_size - part_start;
+ debug("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf+part_start, part_len);
+ dst += part_len;
+ src += part_len;
+ }
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ for (; src < aligned_end; aligned_start +=mmc_block_size, src +=
mmc_block_size, dst += mmc_block_size) {
+ debug("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ printf("mmc block read error\n");
+ return -1;
+ }
+ //printf("mem copy from %x to %x, size %d\n", (ulong)mmc_buf,
(ulong)dst, mmc_block_size );
+ memcpy(dst, mmc_buf, mmc_block_size);
+ }
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_end && src < end) {
+ debug("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf, part_end);
+ }
+ return 0;
+}
+
+/****************************************************/ +static int mv_mmc_write(uchar *src, ulong dst, int size) +/****************************************************/
+{
+ ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
+ ulong mmc_block_size, mmc_block_address;
+
+ if (size == 0) {
+ return 0;
+ }
+
+ if (!mmc_ready) {
+ printf("Please initial the MMC first\n");
+ return -1;
+ }
+
+ mmc_block_size = MMC_BLOCK_SIZE;
+ mmc_block_address = ~(mmc_block_size - 1);
+
+ end = dst + size;
+ part_start = ~mmc_block_address & dst;
+ part_end = ~mmc_block_address & end;
+ aligned_start = mmc_block_address & dst;
+ aligned_end = mmc_block_address & end;
+
+ /* all block aligned accesses */
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_start) {
+ part_len = mmc_block_size - part_start;
+ debug("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (ulong)src, dst, end, part_start, part_end, aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(mmc_buf+part_start, src, part_len);
+ if ((mv_mmc_block_write(aligned_start, mmc_buf, mmc_block_size)) < 0) {
+ return -1;
+ }
+ dst += part_len;
+ src += part_len;
+ }
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ for (; dst < aligned_end; src += mmc_block_size, dst += mmc_block_size) {
+ debug("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_write(dst, (uchar *)src, mmc_block_size)) < 0) {
+ return -1;
+ }
+ }
+ debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_end && dst < end) {
+ debug("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(mmc_buf, src, part_end);
+ if ((mv_mmc_block_write(aligned_end, mmc_buf, mmc_block_size)) < 0) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+/****************************************************/ +static ulong mv_mmc_bread(int dev_num, ulong blknr, ulong blkcnt, ulong *dst) +/****************************************************/
+{
+ int mmc_block_size = MMC_BLOCK_SIZE;
+ ulong src = blknr * mmc_block_size;
+
+ mv_mmc_read(src, (uchar *)dst, blkcnt*mmc_block_size);
+ return blkcnt;
+}
+
+/****************************************************/
+int mmc_legacy_init(int verbose) +/****************************************************/
+{
+ int retries, rc = -ENODEV;
+ ulong *resp;
+ int sd_ver20;
+ int is_sd;
+ ushort reg;
+ uchar cidbuf[64];
+
+ sd_ver20 = 0;
+ is_sdhc = 0;
+ is_sd = 0;
+
+ // Initial Host Ctrl : Timeout : max , Normal Speed mode, 4-bit data mode
+ // Big Endian, SD memory Card, Push_pull CMD Line
+ SDIO_REG_WRITE16(SDIO_HOST_CTRL,
+ SDIO_HOST_CTRL_TMOUT(0xf) |
+ SDIO_HOST_CTRL_DATA_WIDTH_4_BITS |
+ SDIO_HOST_CTRL_BIG_ENDIAN |
+ SDIO_HOST_CTRL_PUSH_PULL_EN |
+ SDIO_HOST_CTRL_CARD_TYPE_MEM_ONLY );
+
+ SDIO_REG_WRITE16(SDIO_CLK_CTRL, 0);
+
+ //enable status
+ SDIO_REG_WRITE16(SDIO_NOR_STATUS_EN, 0xffff);
+ SDIO_REG_WRITE16(SDIO_ERR_STATUS_EN, 0xffff);
+
+ //disable interrupts
+ SDIO_REG_WRITE16(SDIO_NOR_INTR_EN, 0);
+ SDIO_REG_WRITE16(SDIO_ERR_INTR_EN, 0);
+
+ SDIO_REG_WRITE16(SDIO_SW_RESET,0x100);
+ udelay(10000);
+
+ mv_mmc_csd.c_size = 0;
+
+ /* reset */
+ retries = 10;
+ //mv_mmc_cmd(ulong cmd, ulong arg, ushort xfermode, ushort resptype,
ushort waittype);
+ resp = mv_mmc_cmd(0, 0, 0, SDIO_CMD_RSP_NONE, SDIO_NOR_CMD_DONE );
+ debug("cmd 0 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ debug ("trying to detect SD card version\n");
+
+ resp = mv_mmc_cmd(8, 0x000001aa, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ debug("cmd 8 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp && (resp[0] & 0x1ff)==0x1aa) {
+ debug ("SD version 2.0 card detected\n");
+
+ sd_ver20 = 1;
+ }
+
+ if (sd_ver20)
+ retries = 50;
+ else
+ retries = 10;
+
+ while (retries--) {
+ resp = mv_mmc_cmd(55, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ debug("cmd 55 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (sd_ver20)
+ resp = mv_mmc_cmd(41, 0x40300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ else
+ resp = mv_mmc_cmd(41, 0x00300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+
+ debug("cmd 41 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ debug ("detected SD card\n");
+
+ is_sd = 1;
+ break;
+ }
+
+ udelay(100*1000);
+ }
+
+ if (retries <= 0 && !is_sd) {
+ debug ("failed to detect SD card, trying MMC\n");
+
+ retries = 10;
+ while (retries--) {
+ resp = mv_mmc_cmd(1, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ debug("cmd 01 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ printf ("detected MMC card\n");
+ reg = SDIO_REG_READ16(SDIO_HOST_CTRL);
+ reg &= ~(0x3<<1);
+ reg |= SDIO_HOST_CTRL_CARD_TYPE_IO_MMC;
+ SDIO_REG_WRITE16(SDIO_HOST_CTRL, reg);
+ break;
+ }
+
+ udelay(100*1000);
+ }
+ }
+
+ if (retries <= 0) {
+ debug ("detect fails\n");
+
+ return -ENODEV;
+ }
+
+ /* try to get card id */
+ resp = mv_mmc_cmd(2, 0, 0, SDIO_CMD_RSP_136, SDIO_NOR_CMD_DONE );
+ debug("cmd 2 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp == NULL) {
+ debug ("read cid fails\n");
+
+ return -ENODEV;
+ }
+
+ if (is_sd) {
+ mv_sd_cid_t *cid = (mv_sd_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x OEM %c%c \"%c%c%c%c%c\"",
+ cid->mid, cid->oid_0, cid->oid_1,
+ cid->pnm_0, cid->pnm_1, cid->pnm_2, cid->pnm_3, cid->pnm_4);
+
+ sprintf((char *) mmc_dev.product, "%d",
+ (cid->psn_0 << 24) | (cid->psn_1 <<16) | (cid->psn_2 << 8) |
(cid->psn_3 << 8));
+
+ sprintf((char *) mmc_dev.revision, "%d.%d", cid->prv>>4, cid->prv &
0xff);
+
+ } else {
+ /* TODO configure mmc driver depending on card attributes */
+ mv_mmc_cid_t *cid = (mv_mmc_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x%02x%02x Snr %02x%02x%02x",
+ cid->id[0], cid->id[1], cid->id[2],
+ cid->sn[0], cid->sn[1], cid->sn[2]);
+ sprintf((char *) mmc_dev.product, "%s", cid->name);
+ sprintf((char *) mmc_dev.revision, "%x %x", cid->hwrev, cid->fwrev);
+ }
+
+ /* fill in device description */
+ mmc_dev.if_type = IF_TYPE_MMC;
+ mmc_dev.part_type = PART_TYPE_DOS;
+ mmc_dev.dev = 0;
+ mmc_dev.lun = 0;
+ mmc_dev.type = 0;
+
+ /* FIXME fill in the correct size (is set to 128MByte) */
+ mmc_dev.blksz = MMC_BLOCK_SIZE;
+ mmc_dev.lba = 0x10000;
+
+ mmc_dev.removable = 0;
+ mmc_dev.block_read = mv_mmc_bread;
+
+ /* MMC exists, get CSD too */
+ resp = mv_mmc_cmd(MMC_CMD_SET_RCA, 0, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ debug ("set rca fails\n");
+
+ return -ENODEV;
+ }
+ debug("cmd3 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ if (is_sd)
+ rca = resp[0] >> 16;
+ else
+ rca = 0;
+
+ resp = mv_mmc_cmd(MMC_CMD_SEND_CSD, rca<<16, 0,
SDIO_CMD_RSP_136,SDIO_NOR_CMD_DONE );
+ debug("cmd 9 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp == NULL) {
+ debug ("read csd fails\n");
+
+ return -ENODEV;
+ }
+
+ memcpy(&mv_mmc_csd, (mv_mmc_csd_t *) resp, sizeof(mv_mmc_csd_t));
+ rc = 0;
+ mmc_ready = 1;
+
+ /* FIXME add verbose printout for csd */
+ debug ("size = %u\n", mv_mmc_size(&mv_mmc_csd));
+
+
+ resp = mv_mmc_cmd(7, rca<<16, 0, SDIO_CMD_RSP_48BUSY, SDIO_NOR_CMD_DONE);
+ if (resp == NULL) {
+ debug ("select card fails\n");
+
+ return -ENODEV;
+ }
+ debug("cmd 7 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (is_sd) {
+ resp = mv_mmc_cmd(55, rca<<16, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ debug("cmd55 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ resp = mv_mmc_cmd(6, (rca<<16) | 0x2 , 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ debug("cmd6 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+ }
+
+ resp = (ulong *) &mv_mmc_csd;
+ debug("csd: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ /* check SDHC */
+ if ((resp[0]&0xf0000000)==0x40000000)
+ is_sdhc = 1;
+
+ /* set block len */
+ resp = mv_mmc_cmd(MMC_CMD_SET_BLOCKLEN, MMC_BLOCK_SIZE, 0,
SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (!resp) {
+ debug("mv_mmc_block_read: set blk len fails\n");
+ return -ENODEV;
+ }
+
+ if (verbose) {
+ if (is_sd)
+ print_sd_cid((mv_sd_cid_t *) cidbuf);
+ else
+ print_mmc_cid((mv_mmc_cid_t *) cidbuf);
+ }
+
+ mvsdio_set_clock(CONFIG_SYS_MMC_CLK_PP);
+
+ fat_register_device(&mmc_dev,1); /* partitions start counting with 1 */
+
+ return 0;
+}
+
+#endif /* CONFIG_MMC */
+

index c5de86e..7b7e5e8 100644
@@ -25,10 +25,12 @@
 #ifndef _CONFIG_SHEEVAPLUG_H
 #define _CONFIG_SHEEVAPLUG_H
 
+//#define DEBUG 1
+
 /*
  * Version number information
  */
-#define CONFIG_IDENT_STRING	"\nMarvell-Sheevaplug"
+#define CONFIG_IDENT_STRING	"\nMarvell-Sheevaplug - eSATA - SD/MMC"
 
 /*
  * High Level Configuration Options (easy to change)

@@ -94,7 +96,9 @@
 #define CONFIG_CMD_AUTOSCRIPT
 #define CONFIG_CMD_DHCP
 #define CONFIG_CMD_ENV
 #define CONFIG_CMD_MII
+#define CONFIG_CMD_MMC
 #define CONFIG_CMD_NAND
 #define CONFIG_CMD_PING
 #define CONFIG_CMD_USB

@@ -132,16 +136,23 @@
  */
 #define CONFIG_BOOTCOMMAND		"${x_bootcmd_kernel}; "	\
 	"setenv bootargs ${x_bootargs} ${x_bootargs_root}; "	\
-	"${x_bootcmd_usb}; bootm 0x6400000;"
+	"${x_bootcmd_usb}; ${x_bootcmd_sata}; bootm 0x6400000;"
+
+#define CONFIG_MTDPARTS		"orion_nand:"	\
+	"512k(uboot),4m at 1m(kernel),507m at 5m(rootfs) rw\0"
 
-#define CONFIG_MTDPARTS		"orion_nand:512k(uboot),"	\
-	"3m at 1m(kernel),1m at 4m(psm),13m@5m(rootfs) rw\0"
 
-#define CONFIG_EXTRA_ENV_SETTINGS	"x_bootargs=console"	\
-	"=ttyS0,115200 mtdparts="CONFIG_MTDPARTS	\
-	"x_bootcmd_kernel=nand read 0x6400000 0x100000 0x300000\0" \
-	"x_bootcmd_usb=usb start\0" \
-	"x_bootargs_root=root=/dev/mtdblock3 rw rootfstype=jffs2\0"
+#define CONFIG_EXTRA_ENV_SETTINGS	"x_bootargs=console"		\
+	"=ttyS0,115200 mtdparts="CONFIG_MTDPARTS			\
+	"x_bootcmd_kernel=nand read 0x6400000 0x100000 0x400000\0" 	\
+	"x_bootcmd_usb=usb start;\0" 					\
+	"x_bootcmd_sata=ide reset;\0" 					\
+	"x_bootargs_root=ubi.mtd=2 root=ubi0:rootfs rootfstype=ubifs\0"
 
 /*
  * Size of malloc() pool

@@ -183,6 +194,42 @@
 #endif /* CONFIG_CMD_NET */
 
 /*
+ * SDIO/MMC Card Configuration
+ */
+#ifdef CONFIG_CMD_MMC
+#define CONFIG_MMC
+#define CONFIG_MV_SDIO
+#endif /* CONFIG_CMD_MMC */
+
+/*
  * USB/EHCI
  */
 #ifdef CONFIG_CMD_USB

G?rald, can this be adapted for GuruPlug?

First of all Thanks for pinging on this. Yes, we can, but this needs some more modifications. I will provide review comments for this patch ASAP

Regards..
Prafulla . .

Hye Clint,

Le 18/11/2010 02:00, Clint Adams a ?crit :

It is not needed at all.
The ?SD card reader of the GuruPlug is viewed as an USB device.

A patch had already been commit to support the ?SD of the GuruPlug by Ludovic Court?s

I have done a quick test of the current uBoot :
a 1G microSD is correctly detected in a GuruPlug Server Plus.

Regards,

G.K

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 554 bytes
Desc: OpenPGP digital signature
Url : http://lists.denx.de/pipermail/u-boot/attachments/20101120/ee815c2c/attachment.pgp 

Hi Gerald
Sorry for late feedback, please find my comments inlined.

You should break this patch into small pieces as per functionalities like-
1. Kirkwood: add more timer functions
2. Kirkwood: pre-requisite for SDIO driver support
3. mmc : Add SDIO driver for Marvell SoCs (Kirkwood)
4. Sheevaplug: Add MMC/SDIO support
5. Sheevaplug: Fix environments for <specify problem>
6. Guruplug: Add MMC/SDIO support (as Clint suggested- Optional)

---
 arch/arm/include/asm/arch-kirkwood/kirkwood.h     |    1 +
 arch/arm/include/asm/arch-kirkwood/mmc_host_def.h |  292 +++++++++
 drivers/mmc/Makefile                              |    1 +
 drivers/mmc/mv_sdio.c                             |  663
+++++++++++++++++++++
 4 files changed, 957 insertions(+), 0 deletions(-)

b/arch/arm/include/asm/arch-kirkwood/kirkwood.h
index 0104418..4f9fe7e 100644

@@ -60,6 +60,7 @@
 #define KW_EGIGA0_BASE			(KW_REGISTER(0x72000))
 #define KW_EGIGA1_BASE			(KW_REGISTER(0x76000))
 #define KW_SATA_BASE			(KW_REGISTER(0x80000))
+#define KW_SDIO_BASE			(KW_REGISTER(0x90000))
 
 /* Kirkwood Sata controller has two ports */
 #define KW_SATA_PORT0_OFFSET		0x2000

b/arch/arm/include/asm/arch-kirkwood/mmc_host_def.h new file mode 100644
index 0000000..4327c93

index 68afd30..2a4e1d4 100644
@@ -30,6 +30,7 @@ COBJS-$(CONFIG_BFIN_SDH) += bfin_sdh.o
 COBJS-$(CONFIG_FSL_ESDHC) += fsl_esdhc.o
 COBJS-$(CONFIG_GENERIC_MMC) += mmc.o
 COBJS-$(CONFIG_GENERIC_ATMEL_MCI) += gen_atmel_mci.o
+COBJS-$(CONFIG_MV_SDIO) += mv_sdio.o
 COBJS-$(CONFIG_MXC_MMC) += mxcmmc.o
 COBJS-$(CONFIG_OMAP3_MMC) += omap3_mmc.o
 COBJS-$(CONFIG_OMAP_HSMMC) += omap_hsmmc.o

resptype, ushort waittype) +/****************************************************/
+{
+ static ulong resp[4];
+ ushort done ;
+ int err = 0 ;
+ ulong curr, start, diff, hz;
+ ushort response[8], resp_indx = 0;
+
+ pr_debug("mv_mmc_cmd %x, arg: %x,xfer: %x,resp: %x, wait : %x\n"
+ , (unsigned int)cmd, (unsigned int)arg, xfermode, resptype, waittype);
+
+
+ /* clear status */
+ writew(0xffff, SDIO_REG(SDIO_NOR_INTR_STATUS));
+ writew(0xffff, SDIO_REG(SDIO_ERR_INTR_STATUS));
+
+ start = get_timer(0);
+ hz = CONFIG_SYS_HZ;
+
+ while((readw(SDIO_REG(SDIO_PRESENT_STATE0)) & CARD_BUSY)) {
+ curr = get_timer(0);
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ /* 3 seconds timeout, card busy, can't sent cmd */
+ printf("card too busy \n");
+ return 0;
+ }
+ }
+
+ writew((ushort)(arg&0xffff), SDIO_REG(SDIO_ARG_LOW));
+ writew((ushort)(arg>>16), SDIO_REG(SDIO_ARG_HI));
+ writew(xfermode, SDIO_REG(SDIO_XFER_MODE));
+ if( (cmd == MMC_CMD_READ_BLOCK) || (cmd == 25) )
+ {
+ writew(((cmd << 8) | resptype | 0x3c ) , SDIO_REG(SDIO_CMD));
+ pr_debug("cmd reg : %x\n", readw(SDIO_REG(SDIO_CMD) )) ;
+
+ }
+ else
+ {
+ writew(((cmd << 8) | resptype ), SDIO_REG(SDIO_CMD));
+ }
+
+ done = readw(SDIO_REG(SDIO_NOR_INTR_STATUS)) & waittype;
+ start = get_timer(0);
+
+ while( done!=waittype)
+ {
+ done = readw(SDIO_REG(SDIO_NOR_INTR_STATUS)) & waittype;
+
+ if( readw(SDIO_REG(SDIO_NOR_INTR_STATUS)) & 0x8000 )
+ {
+ pr_debug("Error! cmd : %d, err : %04x\n", (unsigned int)cmd,
readw(SDIO_REG(SDIO_ERR_INTR_STATUS))) ;
+
+ return 0 ; /* error happen */
+ }
+
+ curr = get_timer(0);
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ pr_debug("cmd timeout, status : %04x\n",
readw(SDIO_REG(SDIO_NOR_INTR_STATUS)));
+ pr_debug("xfer mode : %04x\n", readw(SDIO_REG(SDIO_XFER_MODE)));
+
+ err = 1 ;
+ break;
+ }
+ }
+
+ for (resp_indx = 0 ; resp_indx < 8; resp_indx++)
+ response[resp_indx] = readw(SDIO_REG(SDIO_RSP(resp_indx)));
+
+ memset(resp, 0, sizeof(resp));
+
+ switch (resptype & 0x3) {
+ case SDIO_CMD_RSP_48:
+ case SDIO_CMD_RSP_48BUSY:
+ resp[0] = ((response[2] & 0x3f) << (8 - 8)) |
+ ((response[1] & 0xffff) << (14 - 8)) |
+ ((response[0] & 0x3ff) << (30 - 8));
+ resp[1] = ((response[0] & 0xfc00) >> 10);
+ break;
+
+ case SDIO_CMD_RSP_136:
+ resp[3] = ((response[7] & 0x3fff) << 8) |
+ ((response[6] & 0x3ff) << 22);
+ resp[2] = ((response[6] & 0xfc00) >> 10) |
+ ((response[5] & 0xffff) << 6) |
+ ((response[4] & 0x3ff) << 22);
+ resp[1] = ((response[4] & 0xfc00) >> 10) |
+ ((response[3] & 0xffff) << 6) |
+ ((response[2] & 0x3ff) << 22);
+ resp[0] = ((response[2] & 0xfc00) >> 10) |
+ ((response[1] & 0xffff) << 6) |
+ ((response[0] & 0x3ff) << 22);
+ break;
+ default:
+ return 0;
+ }
+ int i;
+ pr_debug("MMC resp :");
+ for (i=0; i<4; ++i ) {
+ pr_debug(" %08x", (unsigned int)resp[i]);
+ }
+ pr_debug("\n");
+ if( err )
+ return NULL ;
+ else
+ return resp;
+}
+
+/****************************************************/ +static int mv_mmc_block_read(uchar *dst, ulong src, ulong len) +/****************************************************/
+{
+ ulong *resp;
+
+ if (len == 0) {
+ return 0;
+ }
+
+ if (is_sdhc) {
+ /* SDHC: use block address */
+ src >>= 9;
+ }
+
+ pr_debug("mmc_block_rd dst %lx src %lx len %d\n", (ulong)dst, src,
(int)len);
+
+ /* prepare for dma transfer */
+ writew(((ulong)(dst))&0xffff,SDIO_REG(SDIO_SYS_ADDR_LOW));
+ writew(((ulong)(dst)>>16)&0xffff,SDIO_REG(SDIO_SYS_ADDR_HI));
+ writew(len,SDIO_REG(SDIO_BLK_SIZE));
+ writew(1,SDIO_REG(SDIO_BLK_COUNT));
+
+ /* send read command */
+ resp = mv_mmc_cmd(MMC_CMD_READ_BLOCK, src, 0x10 ,
+ SDIO_CMD_RSP_48, SDIO_NOR_XFER_DONE);
+ if (!resp) {
+ pr_debug("mv_mmc_block_read: mmc read block cmd fails\n");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/****************************************************/
+int mv_mmc_read(ulong src, uchar *dst, int size) +/****************************************************/
+{
+ ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
+ ulong mmc_block_size, mmc_block_address;
+
+ if (size == 0) {
+ return 0;
+ }
+
+ if (!mmc_ready) {
+ printf("Please initial the MMC first\n");
+ return -1;
+ }
+
+ mmc_block_size = MMC_BLOCK_SIZE;
+ mmc_block_address = ~(mmc_block_size - 1);
+
+ end = src + size;
+ part_start = ~mmc_block_address & src;
+ part_end = ~mmc_block_address & end;
+ aligned_start = mmc_block_address & src;
+ aligned_end = mmc_block_address & end;
+
+ /* all block aligned accesses */
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_start) {
+ part_len = mmc_block_size - part_start;
+ pr_debug("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf+part_start, part_len);
+ dst += part_len;
+ src += part_len;
+ }
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ for (; src < aligned_end; aligned_start +=mmc_block_size, src +=
mmc_block_size, dst += mmc_block_size) {
+ pr_debug("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ printf("mmc block read error\n");
+ return -1;
+ }
+ memcpy(dst, mmc_buf, mmc_block_size);
+ }
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_end && src < end) {
+ pr_debug("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf, part_end);
+ }
+ return 0;
+}
+
+/****************************************************/ +static ulong mv_mmc_bread(int dev_num, ulong blknr, ulong blkcnt, ulong *dst) +/****************************************************/
+{
+ int mmc_block_size = MMC_BLOCK_SIZE;
+ ulong src = blknr * mmc_block_size;
+
+ mv_mmc_read(src, (uchar *)dst, blkcnt*mmc_block_size);
+ return blkcnt;
+}
+
+/****************************************************/
+int mmc_legacy_init(int verbose) +/****************************************************/
+{
+ int retries, rc = -ENODEV;
+ ulong *resp;
+ int sd_ver20;
+ int is_sd;
+ ushort reg;
+ uchar cidbuf[64];
+
+ sd_ver20 = 0;
+ is_sdhc = 0;
+ is_sd = 0;
+
+ /* Initial Host Ctrl : Timeout : max , Normal Speed mode, 4-bit data
mode */
+ /* Big Endian, SD memory Card, Push_pull CMD Line */
+ writew( SDIO_HOST_CTRL_TMOUT(0xf) |
+ SDIO_HOST_CTRL_DATA_WIDTH_4_BITS |
+ SDIO_HOST_CTRL_BIG_ENDIAN |
+ SDIO_HOST_CTRL_PUSH_PULL_EN |
+ SDIO_HOST_CTRL_CARD_TYPE_MEM_ONLY ,
+ SDIO_REG(SDIO_HOST_CTRL));
+
+ writew( 0, SDIO_REG(SDIO_CLK_CTRL));
+
+ /* enable status */
+ writew( 0xffff, SDIO_REG(SDIO_NOR_STATUS_EN));
+ writew( 0xffff, SDIO_REG(SDIO_ERR_STATUS_EN));
+
+ /* disable interrupts */
+ writew( 0, SDIO_REG(SDIO_NOR_INTR_EN));
+ writew( 0, SDIO_REG(SDIO_ERR_INTR_EN));
+
+ writew( 0x100, SDIO_REG(SDIO_SW_RESET));
+ udelay(10000);
+
+ mv_mmc_csd.c_size = 0;
+
+ /* reset */
+ retries = 10;
+ resp = mv_mmc_cmd(0, 0, 0, SDIO_CMD_RSP_NONE, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 0 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ pr_debug ("trying to detect SD card version\n");
+
+ resp = mv_mmc_cmd(8, 0x000001aa, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 8 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp && (resp[0] & 0x1ff)==0x1aa) {
+ pr_debug ("SD version 2.0 card detected\n");
+
+ sd_ver20 = 1;
+ }
+
+ if (sd_ver20)
+ retries = 50;
+ else
+ retries = 10;
+
+ while (retries--) {
+ resp = mv_mmc_cmd(55, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 55 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (sd_ver20)
+ resp = mv_mmc_cmd(41, 0x40300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ else
+ resp = mv_mmc_cmd(41, 0x00300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+
+ pr_debug("cmd 41 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ pr_debug ("detected SD card\n");
+
+ is_sd = 1;
+ break;
+ }
+
+ udelay(100*1000);
+ }
+
+ if (retries <= 0 && !is_sd) {
+ pr_debug ("failed to detect SD card, trying MMC\n");
+
+ retries = 10;
+ while (retries--) {
+ resp = mv_mmc_cmd(1, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 01 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ printf ("detected MMC card\n");
+ reg = readw(SDIO_REG(SDIO_HOST_CTRL));
+ reg &= ~(0x3<<1);
+ reg |= SDIO_HOST_CTRL_CARD_TYPE_IO_MMC;
+ writew( reg, SDIO_REG(SDIO_HOST_CTRL));
+ break;
+ }
+
+ udelay(100*1000);
+ }
+ }
+
+ if (retries <= 0) {
+ pr_debug ("detect fails\n");
+
+ return -ENODEV;
+ }
+
+ /* try to get card id */
+ resp = mv_mmc_cmd(2, 0, 0, SDIO_CMD_RSP_136, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 2 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp == NULL) {
+ pr_debug ("read cid fails\n");
+
+ return -ENODEV;
+ }
+
+ if (is_sd) {
+ mv_sd_cid_t *cid = (mv_sd_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x OEM %c%c \"%c%c%c%c%c\"",
+ cid->mid, cid->oid_0, cid->oid_1,
+ cid->pnm_0, cid->pnm_1, cid->pnm_2, cid->pnm_3, cid->pnm_4);
+
+ sprintf((char *) mmc_dev.product, "%d",
+ (cid->psn_0 << 24) | (cid->psn_1 <<16) | (cid->psn_2 << 8) |
(cid->psn_3 << 8));
+
+ sprintf((char *) mmc_dev.revision, "%d.%d", cid->prv>>4, cid->prv &
0xff);
+
+ } else {
+ /* TODO configure mmc driver depending on card attributes */
+ mv_mmc_cid_t *cid = (mv_mmc_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x%02x%02x Snr %02x%02x%02x",
+ cid->id[0], cid->id[1], cid->id[2],
+ cid->sn[0], cid->sn[1], cid->sn[2]);
+ sprintf((char *) mmc_dev.product, "%s", cid->name);
+ sprintf((char *) mmc_dev.revision, "%x %x", cid->hwrev, cid->fwrev);
+ }
+
+ /* fill in device description */
+ mmc_dev.if_type = IF_TYPE_MMC;
+ mmc_dev.part_type = PART_TYPE_DOS;
+ mmc_dev.dev = 0;
+ mmc_dev.lun = 0;
+ mmc_dev.type = 0;
+
+ /* FIXME fill in the correct size (is set to 128MByte) */
+ mmc_dev.blksz = MMC_BLOCK_SIZE;
+ mmc_dev.lba = 0x10000;
+
+ mmc_dev.removable = 0;
+ mmc_dev.block_read = (unsigned long) mv_mmc_bread;
+
+ /* MMC exists, get CSD too */
+ resp = mv_mmc_cmd(MMC_CMD_SET_RCA, 0, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("set rca fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd3 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ if (is_sd)
+ rca = resp[0] >> 16;
+ else
+ rca = 0;
+
+ resp = mv_mmc_cmd(MMC_CMD_SEND_CSD, rca<<16, 0,
SDIO_CMD_RSP_136,SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 9 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp == NULL) {
+ pr_debug ("read csd fails\n");
+
+ return -ENODEV;
+ }
+
+ memcpy(&mv_mmc_csd, (mv_mmc_csd_t *) resp, sizeof(mv_mmc_csd_t));
+ rc = 0;
+ mmc_ready = 1;
+
+ /* FIXME add verbose printout for csd */
+ pr_debug ("size = %u\n", mv_mmc_size(&mv_mmc_csd));
+
+
+ resp = mv_mmc_cmd(7, rca<<16, 0, SDIO_CMD_RSP_48BUSY, SDIO_NOR_CMD_DONE);
+ if (resp == NULL) {
+ pr_debug ("select card fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd 7 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (is_sd) {
+ resp = mv_mmc_cmd(55, rca<<16, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd55 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ resp = mv_mmc_cmd(6, (rca<<16) | 0x2 , 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd6 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+ }
+
+ resp = (ulong *) &mv_mmc_csd;
+ pr_debug("csd: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ /* check SDHC */
+ if ((resp[0]&0xf0000000)==0x40000000)
+ is_sdhc = 1;
+
+ /* set block len */
+ resp = mv_mmc_cmd(MMC_CMD_SET_BLOCKLEN, MMC_BLOCK_SIZE, 0,
SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (!resp) {
+ pr_debug("mv_mmc_block_read: set blk len fails\n");
+ return -ENODEV;
+ }
+
+ if (verbose) {
+ if (is_sd)
+ print_sd_cid((mv_sd_cid_t *) cidbuf);
+ else
+ print_mmc_cid((mv_mmc_cid_t *) cidbuf);
+ }
+
+ mvsdio_set_clock(CONFIG_SYS_MMC_CLK_PP);
+
+ fat_register_device(&mmc_dev,1); /* partitions start counting with 1 */
+
+ return 0;
+}
+
+#endif /* CONFIG_MMC */

1.7.1

There should be some patch explanation here and

Changelog info here..
You can refer some other patches for this, because rest other make it pure driver add patch and this file is pre-requisite requirement by kirkwood SoC to support it, also the patches may be applied by different custodians

(these comments are applicable for all your patches in this patch series)

This should be separate patch

Please move this file to drivers/mmc/ and rename it as mv_sdio.h

pre-requisite for SDIO driver support for Marvell SoCs (Kirkwood) Add SDIO legacy driver for Marvell SoCs (Kirkwood)
Add MMC-SDIO support for Sheevaplug

---
TODO:
* Rewrite the SDIO driver as generic MMC driver

v3:
* GNU Software License compliance
* Patch more readable

v2:
* Code cleaning

v1:
* Fix errors from SD/SDHC detect

G?rald KERMA (3):
Kirkwood: pre-requisite for SDIO driver support mmc : Add SDIO driver for Marvell SoCs (Kirkwood)
Sheevaplug: Add MMC/SDIO support

 arch/arm/include/asm/arch-kirkwood/kirkwood.h |    1 +
 drivers/mmc/Makefile                          |    1 +
 drivers/mmc/mv_sdio.c                         |  675
+++++++++++++++++++++++++
 drivers/mmc/mv_sdio.h                         |  310 ++++++++++++
 include/configs/mv-common.h                   |    9 +
 include/configs/sheevaplug.h                  |    2 +
 6 files changed, 1001 insertions(+), 0 deletions(-)
 create mode 100644 drivers/mmc/mv_sdio.c
 create mode 100644 drivers/mmc/mv_sdio.h

G.K

pre-requisite for SDIO driver support for Marvell SoCs (Kirkwood)

---
 arch/arm/include/asm/arch-kirkwood/kirkwood.h |    1 +
 include/configs/mv-common.h                   |    9 +++++++++
 2 files changed, 10 insertions(+), 0 deletions(-)

b/arch/arm/include/asm/arch-kirkwood/kirkwood.h
index 0104418..4f9fe7e 100644

@@ -60,6 +60,7 @@
 #define KW_EGIGA0_BASE			(KW_REGISTER(0x72000))
 #define KW_EGIGA1_BASE			(KW_REGISTER(0x76000))
 #define KW_SATA_BASE			(KW_REGISTER(0x80000))
+#define KW_SDIO_BASE			(KW_REGISTER(0x90000))
 
 /* Kirkwood Sata controller has two ports */
 #define KW_SATA_PORT0_OFFSET		0x2000

index de0121e..62ef0b9 100644
@@ -63,6 +63,7 @@
 
 #define CONFIG_I2C_MVTWSI_BASE	KW_TWSI_BASE
 #define MV_UART0_BASE		KW_UART0_BASE
+#define MV_SDIO_BASE		KW_SDIO_BASE
 #define MV_SATA_BASE		KW_SATA_BASE
 #define MV_SATA_PORT0_OFFSET	KW_SATA_PORT0_OFFSET
 #define MV_SATA_PORT1_OFFSET	KW_SATA_PORT1_OFFSET

@@ -182,6 +183,14 @@
 #endif /* CONFIG_CMD_NET */
 
 /*
+ * SDIO/MMC Card Configuration
+ */
+#ifdef CONFIG_CMD_MMC
+#define CONFIG_MMC
+#define CONFIG_MV_SDIO
+#endif /* CONFIG_CMD_MMC */
+
+/*
  * USB/EHCI
  */
 #ifdef CONFIG_CMD_USB

1.7.1

-- 
G.K

Add SDIO legacy driver for Marvell SoCs (Kirkwood)

---
v3:
* GNU Software License compliance
* Patch more readable

v2:
* Code cleaning

v1:
* Fix errors from SD/SDHC detect

---
 drivers/mmc/Makefile  |    1 +
 drivers/mmc/mv_sdio.c |  675
+++++++++++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/mv_sdio.h |  313 +++++++++++++++++++++++
 3 files changed, 989 insertions(+), 0 deletions(-)

index 68afd30..2a4e1d4 100644
@@ -30,6 +30,7 @@ COBJS-$(CONFIG_BFIN_SDH) += bfin_sdh.o
 COBJS-$(CONFIG_FSL_ESDHC) += fsl_esdhc.o
 COBJS-$(CONFIG_GENERIC_MMC) += mmc.o
 COBJS-$(CONFIG_GENERIC_ATMEL_MCI) += gen_atmel_mci.o
+COBJS-$(CONFIG_MV_SDIO) += mv_sdio.o
 COBJS-$(CONFIG_MXC_MMC) += mxcmmc.o
 COBJS-$(CONFIG_OMAP3_MMC) += omap3_mmc.o
 COBJS-$(CONFIG_OMAP_HSMMC) += omap_hsmmc.o

resptype, ushort waittype) +/****************************************************/
+{
+ static ulong resp[4];
+ ushort done ;
+ int err = 0 ;
+ ulong curr, start, diff, hz;
+ ushort response[8];
+
+ pr_debug("mv_mmc_cmd %x, arg: %x,xfer: %x,resp: %x, wait : %x\n"
+ , (unsigned int)cmd, (unsigned int)arg, xfermode, resptype, waittype);
+
+
+ /* clear status */
+ writew(0xffff, &mvsd->NOR_INTR_STATUS);
+ writew(0xffff, &mvsd->ERR_INTR_STATUS);
+
+ start = get_timer(0);
+ hz = CONFIG_SYS_HZ;
+
+ while((readw(&mvsd->PRESENT_STATE0) & CARD_BUSY)) {
+ curr = get_timer(0);
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ /* 3 seconds timeout, card busy, can't sent cmd */
+ printf("card too busy \n");
+ return 0;
+ }
+ }
+
+ writew((ushort)(arg&0xffff), &mvsd->ARG_LOW);
+ writew((ushort)(arg>>16), &mvsd->ARG_HI);
+ writew(xfermode, &mvsd->XFER_MODE);
+ if( (cmd == MMC_CMD_READ_BLOCK) || (cmd == 25) )
+ {
+ writew(((cmd << 8) | resptype | 0x3c ) , &mvsd->CMD);
+ pr_debug("cmd reg : %x\n", readw(&mvsd->CMD)) ;
+
+ }
+ else
+ {
+ writew(((cmd << 8) | resptype ), &mvsd->CMD);
+ }
+
+ done = readw(&mvsd->NOR_INTR_STATUS) & waittype;
+ start = get_timer(0);
+
+ while( done!=waittype)
+ {
+ done = readw(&mvsd->NOR_INTR_STATUS) & waittype;
+
+ if( readw(&mvsd->NOR_INTR_STATUS) & 0x8000 )
+ {
+ pr_debug("Error! cmd : %d, err : %04x\n", (unsigned int)cmd,
readw(&mvsd->ERR_INTR_STATUS)) ;
+
+ return 0 ; /* error happen */
+ }
+
+ curr = get_timer(0);
+ diff = (long) curr - (long) start;
+ if (diff > (3*hz))
+ {
+ pr_debug("cmd timeout, status : %04x\n", readw(&mvsd->NOR_INTR_STATUS));
+ pr_debug("xfer mode : %04x\n", readw(&mvsd->XFER_MODE));
+
+ err = 1 ;
+ break;
+ }
+ }
+
+ response[0] = readw(&mvsd->RSP0);
+ response[1] = readw(&mvsd->RSP1);
+ response[2] = readw(&mvsd->RSP2);
+ response[3] = readw(&mvsd->RSP3);
+ response[4] = readw(&mvsd->RSP4);
+ response[5] = readw(&mvsd->RSP5);
+ response[6] = readw(&mvsd->RSP6);
+ response[7] = readw(&mvsd->RSP7);
+
+ memset(resp, 0, sizeof(resp));
+
+ switch (resptype & 0x3) {
+ case SDIO_CMD_RSP_48:
+ case SDIO_CMD_RSP_48BUSY:
+ resp[0] = ((response[2] & 0x3f) << (8 - 8)) |
+ ((response[1] & 0xffff) << (14 - 8)) |
+ ((response[0] & 0x3ff) << (30 - 8));
+ resp[1] = ((response[0] & 0xfc00) >> 10);
+ break;
+
+ case SDIO_CMD_RSP_136:
+ resp[3] = ((response[7] & 0x3fff) << 8) |
+ ((response[6] & 0x3ff) << 22);
+ resp[2] = ((response[6] & 0xfc00) >> 10) |
+ ((response[5] & 0xffff) << 6) |
+ ((response[4] & 0x3ff) << 22);
+ resp[1] = ((response[4] & 0xfc00) >> 10) |
+ ((response[3] & 0xffff) << 6) |
+ ((response[2] & 0x3ff) << 22);
+ resp[0] = ((response[2] & 0xfc00) >> 10) |
+ ((response[1] & 0xffff) << 6) |
+ ((response[0] & 0x3ff) << 22);
+ break;
+ default:
+ return 0;
+ }
+ int i;
+ pr_debug("MMC resp :");
+ for (i=0; i<4; ++i ) {
+ pr_debug(" %08x", (unsigned int)resp[i]);
+ }
+ pr_debug("\n");
+ if( err )
+ return NULL ;
+ else
+ return resp;
+}
+
+/****************************************************/ +static int mv_mmc_block_read(uchar *dst, ulong src, ulong len) +/****************************************************/
+{
+ ulong *resp;
+
+ if (len == 0) {
+ return 0;
+ }
+
+ if (is_sdhc) {
+ /* SDHC: use block address */
+ src >>= 9;
+ }
+
+ pr_debug("mmc_block_rd dst %lx src %lx len %d\n", (ulong)dst, src,
(int)len);
+
+ /* prepare for dma transfer */
+ writew(((ulong)(dst))&0xffff,&mvsd->SYS_ADDR_LOW);
+ writew(((ulong)(dst)>>16)&0xffff,&mvsd->SYS_ADDR_HI);
+ writew(len,&mvsd->BLK_SIZE);
+ writew(1,&mvsd->BLK_COUNT);
+
+ /* send read command */
+ resp = mv_mmc_cmd(MMC_CMD_READ_BLOCK, src, 0x10 ,
+ SDIO_CMD_RSP_48, SDIO_NOR_XFER_DONE);
+ if (!resp) {
+ pr_debug("mv_mmc_block_read: mmc read block cmd fails\n");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/****************************************************/
+int mv_mmc_read(ulong src, uchar *dst, int size) +/****************************************************/
+{
+ ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
+ ulong mmc_block_size, mmc_block_address;
+
+ if (size == 0) {
+ return 0;
+ }
+
+ if (!mmc_ready) {
+ printf("Please initial the MMC first\n");
+ return -1;
+ }
+
+ mmc_block_size = MMC_BLOCK_SIZE;
+ mmc_block_address = ~(mmc_block_size - 1);
+
+ end = src + size;
+ part_start = ~mmc_block_address & src;
+ part_end = ~mmc_block_address & end;
+ aligned_start = mmc_block_address & src;
+ aligned_end = mmc_block_address & end;
+
+ /* all block aligned accesses */
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_start) {
+ part_len = mmc_block_size - part_start;
+ pr_debug("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf+part_start, part_len);
+ dst += part_len;
+ src += part_len;
+ }
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ for (; src < aligned_end; aligned_start +=mmc_block_size, src +=
mmc_block_size, dst += mmc_block_size) {
+ pr_debug("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) < 0) {
+ printf("mmc block read error\n");
+ return -1;
+ }
+ memcpy(dst, mmc_buf, mmc_block_size);
+ }
+ pr_debug("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend
%lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if (part_end && src < end) {
+ pr_debug("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx
aend %lx\n",
+ (long unsigned int)src,(ulong)dst, end, part_start, part_end,
aligned_start, aligned_end);
+
+ if ((mv_mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
+ return -1;
+ }
+ memcpy(dst, mmc_buf, part_end);
+ }
+ return 0;
+}
+
+/****************************************************/ +static ulong mv_mmc_bread(int dev_num, ulong blknr, ulong blkcnt, ulong *dst) +/****************************************************/
+{
+ int mmc_block_size = MMC_BLOCK_SIZE;
+ ulong src = blknr * mmc_block_size;
+
+ mv_mmc_read(src, (uchar *)dst, blkcnt*mmc_block_size);
+ return blkcnt;
+}
+
+/****************************************************/
+int mmc_legacy_init(int verbose) +/****************************************************/
+{
+ int retries, rc = -ENODEV;
+ ulong *resp;
+ int sd_ver20;
+ int is_sd;
+ ushort reg;
+ uchar cidbuf[64];
+
+ sd_ver20 = 0;
+ is_sdhc = 0;
+ is_sd = 0;
+
+ /* Initial Host Ctrl : Timeout : max , Normal Speed mode, 4-bit data
mode */
+ /* Big Endian, SD memory Card, Push_pull CMD Line */
+ writew( SDIO_HOST_CTRL_TMOUT(0xf) |
+ SDIO_HOST_CTRL_DATA_WIDTH_4_BITS |
+ SDIO_HOST_CTRL_BIG_ENDIAN |
+ SDIO_HOST_CTRL_PUSH_PULL_EN |
+ SDIO_HOST_CTRL_CARD_TYPE_MEM_ONLY ,
+ &mvsd->HOST_CTRL);
+
+ writew( 0, &mvsd->CLK_CTRL);
+
+ /* enable status */
+ writew( 0xffff, &mvsd->NOR_STATUS_EN);
+ writew( 0xffff, &mvsd->ERR_STATUS_EN);
+
+ /* disable interrupts */
+ writew( 0, &mvsd->NOR_INTR_EN);
+ writew( 0, &mvsd->ERR_INTR_EN);
+
+ writew( 0x100, &mvsd->SW_RESET);
+ udelay(10000);
+
+ mv_mmc_csd.c_size = 0;
+
+ /* reset */
+ retries = 10;
+ resp = mv_mmc_cmd(0, 0, 0, SDIO_CMD_RSP_NONE, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 0 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ pr_debug ("trying to detect SD card version\n");
+
+ resp = mv_mmc_cmd(8, 0x000001aa, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 8 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp && (resp[0] & 0x1ff)==0x1aa) {
+ pr_debug ("SD version 2.0 card detected\n");
+
+ sd_ver20 = 1;
+ }
+
+ if (sd_ver20)
+ retries = 50;
+ else
+ retries = 10;
+
+ while (retries--) {
+ resp = mv_mmc_cmd(55, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 55 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (sd_ver20)
+ resp = mv_mmc_cmd(41, 0x40300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ else
+ resp = mv_mmc_cmd(41, 0x00300000, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+
+ pr_debug("cmd 41 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ pr_debug ("detected SD card\n");
+
+ is_sd = 1;
+ break;
+ }
+
+ udelay(100*1000);
+ }
+
+ if (retries <= 0 && !is_sd) {
+ pr_debug ("failed to detect SD card, trying MMC\n");
+
+ retries = 10;
+ while (retries--) {
+ resp = mv_mmc_cmd(1, 0, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 01 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp && (resp[0] & 0x80000000)) {
+ printf ("detected MMC card\n");
+ reg = readw(&mvsd->HOST_CTRL);
+ reg &= ~(0x3<<1);
+ reg |= SDIO_HOST_CTRL_CARD_TYPE_IO_MMC;
+ writew( reg, &mvsd->HOST_CTRL);
+ break;
+ }
+
+ udelay(100*1000);
+ }
+ }
+
+ if (retries <= 0) {
+ pr_debug ("detect fails\n");
+
+ return -ENODEV;
+ }
+
+ /* try to get card id */
+ resp = mv_mmc_cmd(2, 0, 0, SDIO_CMD_RSP_136, SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 2 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (resp == NULL) {
+ pr_debug ("read cid fails\n");
+
+ return -ENODEV;
+ }
+
+ if (is_sd) {
+ mv_sd_cid_t *cid = (mv_sd_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x OEM %c%c \"%c%c%c%c%c\"",
+ cid->mid, cid->oid_0, cid->oid_1,
+ cid->pnm_0, cid->pnm_1, cid->pnm_2, cid->pnm_3, cid->pnm_4);
+
+ sprintf((char *) mmc_dev.product, "%d",
+ (cid->psn_0 << 24) | (cid->psn_1 <<16) | (cid->psn_2 << 8) |
(cid->psn_3 << 8));
+
+ sprintf((char *) mmc_dev.revision, "%d.%d", cid->prv>>4, cid->prv &
0xff);
+
+ } else {
+ /* TODO configure mmc driver depending on card attributes */
+ mv_mmc_cid_t *cid = (mv_mmc_cid_t *) resp;
+
+ memcpy(cidbuf, resp, sizeof(mv_sd_cid_t));
+
+
+ sprintf((char *) mmc_dev.vendor,
+ "Man %02x%02x%02x Snr %02x%02x%02x",
+ cid->id[0], cid->id[1], cid->id[2],
+ cid->sn[0], cid->sn[1], cid->sn[2]);
+ sprintf((char *) mmc_dev.product, "%s", cid->name);
+ sprintf((char *) mmc_dev.revision, "%x %x", cid->hwrev, cid->fwrev);
+ }
+
+ /* fill in device description */
+ mmc_dev.if_type = IF_TYPE_MMC;
+ mmc_dev.part_type = PART_TYPE_DOS;
+ mmc_dev.dev = 0;
+ mmc_dev.lun = 0;
+ mmc_dev.type = 0;
+
+ /* FIXME fill in the correct size (is set to 128MByte) */
+ mmc_dev.blksz = MMC_BLOCK_SIZE;
+ mmc_dev.lba = 0x10000;
+
+ mmc_dev.removable = 0;
+ mmc_dev.block_read = (unsigned long) mv_mmc_bread;
+
+ /* MMC exists, get CSD too */
+ resp = mv_mmc_cmd(MMC_CMD_SET_RCA, 0, 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("set rca fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd3 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ if (is_sd)
+ rca = resp[0] >> 16;
+ else
+ rca = 0;
+
+ resp = mv_mmc_cmd(MMC_CMD_SEND_CSD, rca<<16, 0,
SDIO_CMD_RSP_136,SDIO_NOR_CMD_DONE );
+ pr_debug("cmd 9 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+ if (resp == NULL) {
+ pr_debug ("read csd fails\n");
+
+ return -ENODEV;
+ }
+
+ memcpy(&mv_mmc_csd, (mv_mmc_csd_t *) resp, sizeof(mv_mmc_csd_t));
+ rc = 0;
+ mmc_ready = 1;
+
+ /* FIXME add verbose printout for csd */
+ pr_debug ("size = %u\n", mv_mmc_size(&mv_mmc_csd));
+
+
+ resp = mv_mmc_cmd(7, rca<<16, 0, SDIO_CMD_RSP_48BUSY, SDIO_NOR_CMD_DONE);
+ if (resp == NULL) {
+ pr_debug ("select card fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd 7 resp : %08x %08x %08x %08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3] );
+
+
+ if (is_sd) {
+ resp = mv_mmc_cmd(55, rca<<16, 0, SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd55 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ resp = mv_mmc_cmd(6, (rca<<16) | 0x2 , 0, SDIO_CMD_RSP_48,
SDIO_NOR_CMD_DONE );
+ if (resp == NULL) {
+ pr_debug ("cmd55 fails\n");
+
+ return -ENODEV;
+ }
+ pr_debug("cmd6 resp : 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+ }
+
+ resp = (ulong *) &mv_mmc_csd;
+ pr_debug("csd: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ (unsigned int)resp[0], (unsigned int)resp[1], (unsigned int)resp[2],
(unsigned int)resp[3]);
+
+
+ /* check SDHC */
+ if ((resp[0]&0xf0000000)==0x40000000)
+ is_sdhc = 1;
+
+ /* set block len */
+ resp = mv_mmc_cmd(MMC_CMD_SET_BLOCKLEN, MMC_BLOCK_SIZE, 0,
SDIO_CMD_RSP_48, SDIO_NOR_CMD_DONE );
+ if (!resp) {
+ pr_debug("mv_mmc_block_read: set blk len fails\n");
+ return -ENODEV;
+ }
+
+ if (verbose) {
+ if (is_sd)
+ print_sd_cid((mv_sd_cid_t *) cidbuf);
+ else
+ print_mmc_cid((mv_mmc_cid_t *) cidbuf);
+ }
+
+ mvsdio_set_clock(CONFIG_SYS_MMC_CLK_PP);
+
+ fat_register_device(&mmc_dev,1); /* partitions start counting with 1 */
+
+ return 0;
+}
+
+#endif /* CONFIG_MMC */

1.7.1

Can you make use of drivers/mmc/mmc.c to reduce code in this file?

Add MMC-SDIO support for Sheevaplug

---
 include/configs/sheevaplug.h |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

index 83dd8ff..5448718 100644
@@ -1,3 +1,4 @@
+
 /*
  * (C) Copyright 2009
  * Marvell Semiconductor <www.marvell.com>

@@ -47,6 +48,7 @@
 #define CONFIG_CMD_DHCP
 #define CONFIG_CMD_ENV
 #define CONFIG_CMD_MII
+#define CONFIG_CMD_MMC
 #define CONFIG_CMD_NAND
 #define CONFIG_CMD_PING
 #define CONFIG_CMD_USB

1.7.1

---
 include/configs/sheevaplug.h |    9 +++++++++
 1 files changed, 9 insertions(+), 0 deletions(-)

index 83dd8ff..b944ec7 100644
@@ -47,6 +47,7 @@
 #define CONFIG_CMD_DHCP
 #define CONFIG_CMD_ENV
 #define CONFIG_CMD_MII
+#define CONFIG_CMD_MMC
 #define CONFIG_CMD_NAND
 #define CONFIG_CMD_PING
 #define CONFIG_CMD_USB

@@ -90,6 +91,14 @@
 	"x_bootargs_root=root=/dev/mtdblock3 rw rootfstype=jffs2\0"
 
 /*
+ * SDIO/MMC Card Configuration
+ */
+#ifdef CONFIG_CMD_MMC
+#define CONFIG_MMC
+#define CONFIG_MV_SDIO
+#endif /* CONFIG_CMD_MMC */
+
+/*
  * Ethernet Driver configuration
  */
 #ifdef CONFIG_CMD_NET

1.7.1

---
 include/configs/sheevaplug.h |   29 +++++++++++++++++++++++++++++
 1 files changed, 29 insertions(+), 0 deletions(-)

index b944ec7..82e49c0 100644
@@ -46,6 +46,7 @@
 #include <config_cmd_default.h>
 #define CONFIG_CMD_DHCP
 #define CONFIG_CMD_ENV
+#define CONFIG_CMD_IDE
 #define CONFIG_CMD_MII
 #define CONFIG_CMD_MMC
 #define CONFIG_CMD_NAND

@@ -107,6 +108,34 @@
 #endif /* CONFIG_CMD_NET */
 
 /*
+ * IDE Support on SATA port0
+ */
+#ifdef CONFIG_CMD_IDE
+#define __io
+#define CONFIG_CMD_EXT2
+#define CONFIG_MVSATA_IDE
+#define CONFIG_IDE_PREINIT
+#define CONFIG_MVSATA_IDE_USE_PORT0
+/* Needs byte-swapping for ATA data register */
+#define CONFIG_IDE_SWAP_IO
+/* Data, registers and alternate blocks are at the same offset */
+#define CONFIG_SYS_ATA_DATA_OFFSET	(0x0100)
+#define CONFIG_SYS_ATA_REG_OFFSET	(0x0100)
+#define CONFIG_SYS_ATA_ALT_OFFSET	(0x0100)
+/* Each 8-bit ATA register is aligned to a 4-bytes address */
+#define CONFIG_SYS_ATA_STRIDE		4
+/* Controller supports 48-bits LBA addressing */
+#define CONFIG_LBA48
+/* CONFIG_CMD_IDE requires some #defines for ATA registers */
+#define CONFIG_SYS_IDE_MAXBUS		1
+#define CONFIG_SYS_IDE_MAXDEVICE	1
+/* ATA registers base is at SATA controller base */
+#define CONFIG_SYS_ATA_BASE_ADDR	KW_SATA_BASE
+/* ATA bus 0 is Kirkwood port 1 on sheevaplug */
+#define CONFIG_SYS_ATA_IDE0_OFFSET	KW_SATA_PORT1_OFFSET
+#endif /* CONFIG_CMD_IDE */
+
+/*
  * File system
  */
 #define CONFIG_CMD_EXT2

1.7.1

---
 include/configs/sheevaplug.h |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

index 82e49c0..9f5f122 100644
@@ -83,13 +83,13 @@
 	"${x_bootcmd_usb}; bootm 0x6400000;"
 
 #define CONFIG_MTDPARTS		"orion_nand:512k(uboot),"	\
-	"3m at 1m(kernel),1m at 4m(psm),13m at 5m(rootfs) rw\0"
+	"3m at 1m(kernel),1m at 4m(psm),507m at 5m(rootfs) rw\0"
 
 #define CONFIG_EXTRA_ENV_SETTINGS	"x_bootargs=console"	\
 	"=ttyS0,115200 mtdparts="CONFIG_MTDPARTS	\
 	"x_bootcmd_kernel=nand read 0x6400000 0x100000 0x300000\0" \
 	"x_bootcmd_usb=usb start\0" \
-	"x_bootargs_root=root=/dev/mtdblock3 rw rootfstype=jffs2\0"
+	"x_bootargs_root=ubi.mtd=3 root=ubi0:rootfs rootfstype=ubifs\0"
 
 /*
  * SDIO/MMC Card Configuration

1.7.1

Hi,

Guruplug and Sheevaplug are two different boards with h/w diffs, We have introduced mv-common.h for this,

There are some early sheevaplug versions (without wifi), this patch may help for it.

Regards..
Prafulla ..