Subversion Repositories sd_card_controller

/*
 * Copyright 2008, Freescale Semiconductor, Inc
 * Andy Fleming
 *
 * Based vaguely on the Linux code
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */
 
#include "mmc.h"
#include <stdio.h>
#include <string.h>
 
void udelay(int t) {
#define US_DELAY 100
	volatile int us = US_DELAY;
	while(t--) {
		us = US_DELAY;
		while(us--);
	}
}
 
/* frequency bases */
/* divided by 10 to be nice to platforms without floating point */
static const int fbase[] = {
	10000,
	100000,
	1000000,
	10000000,
};
 
/* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 * to platforms without floating point.
 */
static const int multipliers[] = {
	0,	/* reserved */
	10,
	12,
	13,
	15,
	20,
	25,
	30,
	35,
	40,
	45,
	50,
	55,
	60,
	70,
	80,
};
 
static void mmc_set_ios(struct mmc *mmc)
{
	mmc->set_ios(mmc);
}
 
static void mmc_set_bus_width(struct mmc *mmc, uint width)
{
	mmc->bus_width = width;
 
	mmc_set_ios(mmc);
}
 
static void mmc_set_clock(struct mmc *mmc, uint clock)
{
	if (clock > mmc->f_max)
		clock = mmc->f_max;
 
	if (clock < mmc->f_min)
		clock = mmc->f_min;
 
	mmc->clock = clock;
 
	mmc_set_ios(mmc);
}
 
static int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
{
	int ret;
 
	ret = mmc->send_cmd(mmc, cmd, data);
 
	return ret;
}
 
static int mmc_go_idle(struct mmc* mmc)
{
	struct mmc_cmd cmd;
	int err;
 
	udelay(1000);
 
	cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
	cmd.cmdarg = 0;
	cmd.resp_type = MMC_RSP_NONE;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	udelay(2000);
 
	return 0;
}
 
static int mmc_send_if_cond(struct mmc *mmc)
{
	struct mmc_cmd cmd;
	int err;
 
	cmd.cmdidx = SD_CMD_SEND_IF_COND;
	/* We set the bit if the host supports voltages between 2.7 and 3.6 V */
	cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
	cmd.resp_type = MMC_RSP_R7;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	if ((cmd.response[0] & 0xff) != 0xaa)
		return UNUSABLE_ERR;
	else
		mmc->version = SD_VERSION_2;
 
	return 0;
}
 
static int sd_send_op_cond(struct mmc *mmc)
{
	int timeout = 1000;
	int err;
	struct mmc_cmd cmd;
 
	do {
		cmd.cmdidx = MMC_CMD_APP_CMD;
		cmd.resp_type = MMC_RSP_R1;
		cmd.cmdarg = 0;
 
		err = mmc_send_cmd(mmc, &cmd, NULL);
 
		if (err)
			return err;
 
		cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
		cmd.resp_type = MMC_RSP_R3;
 
		/*
		 * Most cards do not answer if some reserved bits
		 * in the ocr are set. However, Some controller
		 * can set bit 7 (reserved for low voltages), but
		 * how to manage low voltages SD card is not yet
		 * specified.
		 */
		cmd.cmdarg = (mmc->voltages & 0xff8000);
 
		if (mmc->version == SD_VERSION_2)
			cmd.cmdarg |= OCR_HCS;
 
		err = mmc_send_cmd(mmc, &cmd, NULL);
 
		if (err)
			return err;
 
		udelay(1000);
	} while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 
	if (timeout <= 0)
		return UNUSABLE_ERR;
 
	if (mmc->version != SD_VERSION_2)
		mmc->version = SD_VERSION_1_0;
 
	mmc->ocr = cmd.response[0];
 
	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
	mmc->rca = 0;
 
	return 0;
}
 
static int mmc_send_op_cond(struct mmc *mmc)
{
	int timeout = 10000;
	struct mmc_cmd cmd;
	int err;
 
	/* Some cards seem to need this */
	mmc_go_idle(mmc);
 
 	/* Asking to the card its capabilities */
 	cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 	cmd.resp_type = MMC_RSP_R3;
 	cmd.cmdarg = 0;
 
 	err = mmc_send_cmd(mmc, &cmd, NULL);
 
 	if (err)
 		return err;
 
 	udelay(1000);
 
	do {
		cmd.cmdidx = MMC_CMD_SEND_OP_COND;
		cmd.resp_type = MMC_RSP_R3;
		cmd.cmdarg =
				(mmc->voltages &
				(cmd.response[0] & OCR_VOLTAGE_MASK)) |
				(cmd.response[0] & OCR_ACCESS_MODE);
 
		if (mmc->host_caps & MMC_MODE_HC)
			cmd.cmdarg |= OCR_HCS;
 
		err = mmc_send_cmd(mmc, &cmd, NULL);
 
		if (err)
			return err;
 
		udelay(1000);
	} while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 
	if (timeout <= 0)
		return UNUSABLE_ERR;
 
	mmc->version = MMC_VERSION_UNKNOWN;
	mmc->ocr = cmd.response[0];
 
	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
	mmc->rca = 0;
 
	return 0;
}
 
