1/*
2 *  linux/drivers/mmc/core/sd_ops.h
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
12#include <linux/slab.h>
13#include <linux/types.h>
14#include <linux/export.h>
15#include <linux/scatterlist.h>
16
17#include <linux/mmc/host.h>
18#include <linux/mmc/card.h>
19#include <linux/mmc/mmc.h>
20#include <linux/mmc/sd.h>
21
22#include "core.h"
23#include "sd_ops.h"
24
25int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
26{
27	int err;
28	struct mmc_command cmd = {0};
29
30	BUG_ON(!host);
31	BUG_ON(card && (card->host != host));
32
33	cmd.opcode = MMC_APP_CMD;
34
35	if (card) {
36		cmd.arg = card->rca << 16;
37		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
38	} else {
39		cmd.arg = 0;
40		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
41	}
42
43	err = mmc_wait_for_cmd(host, &cmd, 0);
44	if (err)
45		return err;
46
47	/* Check that card supported application commands */
48	if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
49		return -EOPNOTSUPP;
50
51	return 0;
52}
53EXPORT_SYMBOL_GPL(mmc_app_cmd);
54
55/**
56 *	mmc_wait_for_app_cmd - start an application command and wait for
57 			       completion
58 *	@host: MMC host to start command
59 *	@card: Card to send MMC_APP_CMD to
60 *	@cmd: MMC command to start
61 *	@retries: maximum number of retries
62 *
63 *	Sends a MMC_APP_CMD, checks the card response, sends the command
64 *	in the parameter and waits for it to complete. Return any error
65 *	that occurred while the command was executing.  Do not attempt to
66 *	parse the response.
67 */
68int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
69	struct mmc_command *cmd, int retries)
70{
71	struct mmc_request mrq = {NULL};
72
73	int i, err;
74
75	BUG_ON(!cmd);
76	BUG_ON(retries < 0);
77
78	err = -EIO;
79
80	/*
81	 * We have to resend MMC_APP_CMD for each attempt so
82	 * we cannot use the retries field in mmc_command.
83	 */
84	for (i = 0;i <= retries;i++) {
85		err = mmc_app_cmd(host, card);
86		if (err) {
87			/* no point in retrying; no APP commands allowed */
88			if (mmc_host_is_spi(host)) {
89				if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
90					break;
91			}
92			continue;
93		}
94
95		memset(&mrq, 0, sizeof(struct mmc_request));
96
97		memset(cmd->resp, 0, sizeof(cmd->resp));
98		cmd->retries = 0;
99
100		mrq.cmd = cmd;
101		cmd->data = NULL;
102
103		mmc_wait_for_req(host, &mrq);
104
105		err = cmd->error;
106		if (!cmd->error)
107			break;
108
109		/* no point in retrying illegal APP commands */
110		if (mmc_host_is_spi(host)) {
111			if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
112				break;
113		}
114	}
115
116	return err;
117}
118
119EXPORT_SYMBOL(mmc_wait_for_app_cmd);
120
121int mmc_app_set_bus_width(struct mmc_card *card, int width)
122{
123	int err;
124	struct mmc_command cmd = {0};
125
126	BUG_ON(!card);
127	BUG_ON(!card->host);
128
129	cmd.opcode = SD_APP_SET_BUS_WIDTH;
130	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
131
132	switch (width) {
133	case MMC_BUS_WIDTH_1:
134		cmd.arg = SD_BUS_WIDTH_1;
135		break;
136	case MMC_BUS_WIDTH_4:
137		cmd.arg = SD_BUS_WIDTH_4;
138		break;
139	default:
140		return -EINVAL;
141	}
142
143	err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
144	if (err)
145		return err;
146
147	return 0;
148}
149
150int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
151{
152	struct mmc_command cmd = {0};
153	int i, err = 0;
154
155	BUG_ON(!host);
156
157	cmd.opcode = SD_APP_OP_COND;
158	if (mmc_host_is_spi(host))
159		cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
160	else
161		cmd.arg = ocr;
162	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
163
164	for (i = 100; i; i--) {
165		err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
166		if (err)
167			break;
168
169		/* if we're just probing, do a single pass */
170		if (ocr == 0)
171			break;
172
173		/* otherwise wait until reset completes */
174		if (mmc_host_is_spi(host)) {
175			if (!(cmd.resp[0] & R1_SPI_IDLE))
176				break;
177		} else {
178			if (cmd.resp[0] & MMC_CARD_BUSY)
179				break;
180		}
181
182		err = -ETIMEDOUT;
183
184		mmc_delay(10);
185	}
186
187	if (!i)
188		pr_err("%s: card never left busy state\n", mmc_hostname(host));
189
190	if (rocr && !mmc_host_is_spi(host))
191		*rocr = cmd.resp[0];
192
193	return err;
194}
195
196int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
197{
198	struct mmc_command cmd = {0};
199	int err;
200	static const u8 test_pattern = 0xAA;
201	u8 result_pattern;
202
203	/*
204	 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
205	 * before SD_APP_OP_COND. This command will harmlessly fail for
206	 * SD 1.0 cards.
207	 */
208	cmd.opcode = SD_SEND_IF_COND;
209	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
210	cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
211
212	err = mmc_wait_for_cmd(host, &cmd, 0);
213	if (err)
214		return err;
215
216	if (mmc_host_is_spi(host))
217		result_pattern = cmd.resp[1] & 0xFF;
218	else
219		result_pattern = cmd.resp[0] & 0xFF;
220
221	if (result_pattern != test_pattern)
222		return -EIO;
223
224	return 0;
225}
226
227int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
228{
229	int err;
230	struct mmc_command cmd = {0};
231
232	BUG_ON(!host);
233	BUG_ON(!rca);
234
235	cmd.opcode = SD_SEND_RELATIVE_ADDR;
236	cmd.arg = 0;
237	cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
238
239	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
240	if (err)
241		return err;
242
243	*rca = cmd.resp[0] >> 16;
244
245	return 0;
246}
247
248int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
249{
250	int err;
251	struct mmc_request mrq = {NULL};
252	struct mmc_command cmd = {0};
253	struct mmc_data data = {0};
254	struct scatterlist sg;
255	void *data_buf;
256
257	BUG_ON(!card);
258	BUG_ON(!card->host);
259	BUG_ON(!scr);
260
261	/* NOTE: caller guarantees scr is heap-allocated */
262
263	err = mmc_app_cmd(card->host, card);
264	if (err)
265		return err;
266
267	/* dma onto stack is unsafe/nonportable, but callers to this
268	 * routine normally provide temporary on-stack buffers ...
269	 */
270	data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
271	if (data_buf == NULL)
272		return -ENOMEM;
273
274	mrq.cmd = &cmd;
275	mrq.data = &data;
276
277	cmd.opcode = SD_APP_SEND_SCR;
278	cmd.arg = 0;
279	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
280
281	data.blksz = 8;
282	data.blocks = 1;
283	data.flags = MMC_DATA_READ;
284	data.sg = &sg;
285	data.sg_len = 1;
286
287	sg_init_one(&sg, data_buf, 8);
288
289	mmc_set_data_timeout(&data, card);
290
291	mmc_wait_for_req(card->host, &mrq);
292
293	memcpy(scr, data_buf, sizeof(card->raw_scr));
294	kfree(data_buf);
295
296	if (cmd.error)
297		return cmd.error;
298	if (data.error)
299		return data.error;
300
301	scr[0] = be32_to_cpu(scr[0]);
302	scr[1] = be32_to_cpu(scr[1]);
303
304	return 0;
305}
306
307int mmc_sd_switch(struct mmc_card *card, int mode, int group,
308	u8 value, u8 *resp)
309{
310	struct mmc_request mrq = {NULL};
311	struct mmc_command cmd = {0};
312	struct mmc_data data = {0};
313	struct scatterlist sg;
314
315	BUG_ON(!card);
316	BUG_ON(!card->host);
317
318	/* NOTE: caller guarantees resp is heap-allocated */
319
320	mode = !!mode;
321	value &= 0xF;
322
323	mrq.cmd = &cmd;
324	mrq.data = &data;
325
326	cmd.opcode = SD_SWITCH;
327	cmd.arg = mode << 31 | 0x00FFFFFF;
328	cmd.arg &= ~(0xF << (group * 4));
329	cmd.arg |= value << (group * 4);
330	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
331
332	data.blksz = 64;
333	data.blocks = 1;
334	data.flags = MMC_DATA_READ;
335	data.sg = &sg;
336	data.sg_len = 1;
337
338	sg_init_one(&sg, resp, 64);
339
340	mmc_set_data_timeout(&data, card);
341
342	mmc_wait_for_req(card->host, &mrq);
343
344	if (cmd.error)
345		return cmd.error;
346	if (data.error)
347		return data.error;
348
349	return 0;
350}
351
352int mmc_app_sd_status(struct mmc_card *card, void *ssr)
353{
354	int err;
355	struct mmc_request mrq = {NULL};
356	struct mmc_command cmd = {0};
357	struct mmc_data data = {0};
358	struct scatterlist sg;
359
360	BUG_ON(!card);
361	BUG_ON(!card->host);
362	BUG_ON(!ssr);
363
364	/* NOTE: caller guarantees ssr is heap-allocated */
365
366	err = mmc_app_cmd(card->host, card);
367	if (err)
368		return err;
369
370	mrq.cmd = &cmd;
371	mrq.data = &data;
372
373	cmd.opcode = SD_APP_SD_STATUS;
374	cmd.arg = 0;
375	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;
376
377	data.blksz = 64;
378	data.blocks = 1;
379	data.flags = MMC_DATA_READ;
380	data.sg = &sg;
381	data.sg_len = 1;
382
383	sg_init_one(&sg, ssr, 64);
384
385	mmc_set_data_timeout(&data, card);
386
387	mmc_wait_for_req(card->host, &mrq);
388
389	if (cmd.error)
390		return cmd.error;
391	if (data.error)
392		return data.error;
393
394	return 0;
395}
396