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