[linux-block.git] / drivers / mmc / core / sd_ops.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  linux/drivers/mmc/core/sd_ops.h
 *
 *  Copyright 2006-2007 Pierre Ossman
 */

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

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

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

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

	if (WARN_ON(card && card->host != host))
		return -EINVAL;

	cmd.opcode = MMC_APP_CMD;

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

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

	/* Check that card supported application commands */
	if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
		return -EOPNOTSUPP;

	return 0;
}
EXPORT_SYMBOL_GPL(mmc_app_cmd);

static int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
				struct mmc_command *cmd)
{
	struct mmc_request mrq = {};
	int i, err = -EIO;

	/*
	 * We have to resend MMC_APP_CMD for each attempt so
	 * we cannot use the retries field in mmc_command.
	 */
	for (i = 0; i <= MMC_CMD_RETRIES; i++) {
		err = mmc_app_cmd(host, card);
		if (err) {
			/* no point in retrying; no APP commands allowed */
			if (mmc_host_is_spi(host)) {
				if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
					break;
			}
			continue;
		}

		memset(&mrq, 0, sizeof(struct mmc_request));

		memset(cmd->resp, 0, sizeof(cmd->resp));
		cmd->retries = 0;

		mrq.cmd = cmd;
		cmd->data = NULL;

		mmc_wait_for_req(host, &mrq);

		err = cmd->error;
		if (!cmd->error)
			break;

		/* no point in retrying illegal APP commands */
		if (mmc_host_is_spi(host)) {
			if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
				break;
		}
	}

	return err;
}

int mmc_app_set_bus_width(struct mmc_card *card, int width)
{
	struct mmc_command cmd = {};

	cmd.opcode = SD_APP_SET_BUS_WIDTH;
	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

	switch (width) {
	case MMC_BUS_WIDTH_1:
		cmd.arg = SD_BUS_WIDTH_1;
		break;
	case MMC_BUS_WIDTH_4:
		cmd.arg = SD_BUS_WIDTH_4;
		break;
	default:
		return -EINVAL;
	}

	return mmc_wait_for_app_cmd(card->host, card, &cmd);
}

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

	cmd.opcode = SD_APP_OP_COND;
	if (mmc_host_is_spi(host))
		cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
	else
		cmd.arg = ocr;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;

	for (i = 100; i; i--) {
		err = mmc_wait_for_app_cmd(host, NULL, &cmd);
		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 (!i)
		pr_err("%s: card never left busy state\n", mmc_hostname(host));

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

	return err;
}

static int __mmc_send_if_cond(struct mmc_host *host, u32 ocr, u8 pcie_bits,
			      u32 *resp)
{
	struct mmc_command cmd = {};
	int err;
	static const u8 test_pattern = 0xAA;
	u8 result_pattern;

	/*
	 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
	 * before SD_APP_OP_COND. This command will harmlessly fail for
	 * SD 1.0 cards.
	 */
	cmd.opcode = SD_SEND_IF_COND;
	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | pcie_bits << 8 | test_pattern;
	cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;

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

	if (mmc_host_is_spi(host))
		result_pattern = cmd.resp[1] & 0xFF;
	else
		result_pattern = cmd.resp[0] & 0xFF;

	if (result_pattern != test_pattern)
		return -EIO;

	if (resp)
		*resp = cmd.resp[0];

	return 0;
}

int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
{
	return __mmc_send_if_cond(host, ocr, 0, NULL);
}

int mmc_send_if_cond_pcie(struct mmc_host *host, u32 ocr)
{
	u32 resp = 0;
	u8 pcie_bits = 0;
	int ret;

	if (host->caps2 & MMC_CAP2_SD_EXP) {
		/* Probe card for SD express support via PCIe. */
		pcie_bits = 0x10;
		if (host->caps2 & MMC_CAP2_SD_EXP_1_2V)
			/* Probe also for 1.2V support. */
			pcie_bits = 0x30;
	}

	ret = __mmc_send_if_cond(host, ocr, pcie_bits, &resp);
	if (ret)
		return 0;

	/* Continue with the SD express init, if the card supports it. */
	resp &= 0x3000;
	if (pcie_bits && resp) {
		if (resp == 0x3000)
			host->ios.timing = MMC_TIMING_SD_EXP_1_2V;
		else
			host->ios.timing = MMC_TIMING_SD_EXP;

		/*
		 * According to the spec the clock shall also be gated, but
		 * let's leave this to the host driver for more flexibility.
		 */
		return host->ops->init_sd_express(host, &host->ios);
	}

	return 0;
}

