[deliverable/linux.git] / drivers / mmc / core / mmc_ops.c

/*
 *  linux/drivers/mmc/core/mmc_ops.h
 *
 *  Copyright 2006-2007 Pierre Ossman
 *
 * 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.
 */

#include <linux/slab.h>
#include <linux/types.h>
#include <linux/scatterlist.h>

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/mmc.h>

#include "core.h"
#include "mmc_ops.h"

static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
{
	int err;
	struct mmc_command cmd = {0};

	BUG_ON(!host);

	cmd.opcode = MMC_SELECT_CARD;

	if (card) {
		cmd.arg = card->rca << 16;
		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
	} else {
		cmd.arg = 0;
		cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
	}

	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	return 0;
}

int mmc_select_card(struct mmc_card *card)
{
	BUG_ON(!card);

	return _mmc_select_card(card->host, card);
}

int mmc_deselect_cards(struct mmc_host *host)
{
	return _mmc_select_card(host, NULL);
}

int mmc_card_sleepawake(struct mmc_host *host, int sleep)
{
	struct mmc_command cmd = {0};
	struct mmc_card *card = host->card;
	int err;

	if (sleep)
		mmc_deselect_cards(host);

	cmd.opcode = MMC_SLEEP_AWAKE;
	cmd.arg = card->rca << 16;
	if (sleep)
		cmd.arg |= 1 << 15;

	cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
	err = mmc_wait_for_cmd(host, &cmd, 0);
	if (err)
		return err;

	/*
	 * If the host does not wait while the card signals busy, then we will
	 * will have to wait the sleep/awake timeout.  Note, we cannot use the
	 * SEND_STATUS command to poll the status because that command (and most
	 * others) is invalid while the card sleeps.
	 */
	if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
		mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000));

	if (!sleep)
		err = mmc_select_card(card);

	return err;
}

int mmc_go_idle(struct mmc_host *host)
{
	int err;
	struct mmc_command cmd = {0};

	/*
	 * Non-SPI hosts need to prevent chipselect going active during
	 * GO_IDLE; that would put chips into SPI mode.  Remind them of
	 * that in case of hardware that won't pull up DAT3/nCS otherwise.
	 *
	 * SPI hosts ignore ios.chip_select; it's managed according to
	 * rules that must accommodate non-MMC slaves which this layer
	 * won't even know about.
	 */
	if (!mmc_host_is_spi(host)) {
		mmc_set_chip_select(host, MMC_CS_HIGH);
		mmc_delay(1);
	}

	cmd.opcode = MMC_GO_IDLE_STATE;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;

	err = mmc_wait_for_cmd(host, &cmd, 0);

	mmc_delay(1);

	if (!mmc_host_is_spi(host)) {
		mmc_set_chip_select(host, MMC_CS_DONTCARE);
		mmc_delay(1);
	}

	host->use_spi_crc = 0;

	return err;
}

int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
{
	struct mmc_command cmd = {0};
	int i, err = 0;

	BUG_ON(!host);

	cmd.opcode = MMC_SEND_OP_COND;
	cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;

	for (i = 100; i; i--) {
		err = mmc_wait_for_cmd(host, &cmd, 0);
		if (err)
			break;

		/* if we're just probing, do a single pass */
		if (ocr == 0)
			break;

		/* otherwise wait until reset completes */
		if (mmc_host_is_spi(host)) {
			if (!(cmd.resp[0] & R1_SPI_IDLE))
				break;
		} else {
			if (cmd.resp[0] & MMC_CARD_BUSY)
				break;
		}

		err = -ETIMEDOUT;

		mmc_delay(10);
	}

	if (rocr && !mmc_host_is_spi(host))
		*rocr = cmd.resp[0];

	return err;
}

int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
{
	int err;
	struct mmc_command cmd = {0};

	BUG_ON(!host);
	BUG_ON(!cid);

	cmd.opcode = MMC_ALL_SEND_CID;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;

	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	memcpy(cid, cmd.resp, sizeof(u32) * 4);

	return 0;
}