static int mmc_send_status(struct mmc *mmc, int timeout)
{
	struct mmc_cmd cmd;
	int err, retries = 5;
 
	cmd.cmdidx = MMC_CMD_SEND_STATUS;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = mmc->rca << 16;
 
	do {
		err = mmc_send_cmd(mmc, &cmd, NULL);
		if (!err) {
			if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
			    (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
			     MMC_STATE_PRG)
				break;
			else if (cmd.response[0] & MMC_STATUS_MASK) {
				printf("Status Error: 0x%08X\n\r",
					cmd.response[0]);
				return COMM_ERR;
			}
		} else if (--retries < 0)
			return err;
 
		udelay(1000);
 
	} while (timeout--);
 
	if (timeout <= 0) {
		printf("Timeout waiting card ready\n\r");
		return TIMEOUT;
	}
 
	return 0;
}
 
static int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
{
	struct mmc_cmd cmd;
	struct mmc_data data;
	int err;
 
	/* Get the Card Status Register */
	cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = 0;
 
	data.dest = (char *)ext_csd;
	data.blocks = 1;
	data.blocksize = 512;
	data.flags = MMC_DATA_READ;
 
	err = mmc_send_cmd(mmc, &cmd, &data);
 
	return err;
}
 
static int mmc_switch(struct mmc *mmc, char set, char index, char value)
{
	struct mmc_cmd cmd;
	int timeout = 1000;
	int ret;
 
	cmd.cmdidx = MMC_CMD_SWITCH;
	cmd.resp_type = MMC_RSP_R1b;
	cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
				 (index << 16) |
				 (value << 8);
 
	ret = mmc_send_cmd(mmc, &cmd, NULL);
 
	/* Waiting for the ready status */
	if (!ret)
		ret = mmc_send_status(mmc, timeout);
 
	return ret;
 
}
 
static int sd_switch(struct mmc *mmc, int mode, int group, char value, char *resp)
{
	struct mmc_cmd cmd;
	struct mmc_data data;
 
	/* Switch the frequency */
	cmd.cmdidx = SD_CMD_SWITCH_FUNC;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = (mode << 31) | 0xffffff;
	cmd.cmdarg &= ~(0xf << (group * 4));
	cmd.cmdarg |= value << (group * 4);
 
	data.dest = (char *)resp;
	data.blocksize = 64;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;
 
	return mmc_send_cmd(mmc, &cmd, &data);
}
 
static int sd_change_freq(struct mmc *mmc)
{
	int err;
	struct mmc_cmd cmd;
	uint scr[2];
	uint switch_status[16];
	struct mmc_data data;
	int timeout;
 
	mmc->card_caps = 0;
 
	/* Read the SCR to find out if this card supports higher speeds */
	cmd.cmdidx = MMC_CMD_APP_CMD;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = mmc->rca << 16;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	cmd.cmdidx = SD_CMD_APP_SEND_SCR;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = 0;
 
	timeout = 3;
 
retry_scr:
	data.dest = (char *)scr;
	data.blocksize = 8;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;
 
	err = mmc_send_cmd(mmc, &cmd, &data);
 
	if (err) {
		if (timeout--)
			goto retry_scr;
 
		return err;
	}
 
	mmc->scr[0] = scr[0];
	mmc->scr[1] = scr[1];
 
	printf("SCR: %08x\n\r", mmc->scr[0]);
	printf("     %08x\n\r", mmc->scr[1]);
 
	switch ((mmc->scr[0] >> 24) & 0xf) {
		case 0:
			mmc->version = SD_VERSION_1_0;
			break;
		case 1:
			mmc->version = SD_VERSION_1_10;
			break;
		case 2:
			mmc->version = SD_VERSION_2;
			break;
		default:
			mmc->version = SD_VERSION_1_0;
			break;
	}
 
	if (mmc->scr[0] & SD_DATA_4BIT)
		mmc->card_caps |= MMC_MODE_4BIT;
 
	/* Version 1.0 doesn't support switching */
	if (mmc->version == SD_VERSION_1_0)
		return 0;
 
	timeout = 4;
	while (timeout--) {
		err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
				(char *)switch_status);
 
		if (err)
			return err;
 
		printf("switch status 7 %08x\n\r", switch_status[7]);
		printf("switch status 3 %08x\n\r", switch_status[3]);
		printf("switch status 4 %08x\n\r", switch_status[4]);
		/* The high-speed function is busy.  Try again */
		if (!(switch_status[7] & SD_HIGHSPEED_BUSY))
			break;
	}
 
	/* If high-speed isn't supported, we return */
	if (!(switch_status[3] & SD_HIGHSPEED_SUPPORTED))
		return 0;
 
	/*
	 * If the host doesn't support SD_HIGHSPEED, do not switch card to
	 * HIGHSPEED mode even if the card support SD_HIGHSPPED.
	 * This can avoid furthur problem when the card runs in different
	 * mode between the host.
	 */
	if (!((mmc->host_caps & MMC_MODE_HS_52MHz) &&
		(mmc->host_caps & MMC_MODE_HS)))
		return 0;
 
	err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (char *)switch_status);
 
	if (err)
		return err;
 
	if ((switch_status[4] & 0x0f000000) == 0x01000000)
		mmc->card_caps |= MMC_MODE_HS;
 
	return 0;
}
 
