1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * linux/drivers/mmc/core/sd_ops.h
5 * Copyright 2006-2007 Pierre Ossman
8 #include <linux/slab.h>
9 #include <linux/types.h>
10 #include <linux/export.h>
11 #include <linux/scatterlist.h>
13 #include <linux/mmc/host.h>
14 #include <linux/mmc/card.h>
15 #include <linux/mmc/mmc.h>
16 #include <linux/mmc/sd.h>
21 int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
24 struct mmc_command cmd = {};
26 if (WARN_ON(card && card->host != host))
29 cmd.opcode = MMC_APP_CMD;
32 cmd.arg = card->rca << 16;
33 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
36 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
39 err = mmc_wait_for_cmd(host, &cmd, 0);
43 /* Check that card supported application commands */
44 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
49 EXPORT_SYMBOL_GPL(mmc_app_cmd);
51 static int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
52 struct mmc_command *cmd)
54 struct mmc_request mrq = {};
58 * We have to resend MMC_APP_CMD for each attempt so
59 * we cannot use the retries field in mmc_command.
61 for (i = 0; i <= MMC_CMD_RETRIES; i++) {
62 err = mmc_app_cmd(host, card);
64 /* no point in retrying; no APP commands allowed */
65 if (mmc_host_is_spi(host)) {
66 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
72 memset(&mrq, 0, sizeof(struct mmc_request));
74 memset(cmd->resp, 0, sizeof(cmd->resp));
80 mmc_wait_for_req(host, &mrq);
86 /* no point in retrying illegal APP commands */
87 if (mmc_host_is_spi(host)) {
88 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
96 int mmc_app_set_bus_width(struct mmc_card *card, int width)
98 struct mmc_command cmd = {};
100 cmd.opcode = SD_APP_SET_BUS_WIDTH;
101 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
104 case MMC_BUS_WIDTH_1:
105 cmd.arg = SD_BUS_WIDTH_1;
107 case MMC_BUS_WIDTH_4:
108 cmd.arg = SD_BUS_WIDTH_4;
114 return mmc_wait_for_app_cmd(card->host, card, &cmd);
117 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
119 struct mmc_command cmd = {};
122 cmd.opcode = SD_APP_OP_COND;
123 if (mmc_host_is_spi(host))
124 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
127 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
129 for (i = 100; i; i--) {
130 err = mmc_wait_for_app_cmd(host, NULL, &cmd);
134 /* if we're just probing, do a single pass */
138 /* otherwise wait until reset completes */
139 if (mmc_host_is_spi(host)) {
140 if (!(cmd.resp[0] & R1_SPI_IDLE))
143 if (cmd.resp[0] & MMC_CARD_BUSY)
153 pr_err("%s: card never left busy state\n", mmc_hostname(host));
155 if (rocr && !mmc_host_is_spi(host))
161 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
163 struct mmc_command cmd = {};
165 static const u8 test_pattern = 0xAA;
169 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
170 * before SD_APP_OP_COND. This command will harmlessly fail for
173 cmd.opcode = SD_SEND_IF_COND;
174 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
175 cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
177 err = mmc_wait_for_cmd(host, &cmd, 0);
181 if (mmc_host_is_spi(host))
182 result_pattern = cmd.resp[1] & 0xFF;
184 result_pattern = cmd.resp[0] & 0xFF;
186 if (result_pattern != test_pattern)
192 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
195 struct mmc_command cmd = {};
197 cmd.opcode = SD_SEND_RELATIVE_ADDR;
199 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
201 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
205 *rca = cmd.resp[0] >> 16;
210 int mmc_app_send_scr(struct mmc_card *card)
213 struct mmc_request mrq = {};
214 struct mmc_command cmd = {};
215 struct mmc_data data = {};
216 struct scatterlist sg;
219 /* NOTE: caller guarantees scr is heap-allocated */
221 err = mmc_app_cmd(card->host, card);
225 /* dma onto stack is unsafe/nonportable, but callers to this
226 * routine normally provide temporary on-stack buffers ...
228 scr = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
235 cmd.opcode = SD_APP_SEND_SCR;
237 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
241 data.flags = MMC_DATA_READ;
245 sg_init_one(&sg, scr, 8);
247 mmc_set_data_timeout(&data, card);
249 mmc_wait_for_req(card->host, &mrq);
251 card->raw_scr[0] = be32_to_cpu(scr[0]);
252 card->raw_scr[1] = be32_to_cpu(scr[1]);
264 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
267 struct mmc_request mrq = {};
268 struct mmc_command cmd = {};
269 struct mmc_data data = {};
270 struct scatterlist sg;
272 /* NOTE: caller guarantees resp is heap-allocated */
280 cmd.opcode = SD_SWITCH;
281 cmd.arg = mode << 31 | 0x00FFFFFF;
282 cmd.arg &= ~(0xF << (group * 4));
283 cmd.arg |= value << (group * 4);
284 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
288 data.flags = MMC_DATA_READ;
292 sg_init_one(&sg, resp, 64);
294 mmc_set_data_timeout(&data, card);
296 mmc_wait_for_req(card->host, &mrq);
306 int mmc_app_sd_status(struct mmc_card *card, void *ssr)
309 struct mmc_request mrq = {};
310 struct mmc_command cmd = {};
311 struct mmc_data data = {};
312 struct scatterlist sg;
314 /* NOTE: caller guarantees ssr is heap-allocated */
316 err = mmc_app_cmd(card->host, card);
323 cmd.opcode = SD_APP_SD_STATUS;
325 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;
329 data.flags = MMC_DATA_READ;
333 sg_init_one(&sg, ssr, 64);
335 mmc_set_data_timeout(&data, card);
337 mmc_wait_for_req(card->host, &mrq);