int mmc_set_relative_addr(struct mmc_card *card)
{
	int err;
	struct mmc_command cmd = {0};

	BUG_ON(!card);
	BUG_ON(!card->host);

	cmd.opcode = MMC_SET_RELATIVE_ADDR;
	cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	return 0;
}

static int
mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
{
	int err;
	struct mmc_command cmd = {0};

	BUG_ON(!host);
	BUG_ON(!cxd);

	cmd.opcode = opcode;
	cmd.arg = arg;
	cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;

	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	memcpy(cxd, cmd.resp, sizeof(u32) * 4);

	return 0;
}

static int
mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
		u32 opcode, void *buf, unsigned len)
{
	struct mmc_request mrq = {NULL};
	struct mmc_command cmd = {0};
	struct mmc_data data = {0};
	struct scatterlist sg;
	void *data_buf;

	/* dma onto stack is unsafe/nonportable, but callers to this
	 * routine normally provide temporary on-stack buffers ...
	 */
	data_buf = kmalloc(len, GFP_KERNEL);
	if (data_buf == NULL)
		return -ENOMEM;

	mrq.cmd = &cmd;
	mrq.data = &data;

	cmd.opcode = opcode;
	cmd.arg = 0;

	/* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
	 * rely on callers to never use this with "native" calls for reading
	 * CSD or CID.  Native versions of those commands use the R2 type,
	 * not R1 plus a data block.
	 */
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

	data.blksz = len;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;
	data.sg = &sg;
	data.sg_len = 1;

	sg_init_one(&sg, data_buf, len);

	if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
		/*
		 * The spec states that CSR and CID accesses have a timeout
		 * of 64 clock cycles.
		 */
		data.timeout_ns = 0;
		data.timeout_clks = 64;
	} else
		mmc_set_data_timeout(&data, card);

	mmc_wait_for_req(host, &mrq);

	memcpy(buf, data_buf, len);
	kfree(data_buf);

	if (cmd.error)
		return cmd.error;
	if (data.error)
		return data.error;

	return 0;
}

int mmc_send_csd(struct mmc_card *card, u32 *csd)
{
	int ret, i;

	if (!mmc_host_is_spi(card->host))
		return mmc_send_cxd_native(card->host, card->rca << 16,
				csd, MMC_SEND_CSD);

	ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);
	if (ret)
		return ret;

	for (i = 0;i < 4;i++)
		csd[i] = be32_to_cpu(csd[i]);

	return 0;
}

int mmc_send_cid(struct mmc_host *host, u32 *cid)
{
	int ret, i;

	if (!mmc_host_is_spi(host)) {
		if (!host->card)
			return -EINVAL;
		return mmc_send_cxd_native(host, host->card->rca << 16,
				cid, MMC_SEND_CID);
	}

	ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16);
	if (ret)
		return ret;

	for (i = 0;i < 4;i++)
		cid[i] = be32_to_cpu(cid[i]);

	return 0;
}

int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
{
	return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
			ext_csd, 512);
}

int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
{
	struct mmc_command cmd = {0};
	int err;

	cmd.opcode = MMC_SPI_READ_OCR;
	cmd.arg = highcap ? (1 << 30) : 0;
	cmd.flags = MMC_RSP_SPI_R3;

	err = mmc_wait_for_cmd(host, &cmd, 0);

	*ocrp = cmd.resp[1];
	return err;
}

int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
{
	struct mmc_command cmd = {0};
	int err;

	cmd.opcode = MMC_SPI_CRC_ON_OFF;
	cmd.flags = MMC_RSP_SPI_R1;
	cmd.arg = use_crc;

	err = mmc_wait_for_cmd(host, &cmd, 0);
	if (!err)
		host->use_spi_crc = use_crc;
	return err;
}

/**
 *	mmc_switch - modify EXT_CSD register
 *	@card: the MMC card associated with the data transfer
 *	@set: cmd set values
 *	@index: EXT_CSD register index
 *	@value: value to program into EXT_CSD register
 *	@timeout_ms: timeout (ms) for operation performed by register write,
 *                   timeout of zero implies maximum possible timeout
 *
 *	Modifies the EXT_CSD register for selected card.
 */