static int mmc_change_freq(struct mmc *mmc)
{
	char ext_csd[512];
	char cardtype;
	int err;
 
	mmc->card_caps = 0;
 
	/* Only version 4 supports high-speed */
	if (mmc->version < MMC_VERSION_4)
		return 0;
 
	err = mmc_send_ext_csd(mmc, ext_csd);
 
	if (err)
		return err;
 
	cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
 
	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 
	if (err)
		return err;
 
	/* Now check to see that it worked */
	err = mmc_send_ext_csd(mmc, ext_csd);
 
	if (err)
		return err;
 
	/* No high-speed support */
	if (!ext_csd[EXT_CSD_HS_TIMING])
		return 0;
 
	/* High Speed is set, there are two types: 52MHz and 26MHz */
	if (cardtype & MMC_HS_52MHZ)
		mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
	else
		mmc->card_caps |= MMC_MODE_HS;
 
	return 0;
}
 
static int mmc_startup(struct mmc *mmc)
{
	int err, width;
	uint mult, freq;
	uint cmult, csize, capacity;
	struct mmc_cmd cmd;
	char ext_csd[512];
	char test_csd[512];
	int timeout = 1000;
 
	/* Put the Card in Identify Mode */
	cmd.cmdidx = MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
	cmd.resp_type = MMC_RSP_R2;
	cmd.cmdarg = 0;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	memcpy(mmc->cid, cmd.response, 16);
 
	/*
	 * For MMC cards, set the Relative Address.
	 * For SD cards, get the Relatvie Address.
	 * This also puts the cards into Standby State
	 */
	cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
	cmd.cmdarg = mmc->rca << 16;
	cmd.resp_type = MMC_RSP_R6;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	if (IS_SD(mmc))
		mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 
	/* Get the Card-Specific Data */
	cmd.cmdidx = MMC_CMD_SEND_CSD;
	cmd.resp_type = MMC_RSP_R2;
	cmd.cmdarg = mmc->rca << 16;
 
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	/* Waiting for the ready status */
	mmc_send_status(mmc, timeout);
 
	if (err)
		return err;
 
	mmc->csd[0] = cmd.response[0];
	mmc->csd[1] = cmd.response[1];
	mmc->csd[2] = cmd.response[2];
	mmc->csd[3] = cmd.response[3];
 
	if (mmc->version == MMC_VERSION_UNKNOWN) {
		int version = (cmd.response[0] >> 26) & 0xf;
 
		switch (version) {
			case 0:
				mmc->version = MMC_VERSION_1_2;
				break;
			case 1:
				mmc->version = MMC_VERSION_1_4;
				break;
			case 2:
				mmc->version = MMC_VERSION_2_2;
				break;
			case 3:
				mmc->version = MMC_VERSION_3;
				break;
			case 4:
				mmc->version = MMC_VERSION_4;
				break;
			default:
				mmc->version = MMC_VERSION_1_2;
				break;
		}
	}
 
	/* divide frequency by 10, since the mults are 10x bigger */
	freq = fbase[(cmd.response[0] & 0x7)];
	mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 
	mmc->tran_speed = freq * mult;
 
	mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 
	if (IS_SD(mmc))
		mmc->write_bl_len = mmc->read_bl_len;
	else
		mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 
	if (mmc->high_capacity) {
		csize = (mmc->csd[1] & 0x3f) << 16
			| (mmc->csd[2] & 0xffff0000) >> 16;
		cmult = 8;
	} else {
		csize = (mmc->csd[1] & 0x3ff) << 2
			| (mmc->csd[2] & 0xc0000000) >> 30;
		cmult = (mmc->csd[2] & 0x00038000) >> 15;
	}
 
	mmc->capacity = (csize + 1) << (cmult + 2);
	mmc->capacity *= mmc->read_bl_len;
 
	if (mmc->read_bl_len > 512)
		mmc->read_bl_len = 512;
 
	if (mmc->write_bl_len > 512)
		mmc->write_bl_len = 512;
 
	/* Select the card, and put it into Transfer Mode */
	cmd.cmdidx = MMC_CMD_SELECT_CARD;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = mmc->rca << 16;
	err = mmc_send_cmd(mmc, &cmd, NULL);
 
	if (err)
		return err;
 
	/*
	 * For SD, its erase group is always one sector
	 */
	mmc->erase_grp_size = 1;
	mmc->part_config = MMCPART_NOAVAILABLE;
	if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
		/* check  ext_csd version and capacity */
		err = mmc_send_ext_csd(mmc, ext_csd);
		if (!err & (ext_csd[EXT_CSD_REV] >= 2)) {
			/*
			 * According to the JEDEC Standard, the value of
			 * ext_csd's capacity is valid if the value is more
			 * than 2GB
			 */
			capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
					| ext_csd[EXT_CSD_SEC_CNT + 1] << 8
					| ext_csd[EXT_CSD_SEC_CNT + 2] << 16
					| ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
			capacity *= 512;
			if ((capacity >> 20) > 2 * 1024)
				mmc->capacity = capacity;
		}
 
		/*
		 * Check whether GROUP_DEF is set, if yes, read out
		 * group size from ext_csd directly, or calculate
		 * the group size from the csd value.
		 */
		if (ext_csd[EXT_CSD_ERASE_GROUP_DEF])
			mmc->erase_grp_size =
			      ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024;
		else {
			int erase_gsz, erase_gmul;
			erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
			erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
			mmc->erase_grp_size = (erase_gsz + 1)
				* (erase_gmul + 1);
		}
 
		/* store the partition info of emmc */
		if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
		    ext_csd[EXT_CSD_BOOT_MULT])
			mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
	}
 
	if (IS_SD(mmc))
		err = sd_change_freq(mmc);
	else
		err = mmc_change_freq(mmc);
 
	if (err)
		return err;
 
	/* Restrict card's capabilities by what the host can do */
	mmc->card_caps &= mmc->host_caps;
 
	if (IS_SD(mmc)) {
		if (mmc->card_caps & MMC_MODE_4BIT) {
			cmd.cmdidx = MMC_CMD_APP_CMD;
			cmd.resp_type = MMC_RSP_R1;
			cmd.cmdarg = mmc->rca << 16;
 
			err = mmc_send_cmd(mmc, &cmd, NULL);
			if (err)
				return err;
 
			cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
			cmd.resp_type = MMC_RSP_R1;
			cmd.cmdarg = 2;
			err = mmc_send_cmd(mmc, &cmd, NULL);
			if (err)
				return err;
 
			mmc_set_bus_width(mmc, 4);
		}
 
		if (mmc->card_caps & MMC_MODE_HS)
			mmc->tran_speed = 50000000;
		else
			mmc->tran_speed = 25000000;
	} else {
		width = ((mmc->host_caps & MMC_MODE_MASK_WIDTH_BITS) >>
			 MMC_MODE_WIDTH_BITS_SHIFT);
		for (; width >= 0; width--) {
			/* Set the card to use 4 bit*/
			err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
					EXT_CSD_BUS_WIDTH, width);
 
			if (err)
				continue;
 
			if (!width) {
				mmc_set_bus_width(mmc, 1);
				break;
			} else
				mmc_set_bus_width(mmc, 4 * width);
 
			err = mmc_send_ext_csd(mmc, test_csd);
			if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
				    == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
				 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
				    == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
				 && ext_csd[EXT_CSD_REV] \
				    == test_csd[EXT_CSD_REV]
				 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
				    == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
				 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
					&test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
 
				mmc->card_caps |= width;
				break;
			}
		}
 
		if (mmc->card_caps & MMC_MODE_HS) {
			if (mmc->card_caps & MMC_MODE_HS_52MHz)
				mmc->tran_speed = 52000000;
			else
				mmc->tran_speed = 26000000;
		}
	}
 
	mmc_set_clock(mmc, mmc->tran_speed);
 
	return 0;
}
 
