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/types.h>
13 #include <linux/scatterlist.h>
14
15 #include <linux/mmc/host.h>
16 #include <linux/mmc/card.h>
17 #include <linux/mmc/mmc.h>
18 #include <linux/mmc/sd.h>
19
20 #include "core.h"
21 #include "sd_ops.h"
22
mmc_app_cmd(struct mmc_host * host,struct mmc_card * card)23 static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
24 {
25 int err;
26 struct mmc_command cmd;
27
28 BUG_ON(!host);
29 BUG_ON(card && (card->host != host));
30
31 cmd.opcode = MMC_APP_CMD;
32
33 if (card) {
34 cmd.arg = card->rca << 16;
35 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
36 } else {
37 cmd.arg = 0;
38 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
39 }
40
41 err = mmc_wait_for_cmd(host, &cmd, 0);
42 if (err)
43 return err;
44
45 /* Check that card supported application commands */
46 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
47 return -EOPNOTSUPP;
48
49 return 0;
50 }
51
52 /**
53 * mmc_wait_for_app_cmd - start an application command and wait for
54 completion
55 * @host: MMC host to start command
56 * @card: Card to send MMC_APP_CMD to
57 * @cmd: MMC command to start
58 * @retries: maximum number of retries
59 *
60 * Sends a MMC_APP_CMD, checks the card response, sends the command
61 * in the parameter and waits for it to complete. Return any error
62 * that occurred while the command was executing. Do not attempt to
63 * parse the response.
64 */
mmc_wait_for_app_cmd(struct mmc_host * host,struct mmc_card * card,struct mmc_command * cmd,int retries)65 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
66 struct mmc_command *cmd, int retries)
67 {
68 struct mmc_request mrq;
69
70 int i, err;
71
72 BUG_ON(!cmd);
73 BUG_ON(retries < 0);
74
75 err = -EIO;
76
77 /*
78 * We have to resend MMC_APP_CMD for each attempt so
79 * we cannot use the retries field in mmc_command.
80 */
81 for (i = 0;i <= retries;i++) {
82 memset(&mrq, 0, sizeof(struct mmc_request));
83
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
mmc_app_set_bus_width(struct mmc_card * card,int width)120 int mmc_app_set_bus_width(struct mmc_card *card, int width)
121 {
122 int err;
123 struct mmc_command cmd;
124
125 BUG_ON(!card);
126 BUG_ON(!card->host);
127
128 memset(&cmd, 0, sizeof(struct mmc_command));
129
130 cmd.opcode = SD_APP_SET_BUS_WIDTH;
131 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
132
133 switch (width) {
134 case MMC_BUS_WIDTH_1:
135 cmd.arg = SD_BUS_WIDTH_1;
136 break;
137 case MMC_BUS_WIDTH_4:
138 cmd.arg = SD_BUS_WIDTH_4;
139 break;
140 default:
141 return -EINVAL;
142 }
143
144 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
145 if (err)
146 return err;
147
148 return 0;
149 }
150
mmc_send_app_op_cond(struct mmc_host * host,u32 ocr,u32 * rocr)151 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
152 {
153 struct mmc_command cmd;
154 int i, err = 0;
155
156 BUG_ON(!host);
157
158 memset(&cmd, 0, sizeof(struct mmc_command));
159
160 cmd.opcode = SD_APP_OP_COND;
161 if (mmc_host_is_spi(host))
162 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
163 else
164 cmd.arg = ocr;
165 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
166
167 for (i = 100; i; i--) {
168 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
169 if (err)
170 break;
171
172 /* if we're just probing, do a single pass */
173 if (ocr == 0)
174 break;
175
176 /* otherwise wait until reset completes */
177 if (mmc_host_is_spi(host)) {
178 if (!(cmd.resp[0] & R1_SPI_IDLE))
179 break;
180 } else {
181 if (cmd.resp[0] & MMC_CARD_BUSY)
182 break;
183 }
184
185 err = -ETIMEDOUT;
186
187 mmc_delay(10);
188 }
189
190 if (rocr && !mmc_host_is_spi(host))
191 *rocr = cmd.resp[0];
192
193 return err;
194 }
195
mmc_send_if_cond(struct mmc_host * host,u32 ocr)196 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
197 {
198 struct mmc_command cmd;
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
mmc_send_relative_addr(struct mmc_host * host,unsigned int * rca)227 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
228 {
229 int err;
230 struct mmc_command cmd;
231
232 BUG_ON(!host);
233 BUG_ON(!rca);
234
235 memset(&cmd, 0, sizeof(struct mmc_command));
236
237 cmd.opcode = SD_SEND_RELATIVE_ADDR;
238 cmd.arg = 0;
239 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
240
241 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
242 if (err)
243 return err;
244
245 *rca = cmd.resp[0] >> 16;
246
247 return 0;
248 }
249
mmc_app_send_scr(struct mmc_card * card,u32 * scr)250 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
251 {
252 int err;
253 struct mmc_request mrq;
254 struct mmc_command cmd;
255 struct mmc_data data;
256 struct scatterlist sg;
257
258 BUG_ON(!card);
259 BUG_ON(!card->host);
260 BUG_ON(!scr);
261
262 /* NOTE: caller guarantees scr is heap-allocated */
263
264 err = mmc_app_cmd(card->host, card);
265 if (err)
266 return err;
267
268 memset(&mrq, 0, sizeof(struct mmc_request));
269 memset(&cmd, 0, sizeof(struct mmc_command));
270 memset(&data, 0, sizeof(struct mmc_data));
271
272 mrq.cmd = &cmd;
273 mrq.data = &data;
274
275 cmd.opcode = SD_APP_SEND_SCR;
276 cmd.arg = 0;
277 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
278
279 data.blksz = 8;
280 data.blocks = 1;
281 data.flags = MMC_DATA_READ;
282 data.sg = &sg;
283 data.sg_len = 1;
284
285 sg_init_one(&sg, scr, 8);
286
287 mmc_set_data_timeout(&data, card);
288
289 mmc_wait_for_req(card->host, &mrq);
290
291 if (cmd.error)
292 return cmd.error;
293 if (data.error)
294 return data.error;
295
296 scr[0] = be32_to_cpu(scr[0]);
297 scr[1] = be32_to_cpu(scr[1]);
298
299 return 0;
300 }
301
mmc_sd_switch(struct mmc_card * card,int mode,int group,u8 value,u8 * resp)302 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
303 u8 value, u8 *resp)
304 {
305 struct mmc_request mrq;
306 struct mmc_command cmd;
307 struct mmc_data data;
308 struct scatterlist sg;
309
310 BUG_ON(!card);
311 BUG_ON(!card->host);
312
313 /* NOTE: caller guarantees resp is heap-allocated */
314
315 mode = !!mode;
316 value &= 0xF;
317
318 memset(&mrq, 0, sizeof(struct mmc_request));
319 memset(&cmd, 0, sizeof(struct mmc_command));
320 memset(&data, 0, sizeof(struct mmc_data));
321
322 mrq.cmd = &cmd;
323 mrq.data = &data;
324
325 cmd.opcode = SD_SWITCH;
326 cmd.arg = mode << 31 | 0x00FFFFFF;
327 cmd.arg &= ~(0xF << (group * 4));
328 cmd.arg |= value << (group * 4);
329 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
330
331 data.blksz = 64;
332 data.blocks = 1;
333 data.flags = MMC_DATA_READ;
334 data.sg = &sg;
335 data.sg_len = 1;
336
337 sg_init_one(&sg, resp, 64);
338
339 mmc_set_data_timeout(&data, card);
340
341 mmc_wait_for_req(card->host, &mrq);
342
343 if (cmd.error)
344 return cmd.error;
345 if (data.error)
346 return data.error;
347
348 return 0;
349 }
350
351