int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
	       unsigned int timeout_ms)
{
	int err;
	struct mmc_command cmd = {0};
	u32 status;

	BUG_ON(!card);
	BUG_ON(!card->host);

	cmd.opcode = MMC_SWITCH;
	cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
		  (index << 16) |
		  (value << 8) |
		  set;
	cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
	cmd.cmd_timeout_ms = timeout_ms;

	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	/* Must check status to be sure of no errors */
	do {
		err = mmc_send_status(card, &status);
		if (err)
			return err;
		if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
			break;
		if (mmc_host_is_spi(card->host))
			break;
	} while (R1_CURRENT_STATE(status) == R1_STATE_PRG);

	if (mmc_host_is_spi(card->host)) {
		if (status & R1_SPI_ILLEGAL_COMMAND)
			return -EBADMSG;
	} else {
		if (status & 0xFDFFA000)
			pr_warning("%s: unexpected status %#x after "
			       "switch", mmc_hostname(card->host), status);
		if (status & R1_SWITCH_ERROR)
			return -EBADMSG;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(mmc_switch);

int mmc_send_status(struct mmc_card *card, u32 *status)
{
	int err;
	struct mmc_command cmd = {0};

	BUG_ON(!card);
	BUG_ON(!card->host);

	cmd.opcode = MMC_SEND_STATUS;
	if (!mmc_host_is_spi(card->host))
		cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;

	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
	if (err)
		return err;

	/* NOTE: callers are required to understand the difference
	 * between "native" and SPI format status words!
	 */
	if (status)
		*status = cmd.resp[0];

	return 0;
}

static int
mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
		  u8 len)
{
	struct mmc_request mrq = {NULL};
	struct mmc_command cmd = {0};
	struct mmc_data data = {0};
	struct scatterlist sg;
	u8 *data_buf;
	u8 *test_buf;
	int i, err;
	static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
	static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };

	/* dma onto stack is unsafe/nonportable, but callers to this
	 * routine normally provide temporary on-stack buffers ...
	 */
	data_buf = kmalloc(len, GFP_KERNEL);
	if (!data_buf)
		return -ENOMEM;

	if (len == 8)
		test_buf = testdata_8bit;
	else if (len == 4)
		test_buf = testdata_4bit;
	else {
		pr_err("%s: Invalid bus_width %d\n",
		       mmc_hostname(host), len);
		kfree(data_buf);
		return -EINVAL;
	}

	if (opcode == MMC_BUS_TEST_W)
		memcpy(data_buf, test_buf, len);

	mrq.cmd = &cmd;
	mrq.data = &data;
	cmd.opcode = opcode;
	cmd.arg = 0;

	/* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
	 * rely on callers to never use this with "native" calls for reading
	 * CSD or CID.  Native versions of those commands use the R2 type,
	 * not R1 plus a data block.
	 */
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

	data.blksz = len;
	data.blocks = 1;
	if (opcode == MMC_BUS_TEST_R)
		data.flags = MMC_DATA_READ;
	else
		data.flags = MMC_DATA_WRITE;

	data.sg = &sg;
	data.sg_len = 1;
	sg_init_one(&sg, data_buf, len);
	mmc_wait_for_req(host, &mrq);
	err = 0;
	if (opcode == MMC_BUS_TEST_R) {
		for (i = 0; i < len / 4; i++)
			if ((test_buf[i] ^ data_buf[i]) != 0xff) {
				err = -EIO;
				break;
			}
	}
	kfree(data_buf);

	if (cmd.error)
		return cmd.error;
	if (data.error)
		return data.error;

	return err;
}

int mmc_bus_test(struct mmc_card *card, u8 bus_width)
{
	int err, width;

	if (bus_width == MMC_BUS_WIDTH_8)
		width = 8;
	else if (bus_width == MMC_BUS_WIDTH_4)
		width = 4;
	else if (bus_width == MMC_BUS_WIDTH_1)
		return 0; /* no need for test */
	else
		return -EINVAL;

	/*
	 * Ignore errors from BUS_TEST_W.  BUS_TEST_R will fail if there
	 * is a problem.  This improves chances that the test will work.
	 */
	mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
	err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
	return err;
}
Commit	Line	Data
da7fbe58	1	/*
70f10482	2	* linux/drivers/mmc/core/mmc_ops.h
da7fbe58 PO	3	*
	4	* Copyright 2006-2007 Pierre Ossman
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or (at
	9	* your option) any later version.
	10	*/
	11
