Skip to content
Snippets Groups Projects
mmc.c 33.6 KiB
Newer Older
  • Learn to ignore specific revisions
  • Andy Fleming's avatar
    Andy Fleming committed
    /*
     * Copyright 2008, Freescale Semiconductor, Inc
     * Andy Fleming
     *
     * Based vaguely on the Linux code
     *
    
     * SPDX-License-Identifier:	GPL-2.0+
    
    Andy Fleming's avatar
    Andy Fleming committed
     */
    
    #include <config.h>
    #include <common.h>
    #include <command.h>
    
    Andy Fleming's avatar
    Andy Fleming committed
    #include <mmc.h>
    #include <part.h>
    #include <malloc.h>
    #include <linux/list.h>
    
    #include <div64.h>
    
    #include "mmc_private.h"
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    static struct list_head mmc_devices;
    static int cur_dev_num = -1;
    
    
    __weak int board_mmc_getwp(struct mmc *mmc)
    
    {
    	return -1;
    }
    
    int mmc_getwp(struct mmc *mmc)
    {
    	int wp;
    
    	wp = board_mmc_getwp(mmc);
    
    
    		if (mmc->cfg->ops->getwp)
    			wp = mmc->cfg->ops->getwp(mmc);
    
    Jeroen Hofstee's avatar
    Jeroen Hofstee committed
    __weak int board_mmc_getcd(struct mmc *mmc)
    {
    
    int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    	int ret;
    
    
    #ifdef CONFIG_MMC_TRACE
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    	int i;
    	u8 *ptr;
    
    	printf("CMD_SEND:%d\n", cmd->cmdidx);
    	printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg);
    
    	ret = mmc->cfg->ops->send_cmd(mmc, cmd, data);
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    	switch (cmd->resp_type) {
    		case MMC_RSP_NONE:
    			printf("\t\tMMC_RSP_NONE\n");
    			break;
    		case MMC_RSP_R1:
    			printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
    				cmd->response[0]);
    			break;
    		case MMC_RSP_R1b:
    			printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
    				cmd->response[0]);
    			break;
    		case MMC_RSP_R2:
    			printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
    				cmd->response[0]);
    			printf("\t\t          \t\t 0x%08X \n",
    				cmd->response[1]);
    			printf("\t\t          \t\t 0x%08X \n",
    				cmd->response[2]);
    			printf("\t\t          \t\t 0x%08X \n",
    				cmd->response[3]);
    			printf("\n");
    			printf("\t\t\t\t\tDUMPING DATA\n");
    			for (i = 0; i < 4; i++) {
    				int j;
    				printf("\t\t\t\t\t%03d - ", i*4);
    
    				ptr = (u8 *)&cmd->response[i];
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    				ptr += 3;
    				for (j = 0; j < 4; j++)
    					printf("%02X ", *ptr--);
    				printf("\n");
    			}
    			break;
    		case MMC_RSP_R3:
    			printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
    				cmd->response[0]);
    			break;
    		default:
    			printf("\t\tERROR MMC rsp not supported\n");
    			break;
    	}
    #else
    
    	ret = mmc->cfg->ops->send_cmd(mmc, cmd, data);
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    #endif
    
    	return ret;
    
    Andy Fleming's avatar
    Andy Fleming committed
    }
    
    
    int mmc_send_status(struct mmc *mmc, int timeout)
    
    	int err, retries = 5;
    
    #ifdef CONFIG_MMC_TRACE
    	int status;
    #endif
    
    	cmd.cmdidx = MMC_CMD_SEND_STATUS;
    	cmd.resp_type = MMC_RSP_R1;
    
    Marek Vasut's avatar
    Marek Vasut committed
    	if (!mmc_host_is_spi(mmc))
    		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) {
    
    #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
    
    				printf("Status Error: 0x%08X\n",
    					cmd.response[0]);
    
    				return COMM_ERR;
    			}
    		} else if (--retries < 0)
    
    Raffaele Recalcati's avatar
    Raffaele Recalcati committed
    #ifdef CONFIG_MMC_TRACE
    	status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
    	printf("CURR STATE:%d\n", status);
    #endif
    
    	if (timeout <= 0) {
    
    #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
    
    		printf("Timeout waiting card ready\n");
    
    	if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR)
    		return SWITCH_ERR;
    
    int mmc_set_blocklen(struct mmc *mmc, int len)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	struct mmc_cmd cmd;
    
    
    	if (mmc->card_caps & MMC_MODE_DDR_52MHz)
    		return 0;
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
    	cmd.resp_type = MMC_RSP_R1;
    	cmd.cmdarg = len;
    
    	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;
    	}
    
    
    #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
    
    Andy Fleming's avatar
    Andy Fleming committed
    	printf("MMC Device %d not found\n", dev_num);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	return NULL;
    }
    
    
    static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start,
    
    			   lbaint_t blkcnt)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	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;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	if (mmc->high_capacity)
    
    Andy Fleming's avatar
    Andy Fleming committed
    	else
    
    		cmd.cmdarg = start * mmc->read_bl_len;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	cmd.resp_type = MMC_RSP_R1;
    
    	data.dest = dst;
    
    Andy Fleming's avatar
    Andy Fleming committed
    	data.blocksize = mmc->read_bl_len;
    	data.flags = MMC_DATA_READ;
    
    
    	if (mmc_send_cmd(mmc, &cmd, &data))
    		return 0;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	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)) {
    
    #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
    
    			printf("mmc fail to send stop cmd\n");
    
    Andy Fleming's avatar
    Andy Fleming committed
    	}
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    }
    
    
    static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    
    	lbaint_t cur, blocks_todo = blkcnt;
    
    	if (blkcnt == 0)
    		return 0;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	struct mmc *mmc = find_mmc_device(dev_num);
    
    Andy Fleming's avatar
    Andy Fleming committed
    	if (!mmc)
    		return 0;
    
    
    	if ((start + blkcnt) > mmc->block_dev.lba) {
    
    #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
    
    		printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
    
    			start + blkcnt, mmc->block_dev.lba);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	if (mmc_set_blocklen(mmc, mmc->read_bl_len))
    
    Andy Fleming's avatar
    Andy Fleming committed
    		return 0;
    
    
    		cur = (blocks_todo > mmc->cfg->b_max) ?
    			mmc->cfg->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);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	return blkcnt;
    }
    
    
    static int mmc_go_idle(struct mmc *mmc)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	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 sd_send_op_cond(struct mmc *mmc)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	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_host_is_spi(mmc) ? 0 :
    
    			(mmc->cfg->voltages & 0xff8000);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    		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;
    
    
    	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
    		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
    		cmd.resp_type = MMC_RSP_R3;
    		cmd.cmdarg = 0;
    
    		err = mmc_send_cmd(mmc, &cmd, NULL);
    
    		if (err)
    			return err;
    	}
    
    
    	mmc->ocr = cmd.response[0];
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
    	mmc->rca = 0;
    
    	return 0;
    }
    
    
    /* We pass in the cmd since otherwise the init seems to fail */
    static int mmc_send_op_cond_iter(struct mmc *mmc, struct mmc_cmd *cmd,
    		int use_arg)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	int err;
    
    
    	cmd->cmdidx = MMC_CMD_SEND_OP_COND;
    	cmd->resp_type = MMC_RSP_R3;
    	cmd->cmdarg = 0;
    	if (use_arg && !mmc_host_is_spi(mmc)) {
    		cmd->cmdarg =
    
    			(mmc->op_cond_response & OCR_VOLTAGE_MASK)) |
    			(mmc->op_cond_response & OCR_ACCESS_MODE);
    
    
    		if (mmc->cfg->host_caps & MMC_MODE_HC)
    
    			cmd->cmdarg |= OCR_HCS;
    	}
    	err = mmc_send_cmd(mmc, cmd, NULL);
    	if (err)
    		return err;
    	mmc->op_cond_response = cmd->response[0];
    	return 0;
    }
    
    
    static int mmc_send_op_cond(struct mmc *mmc)
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* Some cards seem to need this */
    	mmc_go_idle(mmc);
    
    
     	/* Asking to the card its capabilities */
    
    	mmc->op_cond_pending = 1;
    	for (i = 0; i < 2; i++) {
    		err = mmc_send_op_cond_iter(mmc, &cmd, i != 0);
    		if (err)
    			return err;
    
    		/* exit if not busy (flag seems to be inverted) */
    		if (mmc->op_cond_response & OCR_BUSY)
    			return 0;
    	}
    	return IN_PROGRESS;
    }
    
    static int mmc_complete_op_cond(struct mmc *mmc)
    
    {
    	struct mmc_cmd cmd;
    	int timeout = 1000;
    	uint start;
    	int err;
    
    	mmc->op_cond_pending = 0;
    	start = get_timer(0);
    
    Andy Fleming's avatar
    Andy Fleming committed
    	do {
    
    		err = mmc_send_op_cond_iter(mmc, &cmd, 1);
    
    Andy Fleming's avatar
    Andy Fleming committed
    		if (err)
    			return err;
    
    		if (get_timer(start) > timeout)
    			return UNUSABLE_ERR;
    		udelay(100);
    	} while (!(mmc->op_cond_response & OCR_BUSY));
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
    		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
    		cmd.resp_type = MMC_RSP_R3;
    		cmd.cmdarg = 0;
    
    		err = mmc_send_cmd(mmc, &cmd, NULL);
    
    		if (err)
    			return err;
    	}
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	mmc->version = MMC_VERSION_UNKNOWN;
    
    	mmc->ocr = cmd.response[0];
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
    
    	mmc->rca = 1;
    
    static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	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;
    
    Andy Fleming's avatar
    Andy Fleming committed
    	data.blocks = 1;
    
    	data.blocksize = MMC_MAX_BLOCK_LEN;
    
    Andy Fleming's avatar
    Andy Fleming committed
    	data.flags = MMC_DATA_READ;
    
    	err = mmc_send_cmd(mmc, &cmd, &data);
    
    	return err;
    }
    
    
    
    static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	struct mmc_cmd cmd;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	cmd.cmdidx = MMC_CMD_SWITCH;
    	cmd.resp_type = MMC_RSP_R1b;
    	cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	ret = mmc_send_cmd(mmc, &cmd, NULL);
    
    	/* Waiting for the ready status */
    
    Jan Kloetzke's avatar
    Jan Kloetzke committed
    	if (!ret)
    		ret = mmc_send_status(mmc, timeout);
    
    Andy Fleming's avatar
    Andy Fleming committed
    }
    
    
    static int mmc_change_freq(struct mmc *mmc)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    
    	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
    
    Andy Fleming's avatar
    Andy Fleming committed
    	char cardtype;
    	int err;
    
    	mmc->card_caps = 0;
    
    
    	if (mmc_host_is_spi(mmc))
    		return 0;
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* 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;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
    
    	if (err)
    
    		return err == SWITCH_ERR ? 0 : err;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	/* 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])
    
    Andy Fleming's avatar
    Andy Fleming committed
    		return 0;
    
    	/* High Speed is set, there are two types: 52MHz and 26MHz */
    
    	if (cardtype & EXT_CSD_CARD_TYPE_52) {
    		if (cardtype & EXT_CSD_CARD_TYPE_DDR_52)
    			mmc->card_caps |= MMC_MODE_DDR_52MHz;
    
    Andy Fleming's avatar
    Andy Fleming committed
    		mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
    
    Andy Fleming's avatar
    Andy Fleming committed
    		mmc->card_caps |= MMC_MODE_HS;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	return 0;
    }
    
    
    static int mmc_set_capacity(struct mmc *mmc, int part_num)
    {
    	switch (part_num) {
    	case 0:
    		mmc->capacity = mmc->capacity_user;
    		break;
    	case 1:
    	case 2:
    		mmc->capacity = mmc->capacity_boot;
    		break;
    	case 3:
    		mmc->capacity = mmc->capacity_rpmb;
    		break;
    	case 4:
    	case 5:
    	case 6:
    	case 7:
    		mmc->capacity = mmc->capacity_gp[part_num - 4];
    		break;
    	default:
    		return -1;
    	}
    
    	mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
    
    	return 0;
    }
    
    
    int mmc_select_hwpart(int dev_num, int hwpart)
    {
    	struct mmc *mmc = find_mmc_device(dev_num);
    	int ret;
    
    	if (!mmc)
    
    
    	if (mmc->part_num == hwpart)
    		return 0;
    
    	if (mmc->part_config == MMCPART_NOAVAILABLE) {
    		printf("Card doesn't support part_switch\n");
    
    	}
    
    	ret = mmc_switch_part(dev_num, hwpart);
    	if (ret)
    
    int mmc_switch_part(int dev_num, unsigned int part_num)
    {
    	struct mmc *mmc = find_mmc_device(dev_num);
    
    	ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
    			 (mmc->part_config & ~PART_ACCESS_MASK)
    			 | (part_num & PART_ACCESS_MASK));
    
    
    	/*
    	 * Set the capacity if the switch succeeded or was intended
    	 * to return to representing the raw device.
    	 */
    	if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0)))
    		ret = mmc_set_capacity(mmc, part_num);
    
    	return ret;
    
    int mmc_getcd(struct mmc *mmc)
    {
    	int cd;
    
    	cd = board_mmc_getcd(mmc);
    
    
    		if (mmc->cfg->ops->getcd)
    			cd = mmc->cfg->ops->getcd(mmc);
    
    static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	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)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	int err;
    	struct mmc_cmd cmd;
    
    	ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
    	ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
    
    Andy Fleming's avatar
    Andy Fleming committed
    	struct mmc_data data;
    	int timeout;
    
    	mmc->card_caps = 0;
    
    
    	if (mmc_host_is_spi(mmc))
    		return 0;
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* 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:
    
    Andy Fleming's avatar
    Andy Fleming committed
    	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] = __be32_to_cpu(scr[0]);
    	mmc->scr[1] = __be32_to_cpu(scr[1]);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	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;
    
    			if ((mmc->scr[0] >> 15) & 0x1)
    				mmc->version = SD_VERSION_3;
    
    Andy Fleming's avatar
    Andy Fleming committed
    			break;
    		default:
    			mmc->version = SD_VERSION_1_0;
    			break;
    	}
    
    
    Alagu Sankar's avatar
    Alagu Sankar committed
    	if (mmc->scr[0] & SD_DATA_4BIT)
    		mmc->card_caps |= MMC_MODE_4BIT;
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* 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,
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    		if (err)
    			return err;
    
    		/* The high-speed function is busy.  Try again */
    
    		if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
    
    Andy Fleming's avatar
    Andy Fleming committed
    			break;
    	}
    
    	/* If high-speed isn't supported, we return */
    
    	if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
    
    Andy Fleming's avatar
    Andy Fleming committed
    		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->cfg->host_caps & MMC_MODE_HS_52MHz) &&
    		(mmc->cfg->host_caps & MMC_MODE_HS)))
    
    	err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	if (err)
    		return err;
    
    
    	if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
    
    Andy Fleming's avatar
    Andy Fleming committed
    		mmc->card_caps |= MMC_MODE_HS;
    
    	return 0;
    }
    
    /* frequency bases */
    /* divided by 10 to be nice to platforms without floating point */
    
    static const int fbase[] = {
    
    Andy Fleming's avatar
    Andy Fleming committed
    	10000,
    	100000,
    	1000000,
    	10000000,
    };
    
    /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
     * to platforms without floating point.
     */
    
    static const int multipliers[] = {
    
    Andy Fleming's avatar
    Andy Fleming committed
    	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)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    
    	if (mmc->cfg->ops->set_ios)
    		mmc->cfg->ops->set_ios(mmc);
    
    Andy Fleming's avatar
    Andy Fleming committed
    }
    
    void mmc_set_clock(struct mmc *mmc, uint clock)
    {
    
    	if (clock > mmc->cfg->f_max)
    		clock = mmc->cfg->f_max;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	if (clock < mmc->cfg->f_min)
    		clock = mmc->cfg->f_min;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	mmc->clock = clock;
    
    	mmc_set_ios(mmc);
    }
    
    
    static void mmc_set_bus_width(struct mmc *mmc, uint width)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    	mmc->bus_width = width;
    
    	mmc_set_ios(mmc);
    }
    
    
    static int mmc_startup(struct mmc *mmc)
    
    Andy Fleming's avatar
    Andy Fleming committed
    {
    
    Andy Fleming's avatar
    Andy Fleming committed
    	uint mult, freq;
    
    	u64 cmult, csize, capacity;
    
    Andy Fleming's avatar
    Andy Fleming committed
    	struct mmc_cmd cmd;
    
    	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
    	ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    #ifdef CONFIG_MMC_SPI_CRC_ON
    	if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
    		cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
    		cmd.resp_type = MMC_RSP_R1;
    		cmd.cmdarg = 1;
    		err = mmc_send_cmd(mmc, &cmd, NULL);
    
    		if (err)
    			return err;
    	}
    #endif
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* Put the Card in Identify Mode */
    
    	cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
    		MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
    
    Andy Fleming's avatar
    Andy Fleming committed
    	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
    	 */
    
    	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
    		cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
    		cmd.cmdarg = mmc->rca << 16;
    		cmd.resp_type = MMC_RSP_R6;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    		err = mmc_send_cmd(mmc, &cmd, NULL);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    		if (err)
    			return err;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    		if (IS_SD(mmc))
    			mmc->rca = (cmd.response[0] >> 16) & 0xffff;
    	}
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	/* 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);
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	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];
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	if (mmc->version == MMC_VERSION_UNKNOWN) {
    
    		int version = (cmd.response[0] >> 26) & 0xf;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    		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)];
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	mmc->tran_speed = freq * mult;
    
    
    Markus Niebel's avatar
    Markus Niebel committed
    	mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
    
    	mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	if (IS_SD(mmc))
    		mmc->write_bl_len = mmc->read_bl_len;
    	else
    
    		mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    	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_user = (csize + 1) << (cmult + 2);
    	mmc->capacity_user *= mmc->read_bl_len;
    	mmc->capacity_boot = 0;
    	mmc->capacity_rpmb = 0;
    	for (i = 0; i < 4; i++)
    		mmc->capacity_gp[i] = 0;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
    		mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
    		mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    Markus Niebel's avatar
    Markus Niebel committed
    	if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
    		cmd.cmdidx = MMC_CMD_SET_DSR;
    		cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
    		cmd.resp_type = MMC_RSP_NONE;
    		if (mmc_send_cmd(mmc, &cmd, NULL))
    			printf("MMC: SET_DSR failed\n");
    	}
    
    
    Andy Fleming's avatar
    Andy Fleming committed
    	/* Select the card, and put it into Transfer Mode */
    
    	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
    		cmd.cmdidx = MMC_CMD_SELECT_CARD;
    
    		cmd.resp_type = MMC_RSP_R1;
    
    		cmd.cmdarg = mmc->rca << 16;
    		err = mmc_send_cmd(mmc, &cmd, NULL);
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    		if (err)
    			return err;
    	}
    
    Andy Fleming's avatar
    Andy Fleming committed
    
    
    	/*
    	 * 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 *= MMC_MAX_BLOCK_LEN;
    
    			if ((capacity >> 20) > 2 * 1024)
    
    				mmc->capacity_user = capacity;
    
    		switch (ext_csd[EXT_CSD_REV]) {
    		case 1:
    			mmc->version = MMC_VERSION_4_1;
    			break;
    		case 2:
    			mmc->version = MMC_VERSION_4_2;
    			break;
    		case 3:
    			mmc->version = MMC_VERSION_4_3;
    			break;
    		case 5:
    			mmc->version = MMC_VERSION_4_41;
    			break;