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