mmc_core.c

基于s3c2410的SD驱动

/*
 * drivers/mmc/mmc_bus.c
 *
 * MMC bus protocol interfaces 
 *
 * Copyright (C) 2001-2003 MIZI Research, Inc.
 *
 * Author: Yong-iL Joh <[e-mail]>
 * $Id: mmc_bus.c,v 1.2 2004/01/26 08:29:56 laputa Exp $
 *
 * Revision History:
 *
 * 2001-XX-XX Yong-iL Joh <[e-mail]>
 * - initial release
 *
 * 2002-07-25 Chan Gyun Jeong <[e-mail]>
 * - code cleanup 
 *
 * 2002-12-07 Chan Gyun Jeong <[e-mail]>
 * - rough restructuring for S3C2410 SD Controller
 *
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/delay.h>
#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#endif

#include "mmc.h"

#define MMC_RETRIES_MAX		20
#define MMC_RETRIES_SD_CHECK	2

#define MMC_OP_COND_DELAY	set_current_state(TASK_INTERRUPTIBLE); \
				schedule_timeout(HZ/10)

static DECLARE_MUTEX(mmc_slots_mutex);
static struct mmc_slot *mmc_slots[MAX_MMC_SLOTS];
static struct mmc_notifier *mmc_notifiers;

const int mmc_res_len[] = {
	0,
	MMC_RES_LEN_SHORT,
	MMC_RES_LEN_SHORT,
	MMC_RES_LEN_LONG,
	MMC_RES_LEN_SHORT,
	MMC_RES_LEN_SHORT,
	MMC_RES_LEN_SHORT,
	MMC_RES_LEN_SHORT,
};

/*====================================================================*/
/* Data Conversion utilities */

void mmc_str2cid(CID_regs *regs, __u8 *buff)
{
	int i;

	regs->mid = buff[0];
	regs->oid = (buff[1] << 8) | (buff[2]);
	for(i=0; i < 6; i++)
		regs->pnm[i] = buff[3+i];
	regs->pnm[6] = '\0';
	regs->prv = buff[9];
	regs->psn = (buff[10] << 24) | (buff[11] << 16) | 
		(buff[12] << 8) | buff[13];
	regs->mdt = buff[14];
}

void mmc_str2csd(CSD_regs *regs, __u8 *buff)
{
	regs->csd		= (buff[0] & 0xc0) >> 6;
	regs->spec_vers		= (buff[0] & 0x3c) >> 2;
	(regs->taac).man	= (buff[1] & 0x78) >> 3;
	(regs->taac).exp	= (buff[1]) & 0x07;
	regs->nsac		= buff[2];
	(regs->tran_speed).man = (buff[3] & 0x78) >> 3;
	(regs->tran_speed).exp = (buff[3]) & 0x07;
	regs->ccc		= (buff[4] << 4) | ((buff[5] & 0xf0) >> 4);
	regs->read_len	= (buff[5] & 0x0f);
	regs->read_part	= (buff[6] & 0x80) ? 1 : 0;
	regs->write_mis	= (buff[6] & 0x40) ? 1 : 0;
	regs->read_mis	= (buff[6] & 0x20) ? 1 : 0;
	regs->dsr		= (buff[6] & 0x10) ? 1 : 0;
	regs->c_size		= ((buff[6] & 0x03) << 10) |
		(buff[7] << 2) | ((buff[8] & 0xc0) >> 6);
	regs->vcc_r_min	= (buff[8] & 0x38) >> 3;
	regs->vcc_r_max	= (buff[8] & 0x07);
	regs->vcc_w_min	= (buff[9] & 0xe0) >> 5;
	regs->vcc_w_max	= (buff[9] & 0x1c) >> 2;
	regs->c_size_mult = ((buff[9] & 0x03) << 1) | ((buff[10] & 0x80) >> 7);
	regs->er_size     = (buff[10] & 0x7c) >> 2;
	regs->er_grp_size = ((buff[10] & 0x03) << 3) | 
		((buff[11] & 0xe0) >> 5);
	regs->wp_grp_size = (buff[11] & 0x1f);
	regs->wp_grp_en	= (buff[12] & 0x80) ? 1 : 0;
	regs->dflt_ecc	= (buff[12] & 0x60) >> 5;
	regs->r2w_factor = (buff[12] & 0x1c) >> 2;
	regs->write_len  = ((buff[12] & 0x03) << 2) | ((buff[13] & 0xc0) >> 6);
	regs->write_part = (buff[13] & 0x20) ? 1 : 0;
	regs->ffmt_grp   = (buff[14] & 0x80) ? 1 : 0;
	regs->copy		= (buff[14] & 0x40) ? 1 : 0;
	regs->perm_wp		= (buff[14] & 0x20) ? 1 : 0;
	regs->tmp_wp		= (buff[14] & 0x10) ? 1 : 0;
	regs->ffmt		= (buff[14] & 0x0c) >> 2;
	regs->ecc	= (buff[14] & 0x03);
}