int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
{
	int err;
	struct mmc_command cmd = {};

	cmd.opcode = SD_SEND_RELATIVE_ADDR;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;

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

	*rca = cmd.resp[0] >> 16;

	return 0;
}

int mmc_app_send_scr(struct mmc_card *card)
{
	int err;
	struct mmc_request mrq = {};
	struct mmc_command cmd = {};
	struct mmc_data data = {};
	struct scatterlist sg;
	__be32 *scr;

	/* NOTE: caller guarantees scr is heap-allocated */

	err = mmc_app_cmd(card->host, card);
	if (err)
		return err;

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

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

	cmd.opcode = SD_APP_SEND_SCR;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

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

	sg_init_one(&sg, scr, 8);

	mmc_set_data_timeout(&data, card);

	mmc_wait_for_req(card->host, &mrq);

	card->raw_scr[0] = be32_to_cpu(scr[0]);
	card->raw_scr[1] = be32_to_cpu(scr[1]);

	kfree(scr);

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

	return 0;
}

int mmc_sd_switch(struct mmc_card *card, int mode, int group,
	u8 value, u8 *resp)
{
	u32 cmd_args;

	/* NOTE: caller guarantees resp is heap-allocated */

	mode = !!mode;
	value &= 0xF;
	cmd_args = mode << 31 | 0x00FFFFFF;
	cmd_args &= ~(0xF << (group * 4));
	cmd_args |= value << (group * 4);

	return mmc_send_adtc_data(card, card->host, SD_SWITCH, cmd_args, resp,
				  64);
}
EXPORT_SYMBOL_GPL(mmc_sd_switch);