static int mmc_set_blocklen(struct mmc *mmc, int len)
{
	struct mmc_cmd cmd;
 
	cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
	cmd.resp_type = MMC_RSP_R1;
	cmd.cmdarg = len;
 
	return mmc_send_cmd(mmc, &cmd, NULL);
}
 
static int mmc_read_blocks(struct mmc *mmc, void *dst, size_t start, size_t blkcnt)
{
	struct mmc_cmd cmd;
	struct mmc_data data;
 
	if (blkcnt > 1)
		cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
	else
		cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
 
	if (mmc->high_capacity)
		cmd.cmdarg = start;
	else
		cmd.cmdarg = start * mmc->read_bl_len;
 
	cmd.resp_type = MMC_RSP_R1;
 
	data.dest = dst;
	data.blocks = blkcnt;
	data.blocksize = mmc->read_bl_len;
	data.flags = MMC_DATA_READ;
 
	if (mmc_send_cmd(mmc, &cmd, &data))
		return 0;
 
	if (blkcnt > 1) {
		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
		cmd.cmdarg = 0;
		cmd.resp_type = MMC_RSP_R1b;
		if (mmc_send_cmd(mmc, &cmd, NULL)) {
			printf("mmc fail to send stop cmd\n");
			return 0;
		}
	}
 
	return blkcnt;
}
 
