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