int mmc_app_sd_status(struct mmc_card *card, void *ssr)
{
	int err;
	struct mmc_request mrq = {};
	struct mmc_command cmd = {};
	struct mmc_data data = {};
	struct scatterlist sg;

	/* NOTE: caller guarantees ssr is heap-allocated */

	err = mmc_app_cmd(card->host, card);
	if (err)
		return err;

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

	cmd.opcode = SD_APP_SD_STATUS;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;

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

	sg_init_one(&sg, ssr, 64);

	mmc_set_data_timeout(&data, card);

	mmc_wait_for_req(card->host, &mrq);

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

	return 0;
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
da7fbe58	2	/*
70f10482	3	* linux/drivers/mmc/core/sd_ops.h
da7fbe58 PO	4	*
da7fbe58 PO	5	* Copyright 2006-2007 Pierre Ossman
da7fbe58 PO	6	*/
da7fbe58 PO	7
4f665cb6	8	#include <linux/slab.h>
da7fbe58	9	#include <linux/types.h>
3ef77af1	10	#include <linux/export.h>
da7fbe58 PO	11	#include <linux/scatterlist.h>
	12
	13	#include <linux/mmc/host.h>
	14	#include <linux/mmc/card.h>
	15	#include <linux/mmc/mmc.h>
	16	#include <linux/mmc/sd.h>
	17
	18	#include "core.h"
	19	#include "sd_ops.h"
41e84fe1	20	#include "mmc_ops.h"
da7fbe58	21
cb87ea28	22	int mmc_app_cmd(struct mmc_host host, struct mmc_card card)
39361851 AB	23	{
39361851 AB	24	int err;
c7836d15	25	struct mmc_command cmd = {};
39361851	26
349583d6 SL	27	if (WARN_ON(card && card->host != host))
349583d6 SL	28	return -EINVAL;
39361851 AB	29
	30	cmd.opcode = MMC_APP_CMD;
	31
	32	if (card) {
	33	cmd.arg = card->rca << 16;
af517150	34	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_AC;
39361851 AB	35	} else {
39361851 AB	36	cmd.arg = 0;
af517150	37	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_BCR;
39361851 AB	38	}
	39
	40	err = mmc_wait_for_cmd(host, &cmd, 0);
17b0429d	41	if (err)
39361851 AB	42	return err;
	43
	44	/* Check that card supported application commands */
af517150	45	if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
17b0429d	46	return -EOPNOTSUPP;
39361851	47
17b0429d	48	return 0;
39361851	49	}
cb87ea28	50	EXPORT_SYMBOL_GPL(mmc_app_cmd);
39361851	51
9a4b869b	52	static int mmc_wait_for_app_cmd(struct mmc_host host, struct mmc_card card,
03cd5c05	53	struct mmc_command *cmd)
da7fbe58	54	{
c7836d15	55	struct mmc_request mrq = {};
03cd5c05	56	int i, err = -EIO;
da7fbe58 PO	57
	58	/*
	59	* We have to resend MMC_APP_CMD for each attempt so
	60	* we cannot use the retries field in mmc_command.
	61	*/
03cd5c05	62	for (i = 0; i <= MMC_CMD_RETRIES; i++) {
da7fbe58	63	err = mmc_app_cmd(host, card);
af517150 DB	64	if (err) {
	65	/* no point in retrying; no APP commands allowed */
	66	if (mmc_host_is_spi(host)) {
	67	if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
	68	break;
	69	}
da7fbe58	70	continue;
af517150	71	}
da7fbe58 PO	72
	73	memset(&mrq, 0, sizeof(struct mmc_request));
	74
	75	memset(cmd->resp, 0, sizeof(cmd->resp));
	76	cmd->retries = 0;
	77
	78	mrq.cmd = cmd;
	79	cmd->data = NULL;
	80
	81	mmc_wait_for_req(host, &mrq);
	82
	83	err = cmd->error;
17b0429d	84	if (!cmd->error)
da7fbe58	85	break;
af517150 DB	86
	87	/* no point in retrying illegal APP commands */
	88	if (mmc_host_is_spi(host)) {
	89	if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
	90	break;
	91	}
da7fbe58 PO	92	}
	93
	94	return err;
	95	}
	96
da7fbe58 PO	97	int mmc_app_set_bus_width(struct mmc_card *card, int width)
da7fbe58 PO	98	{
c7836d15	99	struct mmc_command cmd = {};
da7fbe58	100
da7fbe58 PO	101	cmd.opcode = SD_APP_SET_BUS_WIDTH;
	102	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;
	103
	104	switch (width) {
	105	case MMC_BUS_WIDTH_1:
	106	cmd.arg = SD_BUS_WIDTH_1;
	107	break;
	108	case MMC_BUS_WIDTH_4:
	109	cmd.arg = SD_BUS_WIDTH_4;
	110	break;
	111	default:
17b0429d	112	return -EINVAL;
da7fbe58 PO	113	}
da7fbe58 PO	114
03cd5c05	115	return mmc_wait_for_app_cmd(card->host, card, &cmd);
da7fbe58 PO	116	}
	117
	118	int mmc_send_app_op_cond(struct mmc_host host, u32 ocr, u32 rocr)
	119	{
c7836d15	120	struct mmc_command cmd = {};
da7fbe58 PO	121	int i, err = 0;
da7fbe58 PO	122
da7fbe58	123	cmd.opcode = SD_APP_OP_COND;
af517150 DB	124	if (mmc_host_is_spi(host))
	125	cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
	126	else
	127	cmd.arg = ocr;
	128	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R3 \| MMC_CMD_BCR;
da7fbe58 PO	129
da7fbe58 PO	130	for (i = 100; i; i--) {
03cd5c05	131	err = mmc_wait_for_app_cmd(host, NULL, &cmd);
17b0429d	132	if (err)
da7fbe58 PO	133	break;
da7fbe58 PO	134
af517150 DB	135	/* if we're just probing, do a single pass */
af517150 DB	136	if (ocr == 0)
da7fbe58 PO	137	break;
da7fbe58 PO	138
af517150 DB	139	/* otherwise wait until reset completes */
	140	if (mmc_host_is_spi(host)) {
	141	if (!(cmd.resp[0] & R1_SPI_IDLE))
	142	break;
	143	} else {
	144	if (cmd.resp[0] & MMC_CARD_BUSY)
	145	break;
	146	}
	147
17b0429d	148	err = -ETIMEDOUT;
da7fbe58 PO	149
	150	mmc_delay(10);
	151	}
	152
5e863662 JR	153	if (!i)
	154	pr_err("%s: card never left busy state\n", mmc_hostname(host));
	155
af517150	156	if (rocr && !mmc_host_is_spi(host))
da7fbe58 PO	157	*rocr = cmd.resp[0];
	158
	159	return err;
	160	}
	161
ead49373 UH	162	static int __mmc_send_if_cond(struct mmc_host *host, u32 ocr, u8 pcie_bits,
ead49373 UH	163	u32 *resp)
da7fbe58	164	{
c7836d15	165	struct mmc_command cmd = {};
da7fbe58 PO	166	int err;
da7fbe58 PO	167	static const u8 test_pattern = 0xAA;
af517150	168	u8 result_pattern;
da7fbe58 PO	169
	170	/*
	171	* To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
	172	* before SD_APP_OP_COND. This command will harmlessly fail for
	173	* SD 1.0 cards.
	174	*/
	175	cmd.opcode = SD_SEND_IF_COND;
ead49373	176	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 \| pcie_bits << 8 \| test_pattern;
af517150	177	cmd.flags = MMC_RSP_SPI_R7 \| MMC_RSP_R7 \| MMC_CMD_BCR;
da7fbe58 PO	178
da7fbe58 PO	179	err = mmc_wait_for_cmd(host, &cmd, 0);
17b0429d	180	if (err)
da7fbe58 PO	181	return err;
da7fbe58 PO	182
af517150 DB	183	if (mmc_host_is_spi(host))
	184	result_pattern = cmd.resp[1] & 0xFF;
	185	else
	186	result_pattern = cmd.resp[0] & 0xFF;
	187
	188	if (result_pattern != test_pattern)
17b0429d	189	return -EIO;
da7fbe58	190
ead49373 UH	191	if (resp)
	192	*resp = cmd.resp[0];
	193
	194	return 0;
	195	}
	196
	197	int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
	198	{
	199	return __mmc_send_if_cond(host, ocr, 0, NULL);
	200	}
	201
	202	int mmc_send_if_cond_pcie(struct mmc_host *host, u32 ocr)
	203	{
	204	u32 resp = 0;
	205	u8 pcie_bits = 0;
	206	int ret;
	207
	208	if (host->caps2 & MMC_CAP2_SD_EXP) {
	209	/* Probe card for SD express support via PCIe. */
	210	pcie_bits = 0x10;
	211	if (host->caps2 & MMC_CAP2_SD_EXP_1_2V)
	212	/* Probe also for 1.2V support. */
	213	pcie_bits = 0x30;
	214	}
	215
	216	ret = __mmc_send_if_cond(host, ocr, pcie_bits, &resp);
	217	if (ret)
	218	return 0;
	219
	220	/* Continue with the SD express init, if the card supports it. */
	221	resp &= 0x3000;
	222	if (pcie_bits && resp) {
	223	if (resp == 0x3000)
	224	host->ios.timing = MMC_TIMING_SD_EXP_1_2V;
	225	else
	226	host->ios.timing = MMC_TIMING_SD_EXP;
	227
	228	/*
	229	* According to the spec the clock shall also be gated, but
	230	* let's leave this to the host driver for more flexibility.
	231	*/
	232	return host->ops->init_sd_express(host, &host->ios);
	233	}
	234
17b0429d	235	return 0;
da7fbe58 PO	236	}
	237
	238	int mmc_send_relative_addr(struct mmc_host host, unsigned int rca)
	239	{
	240	int err;
c7836d15	241	struct mmc_command cmd = {};
da7fbe58	242
da7fbe58 PO	243	cmd.opcode = SD_SEND_RELATIVE_ADDR;
	244	cmd.arg = 0;
	245	cmd.flags = MMC_RSP_R6 \| MMC_CMD_BCR;
	246
	247	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
17b0429d	248	if (err)
da7fbe58 PO	249	return err;
	250
	251	*rca = cmd.resp[0] >> 16;
	252
17b0429d	253	return 0;
da7fbe58 PO	254	}
da7fbe58 PO	255
06c9ccb7	256	int mmc_app_send_scr(struct mmc_card *card)
da7fbe58 PO	257	{
da7fbe58 PO	258	int err;
c7836d15 MY	259	struct mmc_request mrq = {};
	260	struct mmc_command cmd = {};
	261	struct mmc_data data = {};
da7fbe58	262	struct scatterlist sg;
06c9ccb7	263	__be32 *scr;
da7fbe58	264
af517150 DB	265	/* NOTE: caller guarantees scr is heap-allocated */
af517150 DB	266
da7fbe58	267	err = mmc_app_cmd(card->host, card);
17b0429d	268	if (err)
da7fbe58 PO	269	return err;
da7fbe58 PO	270
4f665cb6 YS	271	/* dma onto stack is unsafe/nonportable, but callers to this
	272	* routine normally provide temporary on-stack buffers ...
	273	*/
06c9ccb7 WT	274	scr = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
06c9ccb7 WT	275	if (!scr)
4f665cb6 YS	276	return -ENOMEM;
4f665cb6 YS	277
da7fbe58 PO	278	mrq.cmd = &cmd;
	279	mrq.data = &data;
	280
	281	cmd.opcode = SD_APP_SEND_SCR;
	282	cmd.arg = 0;
af517150	283	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
da7fbe58 PO	284
	285	data.blksz = 8;
	286	data.blocks = 1;
	287	data.flags = MMC_DATA_READ;
	288	data.sg = &sg;
	289	data.sg_len = 1;
	290
06c9ccb7	291	sg_init_one(&sg, scr, 8);
da7fbe58	292
b146d26a	293	mmc_set_data_timeout(&data, card);
da7fbe58 PO	294
	295	mmc_wait_for_req(card->host, &mrq);
	296
06c9ccb7 WT	297	card->raw_scr[0] = be32_to_cpu(scr[0]);
	298	card->raw_scr[1] = be32_to_cpu(scr[1]);
	299
	300	kfree(scr);
4f665cb6	301
17b0429d	302	if (cmd.error)
da7fbe58	303	return cmd.error;
17b0429d	304	if (data.error)
da7fbe58 PO	305	return data.error;
da7fbe58 PO	306
17b0429d	307	return 0;
da7fbe58 PO	308	}
	309
	310	int mmc_sd_switch(struct mmc_card *card, int mode, int group,
	311	u8 value, u8 *resp)
	312	{
41e84fe1	313	u32 cmd_args;
da7fbe58	314
af517150 DB	315	/* NOTE: caller guarantees resp is heap-allocated */
af517150 DB	316
da7fbe58 PO	317	mode = !!mode;
da7fbe58 PO	318	value &= 0xF;
41e84fe1 UH	319	cmd_args = mode << 31 \| 0x00FFFFFF;
	320	cmd_args &= ~(0xF << (group * 4));
	321	cmd_args \|= value << (group * 4);
da7fbe58	322
41e84fe1 UH	323	return mmc_send_adtc_data(card, card->host, SD_SWITCH, cmd_args, resp,
41e84fe1 UH	324	64);
da7fbe58	325	}
bac80683	326	EXPORT_SYMBOL_GPL(mmc_sd_switch);
da7fbe58	327
dfe86cba AH	328	int mmc_app_sd_status(struct mmc_card card, void ssr)
	329	{
	330	int err;
c7836d15 MY	331	struct mmc_request mrq = {};
	332	struct mmc_command cmd = {};
	333	struct mmc_data data = {};
dfe86cba AH	334	struct scatterlist sg;
dfe86cba AH	335
dfe86cba AH	336	/* NOTE: caller guarantees ssr is heap-allocated */
	337
	338	err = mmc_app_cmd(card->host, card);
	339	if (err)
	340	return err;
	341
dfe86cba AH	342	mrq.cmd = &cmd;
	343	mrq.data = &data;
	344
	345	cmd.opcode = SD_APP_SD_STATUS;
	346	cmd.arg = 0;
	347	cmd.flags = MMC_RSP_SPI_R2 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
	348
	349	data.blksz = 64;
	350	data.blocks = 1;
	351	data.flags = MMC_DATA_READ;
	352	data.sg = &sg;
	353	data.sg_len = 1;
	354
	355	sg_init_one(&sg, ssr, 64);
	356
	357	mmc_set_data_timeout(&data, card);
	358
	359	mmc_wait_for_req(card->host, &mrq);
	360
	361	if (cmd.error)
	362	return cmd.error;
	363	if (data.error)
	364	return data.error;
	365
	366	return 0;
	367	}