[people/ms/u-boot.git] / drivers / mmc / mmc.c

/*
 * 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 <config.h>
#include <common.h>
#include <command.h>
#include <mmc.h>
#include <part.h>
#include <malloc.h>
#include <linux/list.h>
#include <mmc.h>
#include <div64.h>

static struct list_head mmc_devices;
static int cur_dev_num = -1;

int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
{
	return mmc->send_cmd(mmc, cmd, data);
}

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;
	cmd.flags = 0;

	return mmc_send_cmd(mmc, &cmd, NULL);
}

struct mmc *find_mmc_device(int dev_num)
{
	struct mmc *m;
	struct list_head *entry;

	list_for_each(entry, &mmc_devices) {
		m = list_entry(entry, struct mmc, link);

		if (m->block_dev.dev == dev_num)
			return m;
	}

	printf("MMC Device %d not found\n", dev_num);

	return NULL;
}

static ulong
mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
{
	struct mmc_cmd cmd;
	struct mmc_data data;
	int err;
	int stoperr = 0;
	struct mmc *mmc = find_mmc_device(dev_num);
	int blklen;

	if (!mmc)
		return -1;

	blklen = mmc->write_bl_len;

	err = mmc_set_blocklen(mmc, mmc->write_bl_len);

	if (err) {
		printf("set write bl len failed\n\r");
		return err;
	}

	if (blkcnt > 1)
		cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
	else
		cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;

	if (mmc->high_capacity)
		cmd.cmdarg = start;
	else
		cmd.cmdarg = start * blklen;

	cmd.resp_type = MMC_RSP_R1;
	cmd.flags = 0;

	data.src = src;
	data.blocks = blkcnt;
	data.blocksize = blklen;
	data.flags = MMC_DATA_WRITE;

	err = mmc_send_cmd(mmc, &cmd, &data);

	if (err) {
		printf("mmc write failed\n\r");
		return err;
	}

	if (blkcnt > 1) {
		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
		cmd.cmdarg = 0;
		cmd.resp_type = MMC_RSP_R1b;
		cmd.flags = 0;
		stoperr = mmc_send_cmd(mmc, &cmd, NULL);
	}

	return blkcnt;
}

int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum)
{
	struct mmc_cmd cmd;
	struct mmc_data data;

	cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;

	if (mmc->high_capacity)
		cmd.cmdarg = blocknum;
	else
		cmd.cmdarg = blocknum * mmc->read_bl_len;

	cmd.resp_type = MMC_RSP_R1;
	cmd.flags = 0;

	data.dest = dst;
	data.blocks = 1;
	data.blocksize = mmc->read_bl_len;
	data.flags = MMC_DATA_READ;

	return mmc_send_cmd(mmc, &cmd, &data);
}

int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size)
{
	char *buffer;
	int i;
	int blklen = mmc->read_bl_len;
	int startblock = lldiv(src, mmc->read_bl_len);
	int endblock = lldiv(src + size - 1, mmc->read_bl_len);
	int err = 0;

	/* Make a buffer big enough to hold all the blocks we might read */
	buffer = malloc(blklen);

	if (!buffer) {
		printf("Could not allocate buffer for MMC read!\n");
		return -1;
	}

	/* We always do full block reads from the card */
	err = mmc_set_blocklen(mmc, mmc->read_bl_len);

	if (err)
		return err;

	for (i = startblock; i <= endblock; i++) {
		int segment_size;
		int offset;

		err = mmc_read_block(mmc, buffer, i);

		if (err)
			goto free_buffer;

		/*
		 * The first block may not be aligned, so we
		 * copy from the desired point in the block
		 */
		offset = (src & (blklen - 1));
		segment_size = MIN(blklen - offset, size);

		memcpy(dst, buffer + offset, segment_size);

		dst += segment_size;
		src += segment_size;
		size -= segment_size;
	}

free_buffer:
	free(buffer);

	return err;
}