5a0e3ad6	12	#include <linux/slab.h>
da7fbe58	13	#include <linux/types.h>
da7fbe58 PO	14	#include <linux/scatterlist.h>
	15
	16	#include <linux/mmc/host.h>
	17	#include <linux/mmc/card.h>
	18	#include <linux/mmc/mmc.h>
	19
	20	#include "core.h"
	21	#include "mmc_ops.h"
	22
	23	static int _mmc_select_card(struct mmc_host host, struct mmc_card card)
	24	{
	25	int err;
1278dba1	26	struct mmc_command cmd = {0};
da7fbe58 PO	27
	28	BUG_ON(!host);
	29
da7fbe58 PO	30	cmd.opcode = MMC_SELECT_CARD;
	31
	32	if (card) {
	33	cmd.arg = card->rca << 16;
	34	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;
	35	} else {
	36	cmd.arg = 0;
	37	cmd.flags = MMC_RSP_NONE \| MMC_CMD_AC;
	38	}
	39
	40	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
17b0429d	41	if (err)
da7fbe58 PO	42	return err;
da7fbe58 PO	43
17b0429d	44	return 0;
da7fbe58 PO	45	}
	46
	47	int mmc_select_card(struct mmc_card *card)
	48	{
	49	BUG_ON(!card);
	50
	51	return _mmc_select_card(card->host, card);
	52	}
	53
	54	int mmc_deselect_cards(struct mmc_host *host)
	55	{
	56	return _mmc_select_card(host, NULL);
	57	}
	58
b1ebe384 JL	59	int mmc_card_sleepawake(struct mmc_host *host, int sleep)
b1ebe384 JL	60	{
1278dba1	61	struct mmc_command cmd = {0};
b1ebe384 JL	62	struct mmc_card *card = host->card;
	63	int err;
	64
	65	if (sleep)
	66	mmc_deselect_cards(host);
	67
b1ebe384 JL	68	cmd.opcode = MMC_SLEEP_AWAKE;
	69	cmd.arg = card->rca << 16;
	70	if (sleep)
	71	cmd.arg \|= 1 << 15;
	72
	73	cmd.flags = MMC_RSP_R1B \| MMC_CMD_AC;
	74	err = mmc_wait_for_cmd(host, &cmd, 0);
	75	if (err)
	76	return err;
	77
	78	/*
	79	* If the host does not wait while the card signals busy, then we will
	80	* will have to wait the sleep/awake timeout. Note, we cannot use the
	81	* SEND_STATUS command to poll the status because that command (and most
	82	* others) is invalid while the card sleeps.
	83	*/
	84	if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
	85	mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000));
	86
	87	if (!sleep)
	88	err = mmc_select_card(card);
	89
	90	return err;
	91	}
	92
