1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *  linux/drivers/mmc/core/sd_ops.h
4 *
5 *  Copyright 2006-2007 Pierre Ossman
6 */
7
8#include <linux/slab.h>
9#include <linux/types.h>
10#include <linux/export.h>
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"
20#include "mmc_ops.h"
21
22int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
23{
24	int err;
25	struct mmc_command cmd = {};
26
27	if (WARN_ON(card && card->host != host))
28		return -EINVAL;
29
30	cmd.opcode = MMC_APP_CMD;
31
32	if (card) {
33		cmd.arg = card->rca << 16;
34		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
35	} else {
36		cmd.arg = 0;
37		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
38	}
39
40	err = mmc_wait_for_cmd(host, &cmd, 0);
41	if (err)
42		return err;
43
44	/* Check that card supported application commands */
45	if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
46		return -EOPNOTSUPP;
47
48	return 0;
49}
50EXPORT_SYMBOL_GPL(mmc_app_cmd);
51
52static int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
53				struct mmc_command *cmd)
54{
55	struct mmc_request mrq = {};
56	int i, err = -EIO;
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	 */
62	for (i = 0; i <= MMC_CMD_RETRIES; i++) {
63		err = mmc_app_cmd(host, card);
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			}
70			continue;
71		}
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;
84		if (!cmd->error)
85			break;
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		}
92	}
93
94	return err;
95}
96
97int mmc_app_set_bus_width(struct mmc_card *card, int width)
98{
99	struct mmc_command cmd = {};
100
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:
112		return -EINVAL;
113	}
114
115	return mmc_wait_for_app_cmd(card->host, card, &cmd);
116}
117
118int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
119{
120	struct mmc_command cmd = {};
121	int i, err = 0;
122
123	cmd.opcode = SD_APP_OP_COND;
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;
129
130	for (i = 100; i; i--) {
131		err = mmc_wait_for_app_cmd(host, NULL, &cmd);
132		if (err)
133			break;
134
135		/* if we're just probing, do a single pass */
136		if (ocr == 0)
137			break;
138
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
148		err = -ETIMEDOUT;
149
150		mmc_delay(10);
151	}
152
153	if (!i)
154		pr_err("%s: card never left busy state\n", mmc_hostname(host));
155
156	if (rocr && !mmc_host_is_spi(host))
157		*rocr = cmd.resp[0];
158
159	return err;
160}
161
162static int __mmc_send_if_cond(struct mmc_host *host, u32 ocr, u8 pcie_bits,
163			      u32 *resp)
164{
165	struct mmc_command cmd = {};
166	int err;
167	static const u8 test_pattern = 0xAA;
168	u8 result_pattern;
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;
176	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | pcie_bits << 8 | test_pattern;
177	cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
178
179	err = mmc_wait_for_cmd(host, &cmd, 0);
180	if (err)
181		return err;
182
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)
189		return -EIO;
190
191	if (resp)
192		*resp = cmd.resp[0];
193
194	return 0;
195}
196
197int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
198{
199	return __mmc_send_if_cond(host, ocr, 0, NULL);
200}
201
202int 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
235	return 0;
236}
237
238int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
239{
240	int err;
241	struct mmc_command cmd = {};
242
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);
248	if (err)
249		return err;
250
251	*rca = cmd.resp[0] >> 16;
252
253	return 0;
254}
255
256int mmc_app_send_scr(struct mmc_card *card)
257{
258	int err;
259	struct mmc_request mrq = {};
260	struct mmc_command cmd = {};
261	struct mmc_data data = {};
262	struct scatterlist sg;
263	__be32 *scr;
264
265	/* NOTE: caller guarantees scr is heap-allocated */
266
267	err = mmc_app_cmd(card->host, card);
268	if (err)
269		return err;
270
271	/* dma onto stack is unsafe/nonportable, but callers to this
272	 * routine normally provide temporary on-stack buffers ...
273	 */
274	scr = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
275	if (!scr)
276		return -ENOMEM;
277
278	mrq.cmd = &cmd;
279	mrq.data = &data;
280
281	cmd.opcode = SD_APP_SEND_SCR;
282	cmd.arg = 0;
283	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
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
291	sg_init_one(&sg, scr, 8);
292
293	mmc_set_data_timeout(&data, card);
294
295	mmc_wait_for_req(card->host, &mrq);
296
297	card->raw_scr[0] = be32_to_cpu(scr[0]);
298	card->raw_scr[1] = be32_to_cpu(scr[1]);
299
300	kfree(scr);
301
302	if (cmd.error)
303		return cmd.error;
304	if (data.error)
305		return data.error;
306
307	return 0;
308}
309
310int mmc_sd_switch(struct mmc_card *card, int mode, int group,
311	u8 value, u8 *resp)
312{
313	u32 cmd_args;
314
315	/* NOTE: caller guarantees resp is heap-allocated */
316
317	mode = !!mode;
318	value &= 0xF;
319	cmd_args = mode << 31 | 0x00FFFFFF;
320	cmd_args &= ~(0xF << (group * 4));
321	cmd_args |= value << (group * 4);
322
323	return mmc_send_adtc_data(card, card->host, SD_SWITCH, cmd_args, resp,
324				  64);
325}
326EXPORT_SYMBOL_GPL(mmc_sd_switch);
327
328int mmc_app_sd_status(struct mmc_card *card, void *ssr)
329{
330	int err;
331	struct mmc_request mrq = {};
332	struct mmc_command cmd = {};
333	struct mmc_data data = {};
334	struct scatterlist sg;
335
336	/* NOTE: caller guarantees ssr is heap-allocated */
337
338	err = mmc_app_cmd(card->host, card);
339	if (err)
340		return err;
341
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}
368