static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
{
	int err;
	int i;
	struct mmc *mmc = find_mmc_device(dev_num);

	if (!mmc)
		return 0;

	/* We always do full block reads from the card */
	err = mmc_set_blocklen(mmc, mmc->read_bl_len);

	if (err) {
		return 0;
	}

	for (i = start; i < start + blkcnt; i++, dst += mmc->read_bl_len) {
		err = mmc_read_block(mmc, dst, i);

		if (err) {
			printf("block read failed: %d\n", err);
			return i - start;
		}
	}

	return blkcnt;
}

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;
	cmd.flags = 0;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	udelay(2000);

	return 0;
}

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;
		cmd.flags = 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;
		cmd.cmdarg = mmc->voltages;

		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 = ((uint *)(cmd.response))[0];

	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
	mmc->rca = 0;

	return 0;
}

int mmc_send_op_cond(struct mmc *mmc)
{
	int timeout = 1000;
	struct mmc_cmd cmd;
	int err;

	/* Some cards seem to need this */
	mmc_go_idle(mmc);

	do {
		cmd.cmdidx = MMC_CMD_SEND_OP_COND;
		cmd.resp_type = MMC_RSP_R3;
		cmd.cmdarg = OCR_HCS | mmc->voltages;
		cmd.flags = 0;

		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 = ((uint *)(cmd.response))[0];

	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
	mmc->rca = 0;

	return 0;
}


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;
	cmd.flags = 0;

	data.dest = ext_csd;
	data.blocks = 1;
	data.blocksize = 512;
	data.flags = MMC_DATA_READ;

	err = mmc_send_cmd(mmc, &cmd, &data);

	return err;
}


int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
{
	struct mmc_cmd cmd;

	cmd.cmdidx = MMC_CMD_SWITCH;
	cmd.resp_type = MMC_RSP_R1b;
	cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
		(index << 16) |
		(value << 8);
	cmd.flags = 0;

	return mmc_send_cmd(mmc, &cmd, NULL);
}

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;

	mmc->card_caps |= MMC_MODE_4BIT;

	err = mmc_send_ext_csd(mmc, ext_csd);

	if (err)
		return err;

	if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
		mmc->high_capacity = 1;

	cardtype = ext_csd[196] & 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[185])
		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;
}

int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *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);
	cmd.flags = 0;

	data.dest = (char *)resp;
	data.blocksize = 64;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;

	return mmc_send_cmd(mmc, &cmd, &data);
}


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;
	cmd.flags = 0;

	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;
	cmd.flags = 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];

	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;
	}

	/* 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,
				(u8 *)&switch_status);

		if (err)
			return err;

		/* The high-speed function is busy.  Try again */
		if (!switch_status[7] & SD_HIGHSPEED_BUSY)
			break;
	}

	if (mmc->scr[0] & SD_DATA_4BIT)
		mmc->card_caps |= MMC_MODE_4BIT;

	/* If high-speed isn't supported, we return */
	if (!(switch_status[3] & SD_HIGHSPEED_SUPPORTED))
		return 0;

	err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);

	if (err)
		return err;

	if ((switch_status[4] & 0x0f000000) == 0x01000000)
		mmc->card_caps |= MMC_MODE_HS;

	return 0;
}

/* frequency bases */
/* divided by 10 to be nice to platforms without floating point */
int fbase[] = {
	10000,
	100000,
	1000000,
	10000000,
};

/* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 * to platforms without floating point.
 */
int multipliers[] = {
	0,	/* reserved */
	10,
	12,
	13,
	15,
	20,
	25,
	30,
	35,
	40,
	45,
	50,
	55,
	60,
	70,
	80,
};

void mmc_set_ios(struct mmc *mmc)
{
	mmc->set_ios(mmc);
}

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);
}

void mmc_set_bus_width(struct mmc *mmc, uint width)
{
	mmc->bus_width = width;

	mmc_set_ios(mmc);
}