da7fbe58 PO	93	int mmc_go_idle(struct mmc_host *host)
	94	{
	95	int err;
1278dba1	96	struct mmc_command cmd = {0};
da7fbe58	97
af517150 DB	98	/*
	99	* Non-SPI hosts need to prevent chipselect going active during
	100	* GO_IDLE; that would put chips into SPI mode. Remind them of
	101	* that in case of hardware that won't pull up DAT3/nCS otherwise.
	102	*
	103	* SPI hosts ignore ios.chip_select; it's managed according to
25985edc	104	* rules that must accommodate non-MMC slaves which this layer
af517150 DB	105	* won't even know about.
	106	*/
	107	if (!mmc_host_is_spi(host)) {
	108	mmc_set_chip_select(host, MMC_CS_HIGH);
	109	mmc_delay(1);
	110	}
da7fbe58	111
da7fbe58 PO	112	cmd.opcode = MMC_GO_IDLE_STATE;
da7fbe58 PO	113	cmd.arg = 0;
af517150	114	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_NONE \| MMC_CMD_BC;
da7fbe58 PO	115
	116	err = mmc_wait_for_cmd(host, &cmd, 0);
	117
	118	mmc_delay(1);
	119
af517150 DB	120	if (!mmc_host_is_spi(host)) {
	121	mmc_set_chip_select(host, MMC_CS_DONTCARE);
	122	mmc_delay(1);
	123	}
da7fbe58	124
af517150	125	host->use_spi_crc = 0;
da7fbe58 PO	126
	127	return err;
	128	}
	129
	130	int mmc_send_op_cond(struct mmc_host host, u32 ocr, u32 rocr)
	131	{
1278dba1	132	struct mmc_command cmd = {0};
da7fbe58 PO	133	int i, err = 0;
	134
	135	BUG_ON(!host);
	136
da7fbe58	137	cmd.opcode = MMC_SEND_OP_COND;
af517150 DB	138	cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
af517150 DB	139	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R3 \| MMC_CMD_BCR;
da7fbe58 PO	140
	141	for (i = 100; i; i--) {
	142	err = mmc_wait_for_cmd(host, &cmd, 0);
17b0429d	143	if (err)
da7fbe58 PO	144	break;
da7fbe58 PO	145
af517150 DB	146	/* if we're just probing, do a single pass */
af517150 DB	147	if (ocr == 0)
da7fbe58 PO	148	break;
da7fbe58 PO	149
af517150 DB	150	/* otherwise wait until reset completes */
	151	if (mmc_host_is_spi(host)) {
	152	if (!(cmd.resp[0] & R1_SPI_IDLE))
	153	break;
	154	} else {
	155	if (cmd.resp[0] & MMC_CARD_BUSY)
	156	break;
	157	}
	158
17b0429d	159	err = -ETIMEDOUT;
da7fbe58 PO	160
	161	mmc_delay(10);
	162	}
	163
af517150	164	if (rocr && !mmc_host_is_spi(host))
da7fbe58 PO	165	*rocr = cmd.resp[0];
	166
	167	return err;
	168	}
	169
	170	int mmc_all_send_cid(struct mmc_host host, u32 cid)
	171	{
	172	int err;
1278dba1	173	struct mmc_command cmd = {0};
da7fbe58 PO	174
	175	BUG_ON(!host);
	176	BUG_ON(!cid);
	177
da7fbe58 PO	178	cmd.opcode = MMC_ALL_SEND_CID;
	179	cmd.arg = 0;
	180	cmd.flags = MMC_RSP_R2 \| MMC_CMD_BCR;
	181
	182	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
17b0429d	183	if (err)
da7fbe58 PO	184	return err;
	185
	186	memcpy(cid, cmd.resp, sizeof(u32) * 4);
	187
17b0429d	188	return 0;
da7fbe58 PO	189	}
	190
	191	int mmc_set_relative_addr(struct mmc_card *card)
	192	{
	193	int err;
1278dba1	194	struct mmc_command cmd = {0};
da7fbe58 PO	195
	196	BUG_ON(!card);
	197	BUG_ON(!card->host);
	198
da7fbe58 PO	199	cmd.opcode = MMC_SET_RELATIVE_ADDR;
	200	cmd.arg = card->rca << 16;
	201	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;
	202
	203	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
17b0429d	204	if (err)
da7fbe58 PO	205	return err;
da7fbe58 PO	206
17b0429d	207	return 0;
da7fbe58 PO	208	}
da7fbe58 PO	209
af517150 DB	210	static int
af517150 DB	211	mmc_send_cxd_native(struct mmc_host host, u32 arg, u32 cxd, int opcode)
da7fbe58 PO	212	{
da7fbe58 PO	213	int err;
1278dba1	214	struct mmc_command cmd = {0};
da7fbe58	215
af517150 DB	216	BUG_ON(!host);
af517150 DB	217	BUG_ON(!cxd);
da7fbe58	218
af517150 DB	219	cmd.opcode = opcode;
af517150 DB	220	cmd.arg = arg;
da7fbe58 PO	221	cmd.flags = MMC_RSP_R2 \| MMC_CMD_AC;
da7fbe58 PO	222
af517150	223	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
17b0429d	224	if (err)
da7fbe58 PO	225	return err;
da7fbe58 PO	226
af517150	227	memcpy(cxd, cmd.resp, sizeof(u32) * 4);
da7fbe58	228
17b0429d	229	return 0;
da7fbe58 PO	230	}
da7fbe58 PO	231
af517150 DB	232	static int
	233	mmc_send_cxd_data(struct mmc_card card, struct mmc_host host,
	234	u32 opcode, void *buf, unsigned len)