/*====================================================================*/
/* Information collecting functions */

void mmc_get_CSD_info(struct mmc_slot *slot, CSD_regs *csd) 
{
	/* read/write block size */
	slot->read_len	= 0x0001 << (csd->read_len);
	slot->write_len	= 0x0001 << (csd->write_len);

	if (slot->read_len != slot->write_len) {
		DEBUG2(1, "read_len(%u) and write_len(%u) are not equal\n",
		       slot->read_len, slot->write_len);
	}

	/* partial block read/write I/O support */
	if (csd->read_part) slot->stat |= MMC_READ_PART;
	if (csd->write_part) slot->stat |= MMC_WRITE_PART;

	if (csd->wp_grp_en) slot->stat |= MMC_WP_GRP_EN;
	if (csd->perm_wp) slot->stat |= MMC_PERM_WP;
	if (csd->tmp_wp) slot->stat |= MMC_TMP_WP;

	/* calculate total card size in bytes */
	slot->size = (1 + csd->c_size) * 
		(0x01 << (csd->c_size_mult + 2)) * slot->read_len;
}


static int mmc_do_transfer_1blk(struct mmc_slot *slot, int rd, u_long from, 
				u_char *buf)
{
	int ret;
	struct mmc_cmd cmd;

	DEBUG2(3, "[%s] from: %lu, read: %d\n", __FUNCTION__, from, rd);

#if 0
	/* I don't know how to do
	   if there exists difference between read_len and write_len */
	if (!rd && (slot->read_len != slot->write_len))
		return -EINVAL;

	if ((from % slot->read_len) || (from >= slot->sizes))
		return -EINVAL;
#endif

	ret = down_interruptible(&slot->mutex);
	if (ret < 0) {
		return ret;
	}

	/* check card-state. if card-state != StandBy, return BUSY */
	cmd.cmd = MMC_CMD13;
	cmd.arg = (slot->rca << 16) & 0xffff0000;
	cmd.res_type = MMC_RES_TYPE_R1;
	cmd.res_flag = 0;
	cmd.t_res = MMC_TIME_NCR_MAX;
	cmd.t_fin = MMC_TIME_NRC_MIN;
	ret = slot->send_cmd(slot, &cmd);
	DEBUG2(2, "sent CMD13\n");
	if (ret < 0) {
		DEBUG2(1, "CMD13 failed, ret = %d\n", ret);
		goto err;
	}
	mmc_str2r1(&(slot->r1), cmd.res);
	if (slot->r1 & (R1_cc_err | R1_err)) {
		DEBUG2(1, "CMD13 failed, R1(0x%08x)\n", slot->r1);
		ret = -EIO;
		goto err;
	}
	if (!(slot->r1 & STATE_STBY)) {
		DEBUG2(1, "CMD13 failed, R1(0x%08x): Busy\n", slot->r1);
		ret = -EBUSY;
		goto err;
	}

	/* SELECT CARD & set card state from Stand-by to Transfer */
	cmd.cmd = MMC_CMD7;
	cmd.arg = (slot->rca << 16) & 0xffff0000;
	cmd.res_type = MMC_RES_TYPE_R1;
	cmd.res_flag = 0;
	cmd.t_res = MMC_TIME_NCR_MAX;
	cmd.t_fin = MMC_TIME_NRC_MIN;
	ret = slot->send_cmd(slot, &cmd);
	DEBUG2(2, "sent CMD7\n");
	if (ret < 0) {
		DEBUG2(1, "CMD7 failed, ret = %d\n", ret);
		goto err;
	}
	mmc_str2r1(&(slot->r1), cmd.res);
	if (slot->r1 & (R1_cc_err | R1_err)) {
		DEBUG2(1, "CMD7 failed, R1(0x%08x)\n", slot->r1);
		ret = -EIO;
		goto err;
	}

	ret = 0;
	if (rd) {
		/* adtc, 31:0 dadr, R1, READ_SINGLE_BLOCK */
		/* set card state from Transfer to Sending-data */
		cmd.cmd = MMC_CMD17;
		cmd.arg = from;
		cmd.res_type = MMC_RES_TYPE_R1;
		cmd.res_flag = MMC_RES_FLAG_RDATA;
		cmd.data = buf;
		cmd.data_len = slot->read_len;
		cmd.t_res = MMC_TIME_NCR_MAX;
		cmd.t_fin = MMC_TIME_NAC_MIN;
		ret = slot->send_cmd(slot, &cmd);
		DEBUG2(2, "sent CMD17\n");
		if (ret < 0) {
			DEBUG2(1, "CMD17 failed, ret = %d\n", ret);
		}
	} else {
		/* adtc, 31:0 dadr, R1, WRITE_SINGLE_BLOCK */
		/* set card state from Transfer to Receive-data */
		cmd.cmd = MMC_CMD24;
		cmd.arg = from;
		cmd.res_type = MMC_RES_TYPE_R1;
		cmd.res_flag = MMC_RES_FLAG_WDATA;
		cmd.data = buf;
		cmd.data_len = slot->write_len;
		cmd.t_res = MMC_TIME_NCR_MAX;
		cmd.t_fin = MMC_TIME_NWR_MIN;
		ret = slot->send_cmd(slot, &cmd);
		DEBUG2(2, "sent CMD24\n");
		if (ret < 0) {
			DEBUG2(1, "CMD24 failed, ret = %d\n", ret);
		}
	}

	/* DESELECT CARD */
	cmd.cmd = MMC_CMD7;
	cmd.arg = 0;
	cmd.res_type = MMC_RES_TYPE_NONE;
	cmd.res_flag = 0;
	cmd.t_fin = MMC_TIME_NRC_MIN;
	slot->send_cmd(slot, &cmd);
	DEBUG2(2, "sent CMD7(DESELECT)\n");

 err:
	up(&slot->mutex);
	return ret;
}