int mmc_startup(struct mmc *mmc)
{
	int err;
	uint mult, freq;
	u64 cmult, csize;
	struct mmc_cmd cmd;

	/* Put the Card in Identify Mode */
	cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
	cmd.resp_type = MMC_RSP_R2;
	cmd.cmdarg = 0;
	cmd.flags = 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;
	cmd.flags = 0;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	if (IS_SD(mmc))
		mmc->rca = (((uint *)(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;
	cmd.flags = 0;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	mmc->csd[0] = ((uint *)(cmd.response))[0];
	mmc->csd[1] = ((uint *)(cmd.response))[1];
	mmc->csd[2] = ((uint *)(cmd.response))[2];
	mmc->csd[3] = ((uint *)(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 << ((((uint *)(cmd.response))[1] >> 16) & 0xf);

	if (IS_SD(mmc))
		mmc->write_bl_len = mmc->read_bl_len;
	else
		mmc->write_bl_len = 1 << ((((uint *)(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_R1b;
	cmd.cmdarg = mmc->rca << 16;
	cmd.flags = 0;
	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	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;
			cmd.flags = 0;

			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;
			cmd.flags = 0;
			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_set_clock(mmc, 50000000);
		else
			mmc_set_clock(mmc, 25000000);
	} else {
		if (mmc->card_caps & MMC_MODE_4BIT) {
			/* Set the card to use 4 bit*/
			err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
					EXT_CSD_BUS_WIDTH,
					EXT_CSD_BUS_WIDTH_4);

			if (err)
				return err;

			mmc_set_bus_width(mmc, 4);
		} else if (mmc->card_caps & MMC_MODE_8BIT) {
			/* Set the card to use 8 bit*/
			err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
					EXT_CSD_BUS_WIDTH,
					EXT_CSD_BUS_WIDTH_8);

			if (err)
				return err;

			mmc_set_bus_width(mmc, 8);
		}

		if (mmc->card_caps & MMC_MODE_HS) {
			if (mmc->card_caps & MMC_MODE_HS_52MHz)
				mmc_set_clock(mmc, 52000000);
			else
				mmc_set_clock(mmc, 26000000);
		} else
			mmc_set_clock(mmc, 20000000);
	}

	/* fill in device description */
	mmc->block_dev.lun = 0;
	mmc->block_dev.type = 0;
	mmc->block_dev.blksz = mmc->read_bl_len;
	mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
	sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
			(mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
	sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
			(mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
			(mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
	sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
			(mmc->cid[2] >> 24) & 0xf);
	init_part(&mmc->block_dev);

	return 0;
}

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;
	cmd.flags = 0;

	err = mmc_send_cmd(mmc, &cmd, NULL);

	if (err)
		return err;

	if ((((uint *)(cmd.response))[0] & 0xff) != 0xaa)
		return UNUSABLE_ERR;
	else
		mmc->version = SD_VERSION_2;

	return 0;
}

int mmc_register(struct mmc *mmc)
{
	/* Setup the universal parts of the block interface just once */
	mmc->block_dev.if_type = IF_TYPE_MMC;
	mmc->block_dev.dev = cur_dev_num++;
	mmc->block_dev.removable = 1;
	mmc->block_dev.block_read = mmc_bread;
	mmc->block_dev.block_write = mmc_bwrite;

	INIT_LIST_HEAD (&mmc->link);

	list_add_tail (&mmc->link, &mmc_devices);

	return 0;
}

block_dev_desc_t *mmc_get_dev(int dev)
{
	struct mmc *mmc = find_mmc_device(dev);

	return mmc ? &mmc->block_dev : NULL;
}

int mmc_init(struct mmc *mmc)
{
	int err;

	err = mmc->init(mmc);

	if (err)
		return err;

	/* Reset the Card */
	err = mmc_go_idle(mmc);

	if (err)
		return err;

	/* Test for SD version 2 */
	err = mmc_send_if_cond(mmc);

	/* If we got an error other than timeout, we bail */
	if (err && err != TIMEOUT)
		return err;

	/* 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");
			return UNUSABLE_ERR;
		}
	}

	return mmc_startup(mmc);
}

/*
 * CPU and board-specific MMC initializations.  Aliased function
 * signals caller to move on
 */
static int __def_mmc_init(bd_t *bis)
{
	return -1;
}

int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));

void print_mmc_devices(char separator)
{
	struct mmc *m;
	struct list_head *entry;

	list_for_each(entry, &mmc_devices) {
		m = list_entry(entry, struct mmc, link);

		printf("%s: %d", m->name, m->block_dev.dev);

		if (entry->next != &mmc_devices)
			printf("%c ", separator);
	}

	printf("\n");
}

int mmc_initialize(bd_t *bis)
{
	INIT_LIST_HEAD (&mmc_devices);
	cur_dev_num = 0;

	if (board_mmc_init(bis) < 0)
		cpu_mmc_init(bis);

	print_mmc_devices(',');

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