da7fbe58	235	{
ad5fd972	236	struct mmc_request mrq = {NULL};
1278dba1	237	struct mmc_command cmd = {0};
a61ad2b4	238	struct mmc_data data = {0};
da7fbe58	239	struct scatterlist sg;
af517150	240	void *data_buf;
da7fbe58	241
af517150 DB	242	/* dma onto stack is unsafe/nonportable, but callers to this
	243	* routine normally provide temporary on-stack buffers ...
	244	*/
	245	data_buf = kmalloc(len, GFP_KERNEL);
	246	if (data_buf == NULL)
	247	return -ENOMEM;
da7fbe58	248
da7fbe58 PO	249	mrq.cmd = &cmd;
	250	mrq.data = &data;
	251
af517150	252	cmd.opcode = opcode;
da7fbe58	253	cmd.arg = 0;
da7fbe58	254
af517150 DB	255	/* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
	256	* rely on callers to never use this with "native" calls for reading
	257	* CSD or CID. Native versions of those commands use the R2 type,
	258	* not R1 plus a data block.
	259	*/
	260	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
	261
	262	data.blksz = len;
da7fbe58 PO	263	data.blocks = 1;
	264	data.flags = MMC_DATA_READ;
	265	data.sg = &sg;
	266	data.sg_len = 1;
	267
af517150	268	sg_init_one(&sg, data_buf, len);
da7fbe58	269
cda56ac2 AH	270	if (opcode == MMC_SEND_CSD \|\| opcode == MMC_SEND_CID) {
	271	/*
	272	* The spec states that CSR and CID accesses have a timeout
	273	* of 64 clock cycles.
	274	*/
	275	data.timeout_ns = 0;
	276	data.timeout_clks = 64;
	277	} else
	278	mmc_set_data_timeout(&data, card);
da7fbe58	279
af517150 DB	280	mmc_wait_for_req(host, &mrq);
	281
	282	memcpy(buf, data_buf, len);
	283	kfree(data_buf);
da7fbe58	284
17b0429d	285	if (cmd.error)
da7fbe58	286	return cmd.error;
17b0429d	287	if (data.error)
da7fbe58 PO	288	return data.error;
da7fbe58 PO	289
17b0429d	290	return 0;
da7fbe58 PO	291	}
da7fbe58 PO	292
af517150 DB	293	int mmc_send_csd(struct mmc_card card, u32 csd)
af517150 DB	294	{
78e48073 PO	295	int ret, i;
78e48073 PO	296
af517150 DB	297	if (!mmc_host_is_spi(card->host))
	298	return mmc_send_cxd_native(card->host, card->rca << 16,
	299	csd, MMC_SEND_CSD);
	300
78e48073 PO	301	ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);
	302	if (ret)
	303	return ret;
	304
	305	for (i = 0;i < 4;i++)
	306	csd[i] = be32_to_cpu(csd[i]);
	307
	308	return 0;
af517150 DB	309	}
	310
	311	int mmc_send_cid(struct mmc_host host, u32 cid)
	312	{
78e48073 PO	313	int ret, i;
78e48073 PO	314
af517150 DB	315	if (!mmc_host_is_spi(host)) {
	316	if (!host->card)
	317	return -EINVAL;
	318	return mmc_send_cxd_native(host, host->card->rca << 16,
	319	cid, MMC_SEND_CID);
	320	}
	321
78e48073 PO	322	ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16);
	323	if (ret)
	324	return ret;
	325
	326	for (i = 0;i < 4;i++)
	327	cid[i] = be32_to_cpu(cid[i]);
	328
	329	return 0;
