sd_ops.c revision 87f6119e25bbe0fd60e76f599d5fa10cf489519c 
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/scatterlist.h>
15
16#include <linux/mmc/host.h>
17#include <linux/mmc/card.h>
18#include <linux/mmc/mmc.h>
19#include <linux/mmc/sd.h>
20
21#include "core.h"
22#include "sd_ops.h"
23
24static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
25{
26	int err;
27	struct mmc_command cmd;
28
29	BUG_ON(!host);
30	BUG_ON(card && (card->host != host));
31
32	memset(&cmd, 0, sizeof(struct mmc_command));
33
34	cmd.opcode = MMC_APP_CMD;
35
36	if (card) {
37		cmd.arg = card->rca << 16;
38		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
39	} else {
40		cmd.arg = 0;
41		cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
42	}
43
44	err = mmc_wait_for_cmd(host, &cmd, 0);
45	if (err)
46		return err;
47
48	/* Check that card supported application commands */
49	if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
50		return -EOPNOTSUPP;
51
52	return 0;
53}
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;
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;
125
126	BUG_ON(!card);
127	BUG_ON(!card->host);
128
129	memset(&cmd, 0, sizeof(struct mmc_command));
130
131	cmd.opcode = SD_APP_SET_BUS_WIDTH;
132	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
133
134	switch (width) {
135	case MMC_BUS_WIDTH_1:
136		cmd.arg = SD_BUS_WIDTH_1;
137		break;
138	case MMC_BUS_WIDTH_4:
139		cmd.arg = SD_BUS_WIDTH_4;
140		break;
141	default:
142		return -EINVAL;
143	}
144
145	err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
146	if (err)
147		return err;
148
149	return 0;
150}
151
152int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
153{
154	struct mmc_command cmd;
155	int i, err = 0;
156
157	BUG_ON(!host);
158
159	memset(&cmd, 0, sizeof(struct mmc_command));
160
161	cmd.opcode = SD_APP_OP_COND;
162	if (mmc_host_is_spi(host))
163		cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
164	else
165		cmd.arg = ocr;
166	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
167
168	for (i = 100; i; i--) {
169		err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
170		if (err)
171			break;
172
173		/* if we're just probing, do a single pass */
174		if (ocr == 0)
175			break;
176
177		/* otherwise wait until reset completes */
178		if (mmc_host_is_spi(host)) {
179			if (!(cmd.resp[0] & R1_SPI_IDLE))
180				break;
181		} else {
182			if (cmd.resp[0] & MMC_CARD_BUSY)
183				break;
184		}
185
186		err = -ETIMEDOUT;
187
188		mmc_delay(10);
189	}
190
191	if (rocr && !mmc_host_is_spi(host))
192		*rocr = cmd.resp[0];
193
194	return err;
195}
196
197int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
198{
199	struct mmc_command cmd;
200	int err;
201	static const u8 test_pattern = 0xAA;
202	u8 result_pattern;
203
204	/*
205	 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
206	 * before SD_APP_OP_COND. This command will harmlessly fail for
207	 * SD 1.0 cards.
208	 */
209	cmd.opcode = SD_SEND_IF_COND;
210	cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
211	cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
212
213	err = mmc_wait_for_cmd(host, &cmd, 0);
214	if (err)
215		return err;
216
217	if (mmc_host_is_spi(host))
218		result_pattern = cmd.resp[1] & 0xFF;
219	else
220		result_pattern = cmd.resp[0] & 0xFF;
221
222	if (result_pattern != test_pattern)
223		return -EIO;
224
225	return 0;
226}
227
228int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
229{
230	int err;
231	struct mmc_command cmd;
232
233	BUG_ON(!host);
234	BUG_ON(!rca);
235
236	memset(&cmd, 0, sizeof(struct mmc_command));
237
238	cmd.opcode = SD_SEND_RELATIVE_ADDR;
239	cmd.arg = 0;
240	cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
241
242	err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
243	if (err)
244		return err;
245
246	*rca = cmd.resp[0] >> 16;
247
248	return 0;
249}
250
251int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
252{
253	int err;
254	struct mmc_request mrq;
255	struct mmc_command cmd;
256	struct mmc_data data;
257	struct scatterlist sg;
258	void *data_buf;
259
260	BUG_ON(!card);
261	BUG_ON(!card->host);
262	BUG_ON(!scr);
263
264	/* NOTE: caller guarantees scr is heap-allocated */
265
266	err = mmc_app_cmd(card->host, card);
267	if (err)
268		return err;
269
270	/* dma onto stack is unsafe/nonportable, but callers to this
271	 * routine normally provide temporary on-stack buffers ...
272	 */
273	data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
274	if (data_buf == NULL)
275		return -ENOMEM;
276
277	memset(&mrq, 0, sizeof(struct mmc_request));
278	memset(&cmd, 0, sizeof(struct mmc_command));
279	memset(&data, 0, sizeof(struct mmc_data));
280
281	mrq.cmd = &cmd;
282	mrq.data = &data;
283
284	cmd.opcode = SD_APP_SEND_SCR;
285	cmd.arg = 0;
286	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
287
288	data.blksz = 8;
289	data.blocks = 1;
290	data.flags = MMC_DATA_READ;
291	data.sg = &sg;
292	data.sg_len = 1;
293
294	sg_init_one(&sg, data_buf, 8);
295
296	mmc_set_data_timeout(&data, card);
297
298	mmc_wait_for_req(card->host, &mrq);
299
300	memcpy(scr, data_buf, sizeof(card->raw_scr));
301	kfree(data_buf);
302
303	if (cmd.error)
304		return cmd.error;
305	if (data.error)
306		return data.error;
307
308	scr[0] = be32_to_cpu(scr[0]);
309	scr[1] = be32_to_cpu(scr[1]);
310
311	return 0;
312}
313
314int mmc_sd_switch(struct mmc_card *card, int mode, int group,
315	u8 value, u8 *resp)
316{
317	struct mmc_request mrq;
318	struct mmc_command cmd;
319	struct mmc_data data;
320	struct scatterlist sg;
321
322	BUG_ON(!card);
323	BUG_ON(!card->host);
324
325	/* NOTE: caller guarantees resp is heap-allocated */
326
327	mode = !!mode;
328	value &= 0xF;
329
330	memset(&mrq, 0, sizeof(struct mmc_request));
331	memset(&cmd, 0, sizeof(struct mmc_command));
332	memset(&data, 0, sizeof(struct mmc_data));
333
334	mrq.cmd = &cmd;
335	mrq.data = &data;
336
337	cmd.opcode = SD_SWITCH;
338	cmd.arg = mode << 31 | 0x00FFFFFF;
339	cmd.arg &= ~(0xF << (group * 4));
340	cmd.arg |= value << (group * 4);
341	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
342
343	data.blksz = 64;
344	data.blocks = 1;
345	data.flags = MMC_DATA_READ;
346	data.sg = &sg;
347	data.sg_len = 1;
348
349	sg_init_one(&sg, resp, 64);
350
351	mmc_set_data_timeout(&data, card);
352
353	mmc_wait_for_req(card->host, &mrq);
354
355	if (cmd.error)
356		return cmd.error;
357	if (data.error)
358		return data.error;
359
360	return 0;
361}
362
363int mmc_app_sd_status(struct mmc_card *card, void *ssr)
364{
365	int err;
366	struct mmc_request mrq;
367	struct mmc_command cmd;
368	struct mmc_data data;
369	struct scatterlist sg;
370
371	BUG_ON(!card);
372	BUG_ON(!card->host);
373	BUG_ON(!ssr);
374
375	/* NOTE: caller guarantees ssr is heap-allocated */
376
377	err = mmc_app_cmd(card->host, card);
378	if (err)
379		return err;
380
381	memset(&mrq, 0, sizeof(struct mmc_request));
382	memset(&cmd, 0, sizeof(struct mmc_command));
383	memset(&data, 0, sizeof(struct mmc_data));
384
385	mrq.cmd = &cmd;
386	mrq.data = &data;
387
388	cmd.opcode = SD_APP_SD_STATUS;
389	cmd.arg = 0;
390	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;
391
392	data.blksz = 64;
393	data.blocks = 1;
394	data.flags = MMC_DATA_READ;
395	data.sg = &sg;
396	data.sg_len = 1;
397
398	sg_init_one(&sg, ssr, 64);
399
400	mmc_set_data_timeout(&data, card);
401
402	mmc_wait_for_req(card->host, &mrq);
403
404	if (cmd.error)
405		return cmd.error;
406	if (data.error)
407		return data.error;
408
409	return 0;
410}
411