inline static int mmc_reset(struct mmc_slot *slot)
{
	int ret;
	struct mmc_cmd cmd;

	/* go IDLE state */
	cmd.cmd = MMC_CMD0;
	cmd.arg = 0;
	cmd.res_type = MMC_RES_TYPE_NONE;
	cmd.res_flag = 0;
	cmd.t_fin = MMC_TIME_NCC_MIN;
	ret = slot->send_cmd(slot, &cmd);
	DEBUG2(2, "sent CMD0\n");
	if (ret < 0) {
		DEBUG2(1, "CMD0 failed, ret = %d\n", ret);
		return ret;
	}

	/* wait for reset */
	if (slot->wait_for_reset) {
		slot->wait_for_reset(slot);
	}

	return 0;
}

inline static int mmc_identify(struct mmc_slot *slot)
{
	int ret;
	int retries = MMC_RETRIES_MAX;
	int sdcard=1;		//is sd card or mmc card
	struct mmc_cmd cmd;

retry_send_op_cond:
	//add by threewater
	/* APP_CMD */
	cmd.cmd = MMC_CMD55;
	cmd.arg = (slot->rca << 16) & 0xffff0000;
	cmd.res_type = MMC_RES_TYPE_R1;
	cmd.res_flag = 0;
	cmd.t_res = MMC_TIME_NCR_MAX;
	cmd.t_fin = MMC_TIME_NRC_MIN;
	ret = slot->send_cmd(slot, &cmd);
	DEBUG2(2, "sent CMD55\n");
	if (ret < 0) {
		DEBUG2(1, "CMD55 failed!\n");
		return ret;
	}

	/* SEND_OP_COND */
	slot->ocr = MMC_VDD_27_36;

	if(sdcard)
		cmd.cmd = MMC_ACMD42; 
	else
		cmd.cmd = MMC_CMD1;

	cmd.arg = slot->ocr;
	cmd.res_type = MMC_RES_TYPE_R3;
	cmd.res_flag = MMC_RES_FLAG_NOCRC;
	cmd.t_res = MMC_TIME_NCR_MAX;
	cmd.t_fin = MMC_TIME_NRC_MIN;
	ret = slot->send_cmd(slot, &cmd);

	DEBUG2(2, "sent %s\n", (sdcard)?"ACMD41":"CMD1");

	if (ret < 0) {
		if(sdcard){
			DEBUG2(1, "ACMD41 failed! Maybe MMC card, ret = %d\n", ret);
			sdcard=0;
			ret = mmc_reset(slot);
			if (ret < 0) {
				return ret;
			}
			MMC_OP_COND_DELAY;
			goto retry_send_op_cond;
		}
		else{
			DEBUG2(1, "CMD1 failed, ret = %d\n", ret);
			if (ret != -ENODEV && retries--) {
				ret = mmc_reset(slot);
				if (ret < 0) {
					return ret;
				}
				MMC_OP_COND_DELAY;