af517150 DB	330	}
	331
	332	int mmc_send_ext_csd(struct mmc_card card, u8 ext_csd)
	333	{
	334	return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
	335	ext_csd, 512);
	336	}
	337
	338	int mmc_spi_read_ocr(struct mmc_host host, int highcap, u32 ocrp)
	339	{
1278dba1	340	struct mmc_command cmd = {0};
af517150 DB	341	int err;
af517150 DB	342
af517150 DB	343	cmd.opcode = MMC_SPI_READ_OCR;
	344	cmd.arg = highcap ? (1 << 30) : 0;
	345	cmd.flags = MMC_RSP_SPI_R3;
	346
	347	err = mmc_wait_for_cmd(host, &cmd, 0);
	348
	349	*ocrp = cmd.resp[1];
	350	return err;
	351	}
	352
	353	int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
	354	{
1278dba1	355	struct mmc_command cmd = {0};
af517150 DB	356	int err;
af517150 DB	357
af517150 DB	358	cmd.opcode = MMC_SPI_CRC_ON_OFF;
	359	cmd.flags = MMC_RSP_SPI_R1;
	360	cmd.arg = use_crc;
	361
	362	err = mmc_wait_for_cmd(host, &cmd, 0);
	363	if (!err)
	364	host->use_spi_crc = use_crc;
	365	return err;
	366	}
	367
d3a8d95d AW	368	/**
	369	* mmc_switch - modify EXT_CSD register
	370	* @card: the MMC card associated with the data transfer
	371	* @set: cmd set values
	372	* @index: EXT_CSD register index
	373	* @value: value to program into EXT_CSD register
	374	* @timeout_ms: timeout (ms) for operation performed by register write,
	375	* timeout of zero implies maximum possible timeout
	376	*
	377	* Modifies the EXT_CSD register for selected card.
	378	*/
	379	int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
	380	unsigned int timeout_ms)
da7fbe58 PO	381	{
da7fbe58 PO	382	int err;
1278dba1	383	struct mmc_command cmd = {0};
ef0b27d4	384	u32 status;
da7fbe58 PO	385
	386	BUG_ON(!card);
	387	BUG_ON(!card->host);
	388
da7fbe58 PO	389	cmd.opcode = MMC_SWITCH;
	390	cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) \|
	391	(index << 16) \|
	392	(value << 8) \|
	393	set;
af517150	394	cmd.flags = MMC_RSP_SPI_R1B \| MMC_RSP_R1B \| MMC_CMD_AC;
d3a8d95d	395	cmd.cmd_timeout_ms = timeout_ms;
da7fbe58 PO	396
da7fbe58 PO	397	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
17b0429d	398	if (err)
da7fbe58 PO	399	return err;
da7fbe58 PO	400
ef0b27d4 AH	401	/* Must check status to be sure of no errors */
	402	do {
	403	err = mmc_send_status(card, &status);
	404	if (err)
	405	return err;
	406	if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
	407	break;
	408	if (mmc_host_is_spi(card->host))
	409	break;
7435bb79	410	} while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
ef0b27d4 AH	411
	412	if (mmc_host_is_spi(card->host)) {
	413	if (status & R1_SPI_ILLEGAL_COMMAND)
	414	return -EBADMSG;
	415	} else {
	416	if (status & 0xFDFFA000)
a3c76eb9	417	pr_warning("%s: unexpected status %#x after "
ef0b27d4 AH	418	"switch", mmc_hostname(card->host), status);
	419	if (status & R1_SWITCH_ERROR)
	420	return -EBADMSG;
	421	}
	422