int mmc_init(struct mmc *mmc)
{
	int err;
 
	if (mmc->has_init)
		return 0;
 
	err = mmc->init(mmc);
 
	if (err)
		return err;
 
	mmc_set_bus_width(mmc, 1);
	mmc_set_clock(mmc, 1);
 
	/* Reset the Card */
	err = mmc_go_idle(mmc);
 
	if (err)
		return err;
 
	/* The internal partition reset to user partition(0) at every CMD0*/
	mmc->part_num = 0;
 
	/* Test for SD version 2 */
	err = mmc_send_if_cond(mmc);
 
	/* Now try to get the SD card's operating condition */
	err = sd_send_op_cond(mmc);
 
	/* If the command timed out, we check for an MMC card */
	if (err == TIMEOUT) {
		err = mmc_send_op_cond(mmc);
 
		if (err) {
			printf("Card did not respond to voltage select!\n\r");
			return UNUSABLE_ERR;
		}
	}
 
	err = mmc_startup(mmc);
	if (err)
		mmc->has_init = 0;
	else
		mmc->has_init = 1;
	return err;
}
 
size_t mmc_bread(struct mmc *mmc, size_t start, size_t blkcnt, void *dst)
{
	size_t cur, blocks_todo = blkcnt;
 
	if (blkcnt == 0)
		return 0;
 
	if ((start + blkcnt) > mmc->capacity / mmc->read_bl_len) {
		printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
			start + blkcnt, mmc->capacity / mmc->read_bl_len);
		return 0;
	}
 
	if (mmc_set_blocklen(mmc, mmc->read_bl_len))
		return 0;
 
	do {
		cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
		if(mmc_read_blocks(mmc, dst, start, cur) != cur)
			return 0;
		blocks_todo -= cur;
		start += cur;
		dst += cur * mmc->read_bl_len;
	} while (blocks_todo > 0);
 
	return blkcnt;
}
 
void print_mmcinfo(struct mmc *mmc)
{
	printf("Device: %s\n\r", mmc->name);
	printf("Manufacturer ID: %x\n\r", mmc->cid[0] >> 24);
	printf("OEM: %x\n\r", (mmc->cid[0] >> 8) & 0xffff);
	printf("Name: %c%c%c%c%c \n\r", mmc->cid[0] & 0xff,
			(mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
			(mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
 
	printf("Tran Speed: %d\n\r", mmc->tran_speed);
	printf("Rd Block Len: %d\n\r", mmc->read_bl_len);
 
	printf("%s version %d.%d\n\r", IS_SD(mmc) ? "SD" : "MMC",
			(mmc->version >> 4) & 0xf, mmc->version & 0xf);
 
	printf("High Capacity: %s\n\r", mmc->high_capacity ? "Yes" : "No");
	printf("Capacity: %ld\n\r", mmc->capacity);
 
	printf("Bus Width: %d-bit\n\r", mmc->bus_width);
}