Branch data Line data Source code
1 : : /*
2 : : * linux/drivers/mmc/core/mmc_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/export.h>
14 : : #include <linux/types.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 : :
21 : : #include "core.h"
22 : : #include "mmc_ops.h"
23 : :
24 : : #define MMC_OPS_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */
25 : :
26 : : static inline int __mmc_send_status(struct mmc_card *card, u32 *status,
27 : : bool ignore_crc)
28 : : {
29 : : int err;
30 : 0 : struct mmc_command cmd = {0};
31 : :
32 [ # # ][ # # ]: 0 : BUG_ON(!card);
33 [ # # ][ # # ]: 0 : BUG_ON(!card->host);
34 : :
35 : 0 : cmd.opcode = MMC_SEND_STATUS;
36 [ # # ][ # # ]: 0 : if (!mmc_host_is_spi(card->host))
37 : 0 : cmd.arg = card->rca << 16;
38 : 0 : cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
39 [ # # ]: 0 : if (ignore_crc)
40 : 0 : cmd.flags &= ~MMC_RSP_CRC;
41 : :
42 : 0 : err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
43 [ # # # # ]: 0 : if (err)
44 : : return err;
45 : :
46 : : /* NOTE: callers are required to understand the difference
47 : : * between "native" and SPI format status words!
48 : : */
49 [ # # ]: 0 : if (status)
50 : 0 : *status = cmd.resp[0];
51 : :
52 : : return 0;
53 : : }
54 : :
55 : 0 : int mmc_send_status(struct mmc_card *card, u32 *status)
56 : : {
57 : 0 : return __mmc_send_status(card, status, false);
58 : : }
59 : :
60 : 0 : static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
61 : : {
62 : : int err;
63 : 0 : struct mmc_command cmd = {0};
64 : :
65 [ # # ]: 0 : BUG_ON(!host);
66 : :
67 : 0 : cmd.opcode = MMC_SELECT_CARD;
68 : :
69 [ # # ]: 0 : if (card) {
70 : 0 : cmd.arg = card->rca << 16;
71 : 0 : cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
72 : : } else {
73 : : cmd.arg = 0;
74 : : cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
75 : : }
76 : :
77 : 0 : err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
78 [ # # ]: 0 : if (err)
79 : 0 : return err;
80 : :
81 : : return 0;
82 : : }
83 : :
84 : 0 : int mmc_select_card(struct mmc_card *card)
85 : : {
86 [ # # ]: 0 : BUG_ON(!card);
87 : :
88 : 0 : return _mmc_select_card(card->host, card);
89 : : }
90 : :
91 : 0 : int mmc_deselect_cards(struct mmc_host *host)
92 : : {
93 : 0 : return _mmc_select_card(host, NULL);
94 : : }
95 : :
96 : 0 : int mmc_go_idle(struct mmc_host *host)
97 : : {
98 : : int err;
99 : 0 : struct mmc_command cmd = {0};
100 : :
101 : : /*
102 : : * Non-SPI hosts need to prevent chipselect going active during
103 : : * GO_IDLE; that would put chips into SPI mode. Remind them of
104 : : * that in case of hardware that won't pull up DAT3/nCS otherwise.
105 : : *
106 : : * SPI hosts ignore ios.chip_select; it's managed according to
107 : : * rules that must accommodate non-MMC slaves which this layer
108 : : * won't even know about.
109 : : */
110 [ # # ]: 0 : if (!mmc_host_is_spi(host)) {
111 : 0 : mmc_set_chip_select(host, MMC_CS_HIGH);
112 : : mmc_delay(1);
113 : : }
114 : :
115 : 0 : cmd.opcode = MMC_GO_IDLE_STATE;
116 : 0 : cmd.arg = 0;
117 : 0 : cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
118 : :
119 : 0 : err = mmc_wait_for_cmd(host, &cmd, 0);
120 : :
121 : : mmc_delay(1);
122 : :
123 [ # # ]: 0 : if (!mmc_host_is_spi(host)) {
124 : 0 : mmc_set_chip_select(host, MMC_CS_DONTCARE);
125 : : mmc_delay(1);
126 : : }
127 : :
128 : 0 : host->use_spi_crc = 0;
129 : :
130 : 0 : return err;
131 : : }
132 : :
133 : 0 : int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
134 : : {
135 : 0 : struct mmc_command cmd = {0};
136 : : int i, err = 0;
137 : :
138 [ # # ]: 0 : BUG_ON(!host);
139 : :
140 : 0 : cmd.opcode = MMC_SEND_OP_COND;
141 [ # # ]: 0 : cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
142 : 0 : cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
143 : :
144 [ # # ]: 0 : for (i = 100; i; i--) {
145 : 0 : err = mmc_wait_for_cmd(host, &cmd, 0);
146 [ # # ]: 0 : if (err)
147 : : break;
148 : :
149 : : /* if we're just probing, do a single pass */
150 [ # # ]: 0 : if (ocr == 0)
151 : : break;
152 : :
153 : : /* otherwise wait until reset completes */
154 [ # # ]: 0 : if (mmc_host_is_spi(host)) {
155 [ # # ]: 0 : if (!(cmd.resp[0] & R1_SPI_IDLE))
156 : : break;
157 : : } else {
158 [ # # ]: 0 : if (cmd.resp[0] & MMC_CARD_BUSY)
159 : : break;
160 : : }
161 : :
162 : : err = -ETIMEDOUT;
163 : :
164 : : mmc_delay(10);
165 : : }
166 : :
167 [ # # ][ # # ]: 0 : if (rocr && !mmc_host_is_spi(host))
168 : 0 : *rocr = cmd.resp[0];
169 : :
170 : 0 : return err;
171 : : }
172 : :
173 : 0 : int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
174 : : {
175 : : int err;
176 : 0 : struct mmc_command cmd = {0};
177 : :
178 [ # # ]: 0 : BUG_ON(!host);
179 [ # # ]: 0 : BUG_ON(!cid);
180 : :
181 : 0 : cmd.opcode = MMC_ALL_SEND_CID;
182 : : cmd.arg = 0;
183 : 0 : cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
184 : :
185 : 0 : err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
186 [ # # ]: 0 : if (err)
187 : : return err;
188 : :
189 : 0 : memcpy(cid, cmd.resp, sizeof(u32) * 4);
190 : :
191 : 0 : return 0;
192 : : }
193 : :
194 : 0 : int mmc_set_relative_addr(struct mmc_card *card)
195 : : {
196 : : int err;
197 : 0 : struct mmc_command cmd = {0};
198 : :
199 [ # # ]: 0 : BUG_ON(!card);
200 [ # # ]: 0 : BUG_ON(!card->host);
201 : :
202 : 0 : cmd.opcode = MMC_SET_RELATIVE_ADDR;
203 : 0 : cmd.arg = card->rca << 16;
204 : 0 : cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
205 : :
206 : 0 : err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
207 [ # # ]: 0 : if (err)
208 : 0 : return err;
209 : :
210 : : return 0;
211 : : }
212 : :
213 : : static int
214 : 0 : mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
215 : : {
216 : : int err;
217 : 0 : struct mmc_command cmd = {0};
218 : :
219 [ # # ]: 0 : BUG_ON(!host);
220 [ # # ]: 0 : BUG_ON(!cxd);
221 : :
222 : 0 : cmd.opcode = opcode;
223 : 0 : cmd.arg = arg;
224 : 0 : cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
225 : :
226 : 0 : err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
227 [ # # ]: 0 : if (err)
228 : : return err;
229 : :
230 : 0 : memcpy(cxd, cmd.resp, sizeof(u32) * 4);
231 : :
232 : 0 : return 0;
233 : : }
234 : :
235 : : /*
236 : : * NOTE: void *buf, caller for the buf is required to use DMA-capable
237 : : * buffer or on-stack buffer (with some overhead in callee).
238 : : */
239 : : static int
240 : 0 : mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
241 : : u32 opcode, void *buf, unsigned len)
242 : : {
243 : 0 : struct mmc_request mrq = {NULL};
244 : 0 : struct mmc_command cmd = {0};
245 : 0 : struct mmc_data data = {0};
246 : : struct scatterlist sg;
247 : : void *data_buf;
248 : : int is_on_stack;
249 : :
250 : : is_on_stack = object_is_on_stack(buf);
251 [ # # ]: 0 : if (is_on_stack) {
252 : : /*
253 : : * dma onto stack is unsafe/nonportable, but callers to this
254 : : * routine normally provide temporary on-stack buffers ...
255 : : */
256 : : data_buf = kmalloc(len, GFP_KERNEL);
257 [ # # ]: 0 : if (!data_buf)
258 : : return -ENOMEM;
259 : : } else
260 : : data_buf = buf;
261 : :
262 : 0 : mrq.cmd = &cmd;
263 : 0 : mrq.data = &data;
264 : :
265 : 0 : cmd.opcode = opcode;
266 : 0 : cmd.arg = 0;
267 : :
268 : : /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
269 : : * rely on callers to never use this with "native" calls for reading
270 : : * CSD or CID. Native versions of those commands use the R2 type,
271 : : * not R1 plus a data block.
272 : : */
273 : 0 : cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
274 : :
275 : 0 : data.blksz = len;
276 : 0 : data.blocks = 1;
277 : 0 : data.flags = MMC_DATA_READ;
278 : 0 : data.sg = &sg;
279 : 0 : data.sg_len = 1;
280 : :
281 : 0 : sg_init_one(&sg, data_buf, len);
282 : :
283 [ # # ]: 0 : if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
284 : : /*
285 : : * The spec states that CSR and CID accesses have a timeout
286 : : * of 64 clock cycles.
287 : : */
288 : 0 : data.timeout_ns = 0;
289 : 0 : data.timeout_clks = 64;
290 : : } else
291 : 0 : mmc_set_data_timeout(&data, card);
292 : :
293 : 0 : mmc_wait_for_req(host, &mrq);
294 : :
295 [ # # ]: 0 : if (is_on_stack) {
296 : 0 : memcpy(buf, data_buf, len);
297 : 0 : kfree(data_buf);
298 : : }
299 : :
300 [ # # ]: 0 : if (cmd.error)
301 : 0 : return cmd.error;
302 [ # # ]: 0 : if (data.error)
303 : 0 : return data.error;
304 : :
305 : : return 0;
306 : : }
307 : :
308 : 0 : int mmc_send_csd(struct mmc_card *card, u32 *csd)
309 : : {
310 : : int ret, i;
311 : : u32 *csd_tmp;
312 : :
313 [ # # ]: 0 : if (!mmc_host_is_spi(card->host))
314 : 0 : return mmc_send_cxd_native(card->host, card->rca << 16,
315 : : csd, MMC_SEND_CSD);
316 : :
317 : : csd_tmp = kmalloc(16, GFP_KERNEL);
318 [ # # ]: 0 : if (!csd_tmp)
319 : : return -ENOMEM;
320 : :
321 : 0 : ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
322 [ # # ]: 0 : if (ret)
323 : : goto err;
324 : :
325 [ # # ]: 0 : for (i = 0;i < 4;i++)
326 [ # # ]: 0 : csd[i] = be32_to_cpu(csd_tmp[i]);
327 : :
328 : : err:
329 : 0 : kfree(csd_tmp);
330 : 0 : return ret;
331 : : }
332 : :
333 : 0 : int mmc_send_cid(struct mmc_host *host, u32 *cid)
334 : : {
335 : : int ret, i;
336 : : u32 *cid_tmp;
337 : :
338 [ # # ]: 0 : if (!mmc_host_is_spi(host)) {
339 [ # # ]: 0 : if (!host->card)
340 : : return -EINVAL;
341 : 0 : return mmc_send_cxd_native(host, host->card->rca << 16,
342 : : cid, MMC_SEND_CID);
343 : : }
344 : :
345 : : cid_tmp = kmalloc(16, GFP_KERNEL);
346 [ # # ]: 0 : if (!cid_tmp)
347 : : return -ENOMEM;
348 : :
349 : 0 : ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
350 [ # # ]: 0 : if (ret)
351 : : goto err;
352 : :
353 [ # # ]: 0 : for (i = 0;i < 4;i++)
354 [ # # ]: 0 : cid[i] = be32_to_cpu(cid_tmp[i]);
355 : :
356 : : err:
357 : 0 : kfree(cid_tmp);
358 : 0 : return ret;
359 : : }
360 : :
361 : 0 : int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
362 : : {
363 : 0 : return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
364 : : ext_csd, 512);
365 : : }
366 : : EXPORT_SYMBOL_GPL(mmc_send_ext_csd);
367 : :
368 : 0 : int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
369 : : {
370 : 0 : struct mmc_command cmd = {0};
371 : : int err;
372 : :
373 : 0 : cmd.opcode = MMC_SPI_READ_OCR;
374 [ # # ]: 0 : cmd.arg = highcap ? (1 << 30) : 0;
375 : 0 : cmd.flags = MMC_RSP_SPI_R3;
376 : :
377 : 0 : err = mmc_wait_for_cmd(host, &cmd, 0);
378 : :
379 : 0 : *ocrp = cmd.resp[1];
380 : 0 : return err;
381 : : }
382 : :
383 : 0 : int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
384 : : {
385 : 0 : struct mmc_command cmd = {0};
386 : : int err;
387 : :
388 : 0 : cmd.opcode = MMC_SPI_CRC_ON_OFF;
389 : 0 : cmd.flags = MMC_RSP_SPI_R1;
390 : 0 : cmd.arg = use_crc;
391 : :
392 : 0 : err = mmc_wait_for_cmd(host, &cmd, 0);
393 [ # # ]: 0 : if (!err)
394 : 0 : host->use_spi_crc = use_crc;
395 : 0 : return err;
396 : : }
397 : :
398 : : /**
399 : : * __mmc_switch - modify EXT_CSD register
400 : : * @card: the MMC card associated with the data transfer
401 : : * @set: cmd set values
402 : : * @index: EXT_CSD register index
403 : : * @value: value to program into EXT_CSD register
404 : : * @timeout_ms: timeout (ms) for operation performed by register write,
405 : : * timeout of zero implies maximum possible timeout
406 : : * @use_busy_signal: use the busy signal as response type
407 : : * @send_status: send status cmd to poll for busy
408 : : *
409 : : * Modifies the EXT_CSD register for selected card.
410 : : */
411 : 0 : int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
412 : : unsigned int timeout_ms, bool use_busy_signal, bool send_status)
413 : : {
414 : : int err;
415 : 0 : struct mmc_command cmd = {0};
416 : : unsigned long timeout;
417 : : u32 status = 0;
418 : : bool ignore_crc = false;
419 : :
420 [ # # ]: 0 : BUG_ON(!card);
421 [ # # ]: 0 : BUG_ON(!card->host);
422 : :
423 : 0 : cmd.opcode = MMC_SWITCH;
424 : 0 : cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
425 : 0 : (index << 16) |
426 : 0 : (value << 8) |
427 : : set;
428 : : cmd.flags = MMC_CMD_AC;
429 [ # # ]: 0 : if (use_busy_signal)
430 : 0 : cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
431 : : else
432 : 0 : cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
433 : :
434 : :
435 : 0 : cmd.cmd_timeout_ms = timeout_ms;
436 [ # # ]: 0 : if (index == EXT_CSD_SANITIZE_START)
437 : 0 : cmd.sanitize_busy = true;
438 : :
439 : 0 : err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
440 [ # # ]: 0 : if (err)
441 : : return err;
442 : :
443 : : /* No need to check card status in case of unblocking command */
444 [ # # ]: 0 : if (!use_busy_signal)
445 : : return 0;
446 : :
447 : : /*
448 : : * Must check status to be sure of no errors
449 : : * If CMD13 is to check the busy completion of the timing change,
450 : : * disable the check of CRC error.
451 : : */
452 [ # # ][ # # ]: 0 : if (index == EXT_CSD_HS_TIMING &&
453 : 0 : !(card->host->caps & MMC_CAP_WAIT_WHILE_BUSY))
454 : : ignore_crc = true;
455 : :
456 : 0 : timeout = jiffies + msecs_to_jiffies(MMC_OPS_TIMEOUT_MS);
457 : : do {
458 [ # # ]: 0 : if (send_status) {
459 : : err = __mmc_send_status(card, &status, ignore_crc);
460 [ # # ]: 0 : if (err)
461 : : return err;
462 : : }
463 [ # # ]: 0 : if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
464 : : break;
465 [ # # ]: 0 : if (mmc_host_is_spi(card->host))
466 : : break;
467 : :
468 : : /*
469 : : * We are not allowed to issue a status command and the host
470 : : * does'nt support MMC_CAP_WAIT_WHILE_BUSY, then we can only
471 : : * rely on waiting for the stated timeout to be sufficient.
472 : : */
473 [ # # ]: 0 : if (!send_status) {
474 : : mmc_delay(timeout_ms);
475 : : return 0;
476 : : }
477 : :
478 : : /* Timeout if the device never leaves the program state. */
479 [ # # ]: 0 : if (time_after(jiffies, timeout)) {
480 : 0 : pr_err("%s: Card stuck in programming state! %s\n",
481 : : mmc_hostname(card->host), __func__);
482 : 0 : return -ETIMEDOUT;
483 : : }
484 [ # # ]: 0 : } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
485 : :
486 [ # # ]: 0 : if (mmc_host_is_spi(card->host)) {
487 [ # # ]: 0 : if (status & R1_SPI_ILLEGAL_COMMAND)
488 : : return -EBADMSG;
489 : : } else {
490 [ # # ]: 0 : if (status & 0xFDFFA000)
491 : 0 : pr_warning("%s: unexpected status %#x after "
492 : : "switch", mmc_hostname(card->host), status);
493 [ # # ]: 0 : if (status & R1_SWITCH_ERROR)
494 : : return -EBADMSG;
495 : : }
496 : :
497 : : return 0;
498 : : }
499 : : EXPORT_SYMBOL_GPL(__mmc_switch);
500 : :
501 : 0 : int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
502 : : unsigned int timeout_ms)
503 : : {
504 : 0 : return __mmc_switch(card, set, index, value, timeout_ms, true, true);
505 : : }
506 : : EXPORT_SYMBOL_GPL(mmc_switch);
507 : :
508 : : static int
509 : 0 : mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
510 : : u8 len)
511 : : {
512 : 0 : struct mmc_request mrq = {NULL};
513 : 0 : struct mmc_command cmd = {0};
514 : 0 : struct mmc_data data = {0};
515 : : struct scatterlist sg;
516 : : u8 *data_buf;
517 : : u8 *test_buf;
518 : : int i, err;
519 : : static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
520 : : static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
521 : :
522 : : /* dma onto stack is unsafe/nonportable, but callers to this
523 : : * routine normally provide temporary on-stack buffers ...
524 : : */
525 : 0 : data_buf = kmalloc(len, GFP_KERNEL);
526 [ # # ]: 0 : if (!data_buf)
527 : : return -ENOMEM;
528 : :
529 [ # # ]: 0 : if (len == 8)
530 : : test_buf = testdata_8bit;
531 [ # # ]: 0 : else if (len == 4)
532 : : test_buf = testdata_4bit;
533 : : else {
534 : 0 : pr_err("%s: Invalid bus_width %d\n",
535 : : mmc_hostname(host), len);
536 : 0 : kfree(data_buf);
537 : 0 : return -EINVAL;
538 : : }
539 : :
540 [ # # ]: 0 : if (opcode == MMC_BUS_TEST_W)
541 : 0 : memcpy(data_buf, test_buf, len);
542 : :
543 : 0 : mrq.cmd = &cmd;
544 : 0 : mrq.data = &data;
545 : 0 : cmd.opcode = opcode;
546 : 0 : cmd.arg = 0;
547 : :
548 : : /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
549 : : * rely on callers to never use this with "native" calls for reading
550 : : * CSD or CID. Native versions of those commands use the R2 type,
551 : : * not R1 plus a data block.
552 : : */
553 : 0 : cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
554 : :
555 : 0 : data.blksz = len;
556 : 0 : data.blocks = 1;
557 [ # # ]: 0 : if (opcode == MMC_BUS_TEST_R)
558 : 0 : data.flags = MMC_DATA_READ;
559 : : else
560 : 0 : data.flags = MMC_DATA_WRITE;
561 : :
562 : 0 : data.sg = &sg;
563 : 0 : data.sg_len = 1;
564 : 0 : mmc_set_data_timeout(&data, card);
565 : 0 : sg_init_one(&sg, data_buf, len);
566 : 0 : mmc_wait_for_req(host, &mrq);
567 : : err = 0;
568 [ # # ]: 0 : if (opcode == MMC_BUS_TEST_R) {
569 [ # # ]: 0 : for (i = 0; i < len / 4; i++)
570 [ # # ]: 0 : if ((test_buf[i] ^ data_buf[i]) != 0xff) {
571 : : err = -EIO;
572 : : break;
573 : : }
574 : : }
575 : 0 : kfree(data_buf);
576 : :
577 [ # # ]: 0 : if (cmd.error)
578 : 0 : return cmd.error;
579 [ # # ]: 0 : if (data.error)
580 : 0 : return data.error;
581 : :
582 : : return err;
583 : : }
584 : :
585 : 0 : int mmc_bus_test(struct mmc_card *card, u8 bus_width)
586 : : {
587 : : int err, width;
588 : :
589 [ # # ]: 0 : if (bus_width == MMC_BUS_WIDTH_8)
590 : : width = 8;
591 [ # # ]: 0 : else if (bus_width == MMC_BUS_WIDTH_4)
592 : : width = 4;
593 [ # # ]: 0 : else if (bus_width == MMC_BUS_WIDTH_1)
594 : : return 0; /* no need for test */
595 : : else
596 : 0 : return -EINVAL;
597 : :
598 : : /*
599 : : * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
600 : : * is a problem. This improves chances that the test will work.
601 : : */
602 : 0 : mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
603 : 0 : err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
604 : 0 : return err;
605 : : }
606 : :
607 : 0 : int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
608 : : {
609 : 0 : struct mmc_command cmd = {0};
610 : : unsigned int opcode;
611 : : int err;
612 : :
613 [ # # ]: 0 : if (!card->ext_csd.hpi) {
614 : 0 : pr_warning("%s: Card didn't support HPI command\n",
615 : : mmc_hostname(card->host));
616 : 0 : return -EINVAL;
617 : : }
618 : :
619 : 0 : opcode = card->ext_csd.hpi_cmd;
620 [ # # ]: 0 : if (opcode == MMC_STOP_TRANSMISSION)
621 : 0 : cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
622 [ # # ]: 0 : else if (opcode == MMC_SEND_STATUS)
623 : 0 : cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
624 : :
625 : 0 : cmd.opcode = opcode;
626 : 0 : cmd.arg = card->rca << 16 | 1;
627 : :
628 : 0 : err = mmc_wait_for_cmd(card->host, &cmd, 0);
629 [ # # ]: 0 : if (err) {
630 : 0 : pr_warn("%s: error %d interrupting operation. "
631 : : "HPI command response %#x\n", mmc_hostname(card->host),
632 : : err, cmd.resp[0]);
633 : 0 : return err;
634 : : }
635 [ # # ]: 0 : if (status)
636 : 0 : *status = cmd.resp[0];
637 : :
638 : : return 0;
639 : : }
|