17b0429d	423	return 0;
da7fbe58	424	}
d3a8d95d	425	EXPORT_SYMBOL_GPL(mmc_switch);
da7fbe58 PO	426
	427	int mmc_send_status(struct mmc_card card, u32 status)
	428	{
	429	int err;
1278dba1	430	struct mmc_command cmd = {0};
da7fbe58 PO	431
	432	BUG_ON(!card);
	433	BUG_ON(!card->host);
	434
da7fbe58	435	cmd.opcode = MMC_SEND_STATUS;
af517150 DB	436	if (!mmc_host_is_spi(card->host))
	437	cmd.arg = card->rca << 16;
	438	cmd.flags = MMC_RSP_SPI_R2 \| MMC_RSP_R1 \| MMC_CMD_AC;
da7fbe58 PO	439
da7fbe58 PO	440	err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
17b0429d	441	if (err)
da7fbe58 PO	442	return err;
da7fbe58 PO	443
af517150 DB	444	/* NOTE: callers are required to understand the difference
	445	* between "native" and SPI format status words!
	446	*/
da7fbe58 PO	447	if (status)
	448	*status = cmd.resp[0];
	449
17b0429d	450	return 0;
da7fbe58 PO	451	}
da7fbe58 PO	452
22113efd AL	453	static int
	454	mmc_send_bus_test(struct mmc_card card, struct mmc_host host, u8 opcode,
	455	u8 len)
	456	{
ad5fd972	457	struct mmc_request mrq = {NULL};
1278dba1	458	struct mmc_command cmd = {0};
a61ad2b4	459	struct mmc_data data = {0};
22113efd AL	460	struct scatterlist sg;
	461	u8 *data_buf;
	462	u8 *test_buf;
	463	int i, err;
	464	static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
	465	static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
	466
	467	/* dma onto stack is unsafe/nonportable, but callers to this
	468	* routine normally provide temporary on-stack buffers ...
	469	*/
	470	data_buf = kmalloc(len, GFP_KERNEL);
	471	if (!data_buf)
	472	return -ENOMEM;
	473
	474	if (len == 8)
	475	test_buf = testdata_8bit;
	476	else if (len == 4)
	477	test_buf = testdata_4bit;
	478	else {
a3c76eb9	479	pr_err("%s: Invalid bus_width %d\n",
22113efd AL	480	mmc_hostname(host), len);
	481	kfree(data_buf);
	482	return -EINVAL;
	483	}
	484
	485	if (opcode == MMC_BUS_TEST_W)
	486	memcpy(data_buf, test_buf, len);
	487
22113efd AL	488	mrq.cmd = &cmd;
	489	mrq.data = &data;
	490	cmd.opcode = opcode;
	491	cmd.arg = 0;
	492
	493	/* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
	494	* rely on callers to never use this with "native" calls for reading
	495	* CSD or CID. Native versions of those commands use the R2 type,
	496	* not R1 plus a data block.
	497	*/
	498	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
	499
	500	data.blksz = len;
	501	data.blocks = 1;
	502	if (opcode == MMC_BUS_TEST_R)
	503	data.flags = MMC_DATA_READ;
	504	else
	505	data.flags = MMC_DATA_WRITE;
	506
	507	data.sg = &sg;
	508	data.sg_len = 1;
	509	sg_init_one(&sg, data_buf, len);
	510	mmc_wait_for_req(host, &mrq);
	511	err = 0;
	512	if (opcode == MMC_BUS_TEST_R) {
	513	for (i = 0; i < len / 4; i++)
	514	if ((test_buf[i] ^ data_buf[i]) != 0xff) {
	515	err = -EIO;
	516	break;
	517	}
	518	}
	519	kfree(data_buf);
	520
	521	if (cmd.error)
	522	return cmd.error;
	523	if (data.error)
	524	return data.error;
	525
	526	return err;
	527	}
	528
	529	int mmc_bus_test(struct mmc_card *card, u8 bus_width)
	530	{
	531	int err, width;
	532
	533	if (bus_width == MMC_BUS_WIDTH_8)
	534	width = 8;
	535	else if (bus_width == MMC_BUS_WIDTH_4)
	536	width = 4;
	537	else if (bus_width == MMC_BUS_WIDTH_1)
	538	return 0; /* no need for test */
	539	else
	540	return -EINVAL;
	541
	542	/*
	543	* Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
	544	* is a problem. This improves chances that the test will work.
	545	*/
	546	mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
	547	err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
	548	return err;
	549	}