2 * linux/drivers/mmc/core/mmc_ops.h
4 * Copyright 2006-2007 Pierre Ossman
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.
12 #include <linux/slab.h>
13 #include <linux/export.h>
14 #include <linux/types.h>
15 #include <linux/scatterlist.h>
17 #include <linux/mmc/host.h>
18 #include <linux/mmc/card.h>
19 #include <linux/mmc/mmc.h>
24 #define MMC_OPS_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */
26 static inline int __mmc_send_status(struct mmc_card
*card
, u32
*status
,
30 struct mmc_command cmd
= {0};
35 cmd
.opcode
= MMC_SEND_STATUS
;
36 if (!mmc_host_is_spi(card
->host
))
37 cmd
.arg
= card
->rca
<< 16;
38 cmd
.flags
= MMC_RSP_SPI_R2
| MMC_RSP_R1
| MMC_CMD_AC
;
40 cmd
.flags
&= ~MMC_RSP_CRC
;
42 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
46 /* NOTE: callers are required to understand the difference
47 * between "native" and SPI format status words!
50 *status
= cmd
.resp
[0];
55 int mmc_send_status(struct mmc_card
*card
, u32
*status
)
57 return __mmc_send_status(card
, status
, false);
60 static int _mmc_select_card(struct mmc_host
*host
, struct mmc_card
*card
)
63 struct mmc_command cmd
= {0};
67 cmd
.opcode
= MMC_SELECT_CARD
;
70 cmd
.arg
= card
->rca
<< 16;
71 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
74 cmd
.flags
= MMC_RSP_NONE
| MMC_CMD_AC
;
77 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
84 int mmc_select_card(struct mmc_card
*card
)
88 return _mmc_select_card(card
->host
, card
);
91 int mmc_deselect_cards(struct mmc_host
*host
)
93 return _mmc_select_card(host
, NULL
);
97 * Write the value specified in the device tree or board code into the optional
98 * 16 bit Driver Stage Register. This can be used to tune raise/fall times and
99 * drive strength of the DAT and CMD outputs. The actual meaning of a given
100 * value is hardware dependant.
101 * The presence of the DSR register can be determined from the CSD register,
104 int mmc_set_dsr(struct mmc_host
*host
)
106 struct mmc_command cmd
= {0};
108 cmd
.opcode
= MMC_SET_DSR
;
110 cmd
.arg
= (host
->dsr
<< 16) | 0xffff;
111 cmd
.flags
= MMC_RSP_NONE
| MMC_CMD_AC
;
113 return mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
116 int mmc_go_idle(struct mmc_host
*host
)
119 struct mmc_command cmd
= {0};
122 * Non-SPI hosts need to prevent chipselect going active during
123 * GO_IDLE; that would put chips into SPI mode. Remind them of
124 * that in case of hardware that won't pull up DAT3/nCS otherwise.
126 * SPI hosts ignore ios.chip_select; it's managed according to
127 * rules that must accommodate non-MMC slaves which this layer
128 * won't even know about.
130 if (!mmc_host_is_spi(host
)) {
131 mmc_set_chip_select(host
, MMC_CS_HIGH
);
135 cmd
.opcode
= MMC_GO_IDLE_STATE
;
137 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_NONE
| MMC_CMD_BC
;
139 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
143 if (!mmc_host_is_spi(host
)) {
144 mmc_set_chip_select(host
, MMC_CS_DONTCARE
);
148 host
->use_spi_crc
= 0;
153 int mmc_send_op_cond(struct mmc_host
*host
, u32 ocr
, u32
*rocr
)
155 struct mmc_command cmd
= {0};
160 cmd
.opcode
= MMC_SEND_OP_COND
;
161 cmd
.arg
= mmc_host_is_spi(host
) ? 0 : ocr
;
162 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R3
| MMC_CMD_BCR
;
164 for (i
= 100; i
; i
--) {
165 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
169 /* if we're just probing, do a single pass */
173 /* otherwise wait until reset completes */
174 if (mmc_host_is_spi(host
)) {
175 if (!(cmd
.resp
[0] & R1_SPI_IDLE
))
178 if (cmd
.resp
[0] & MMC_CARD_BUSY
)
187 if (rocr
&& !mmc_host_is_spi(host
))
193 int mmc_all_send_cid(struct mmc_host
*host
, u32
*cid
)
196 struct mmc_command cmd
= {0};
201 cmd
.opcode
= MMC_ALL_SEND_CID
;
203 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_BCR
;
205 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
209 memcpy(cid
, cmd
.resp
, sizeof(u32
) * 4);
214 int mmc_set_relative_addr(struct mmc_card
*card
)
217 struct mmc_command cmd
= {0};
222 cmd
.opcode
= MMC_SET_RELATIVE_ADDR
;
223 cmd
.arg
= card
->rca
<< 16;
224 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
226 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
234 mmc_send_cxd_native(struct mmc_host
*host
, u32 arg
, u32
*cxd
, int opcode
)
237 struct mmc_command cmd
= {0};
244 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_AC
;
246 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
250 memcpy(cxd
, cmd
.resp
, sizeof(u32
) * 4);
256 * NOTE: void *buf, caller for the buf is required to use DMA-capable
257 * buffer or on-stack buffer (with some overhead in callee).
260 mmc_send_cxd_data(struct mmc_card
*card
, struct mmc_host
*host
,
261 u32 opcode
, void *buf
, unsigned len
)
263 struct mmc_request mrq
= {NULL
};
264 struct mmc_command cmd
= {0};
265 struct mmc_data data
= {0};
266 struct scatterlist sg
;
270 is_on_stack
= object_is_on_stack(buf
);
273 * dma onto stack is unsafe/nonportable, but callers to this
274 * routine normally provide temporary on-stack buffers ...
276 data_buf
= kmalloc(len
, GFP_KERNEL
);
288 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
289 * rely on callers to never use this with "native" calls for reading
290 * CSD or CID. Native versions of those commands use the R2 type,
291 * not R1 plus a data block.
293 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
297 data
.flags
= MMC_DATA_READ
;
301 sg_init_one(&sg
, data_buf
, len
);
303 if (opcode
== MMC_SEND_CSD
|| opcode
== MMC_SEND_CID
) {
305 * The spec states that CSR and CID accesses have a timeout
306 * of 64 clock cycles.
309 data
.timeout_clks
= 64;
311 mmc_set_data_timeout(&data
, card
);
313 mmc_wait_for_req(host
, &mrq
);
316 memcpy(buf
, data_buf
, len
);
328 int mmc_send_csd(struct mmc_card
*card
, u32
*csd
)
333 if (!mmc_host_is_spi(card
->host
))
334 return mmc_send_cxd_native(card
->host
, card
->rca
<< 16,
337 csd_tmp
= kmalloc(16, GFP_KERNEL
);
341 ret
= mmc_send_cxd_data(card
, card
->host
, MMC_SEND_CSD
, csd_tmp
, 16);
345 for (i
= 0;i
< 4;i
++)
346 csd
[i
] = be32_to_cpu(csd_tmp
[i
]);
353 int mmc_send_cid(struct mmc_host
*host
, u32
*cid
)
358 if (!mmc_host_is_spi(host
)) {
361 return mmc_send_cxd_native(host
, host
->card
->rca
<< 16,
365 cid_tmp
= kmalloc(16, GFP_KERNEL
);
369 ret
= mmc_send_cxd_data(NULL
, host
, MMC_SEND_CID
, cid_tmp
, 16);
373 for (i
= 0;i
< 4;i
++)
374 cid
[i
] = be32_to_cpu(cid_tmp
[i
]);
381 int mmc_send_ext_csd(struct mmc_card
*card
, u8
*ext_csd
)
383 return mmc_send_cxd_data(card
, card
->host
, MMC_SEND_EXT_CSD
,
386 EXPORT_SYMBOL_GPL(mmc_send_ext_csd
);
388 int mmc_spi_read_ocr(struct mmc_host
*host
, int highcap
, u32
*ocrp
)
390 struct mmc_command cmd
= {0};
393 cmd
.opcode
= MMC_SPI_READ_OCR
;
394 cmd
.arg
= highcap
? (1 << 30) : 0;
395 cmd
.flags
= MMC_RSP_SPI_R3
;
397 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
403 int mmc_spi_set_crc(struct mmc_host
*host
, int use_crc
)
405 struct mmc_command cmd
= {0};
408 cmd
.opcode
= MMC_SPI_CRC_ON_OFF
;
409 cmd
.flags
= MMC_RSP_SPI_R1
;
412 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
414 host
->use_spi_crc
= use_crc
;
419 * __mmc_switch - modify EXT_CSD register
420 * @card: the MMC card associated with the data transfer
421 * @set: cmd set values
422 * @index: EXT_CSD register index
423 * @value: value to program into EXT_CSD register
424 * @timeout_ms: timeout (ms) for operation performed by register write,
425 * timeout of zero implies maximum possible timeout
426 * @use_busy_signal: use the busy signal as response type
427 * @send_status: send status cmd to poll for busy
428 * @ignore_crc: ignore CRC errors when sending status cmd to poll for busy
430 * Modifies the EXT_CSD register for selected card.
432 int __mmc_switch(struct mmc_card
*card
, u8 set
, u8 index
, u8 value
,
433 unsigned int timeout_ms
, bool use_busy_signal
, bool send_status
,
436 struct mmc_host
*host
= card
->host
;
438 struct mmc_command cmd
= {0};
439 unsigned long timeout
;
441 bool use_r1b_resp
= use_busy_signal
;
444 * If the cmd timeout and the max_busy_timeout of the host are both
445 * specified, let's validate them. A failure means we need to prevent
446 * the host from doing hw busy detection, which is done by converting
447 * to a R1 response instead of a R1B.
449 if (timeout_ms
&& host
->max_busy_timeout
&&
450 (timeout_ms
> host
->max_busy_timeout
))
451 use_r1b_resp
= false;
453 cmd
.opcode
= MMC_SWITCH
;
454 cmd
.arg
= (MMC_SWITCH_MODE_WRITE_BYTE
<< 24) |
458 cmd
.flags
= MMC_CMD_AC
;
460 cmd
.flags
|= MMC_RSP_SPI_R1B
| MMC_RSP_R1B
;
462 * A busy_timeout of zero means the host can decide to use
463 * whatever value it finds suitable.
465 cmd
.busy_timeout
= timeout_ms
;
467 cmd
.flags
|= MMC_RSP_SPI_R1
| MMC_RSP_R1
;
470 if (index
== EXT_CSD_SANITIZE_START
)
471 cmd
.sanitize_busy
= true;
473 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
477 /* No need to check card status in case of unblocking command */
478 if (!use_busy_signal
)
482 * CRC errors shall only be ignored in cases were CMD13 is used to poll
483 * to detect busy completion.
485 if ((host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
) && use_r1b_resp
)
488 /* We have an unspecified cmd timeout, use the fallback value. */
490 timeout_ms
= MMC_OPS_TIMEOUT_MS
;
492 /* Must check status to be sure of no errors. */
493 timeout
= jiffies
+ msecs_to_jiffies(timeout_ms
);
496 err
= __mmc_send_status(card
, &status
, ignore_crc
);
500 if ((host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
) && use_r1b_resp
)
502 if (mmc_host_is_spi(host
))
506 * We are not allowed to issue a status command and the host
507 * does'nt support MMC_CAP_WAIT_WHILE_BUSY, then we can only
508 * rely on waiting for the stated timeout to be sufficient.
511 mmc_delay(timeout_ms
);
515 /* Timeout if the device never leaves the program state. */
516 if (time_after(jiffies
, timeout
)) {
517 pr_err("%s: Card stuck in programming state! %s\n",
518 mmc_hostname(host
), __func__
);
521 } while (R1_CURRENT_STATE(status
) == R1_STATE_PRG
);
523 if (mmc_host_is_spi(host
)) {
524 if (status
& R1_SPI_ILLEGAL_COMMAND
)
527 if (status
& 0xFDFFA000)
528 pr_warn("%s: unexpected status %#x after switch\n",
529 mmc_hostname(host
), status
);
530 if (status
& R1_SWITCH_ERROR
)
536 EXPORT_SYMBOL_GPL(__mmc_switch
);
538 int mmc_switch(struct mmc_card
*card
, u8 set
, u8 index
, u8 value
,
539 unsigned int timeout_ms
)
541 return __mmc_switch(card
, set
, index
, value
, timeout_ms
, true, true,
544 EXPORT_SYMBOL_GPL(mmc_switch
);
547 mmc_send_bus_test(struct mmc_card
*card
, struct mmc_host
*host
, u8 opcode
,
550 struct mmc_request mrq
= {NULL
};
551 struct mmc_command cmd
= {0};
552 struct mmc_data data
= {0};
553 struct scatterlist sg
;
557 static u8 testdata_8bit
[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
558 static u8 testdata_4bit
[4] = { 0x5a, 0, 0, 0 };
560 /* dma onto stack is unsafe/nonportable, but callers to this
561 * routine normally provide temporary on-stack buffers ...
563 data_buf
= kmalloc(len
, GFP_KERNEL
);
568 test_buf
= testdata_8bit
;
570 test_buf
= testdata_4bit
;
572 pr_err("%s: Invalid bus_width %d\n",
573 mmc_hostname(host
), len
);
578 if (opcode
== MMC_BUS_TEST_W
)
579 memcpy(data_buf
, test_buf
, len
);
586 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
587 * rely on callers to never use this with "native" calls for reading
588 * CSD or CID. Native versions of those commands use the R2 type,
589 * not R1 plus a data block.
591 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
595 if (opcode
== MMC_BUS_TEST_R
)
596 data
.flags
= MMC_DATA_READ
;
598 data
.flags
= MMC_DATA_WRITE
;
602 mmc_set_data_timeout(&data
, card
);
603 sg_init_one(&sg
, data_buf
, len
);
604 mmc_wait_for_req(host
, &mrq
);
606 if (opcode
== MMC_BUS_TEST_R
) {
607 for (i
= 0; i
< len
/ 4; i
++)
608 if ((test_buf
[i
] ^ data_buf
[i
]) != 0xff) {
623 int mmc_bus_test(struct mmc_card
*card
, u8 bus_width
)
627 if (bus_width
== MMC_BUS_WIDTH_8
)
629 else if (bus_width
== MMC_BUS_WIDTH_4
)
631 else if (bus_width
== MMC_BUS_WIDTH_1
)
632 return 0; /* no need for test */
637 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
638 * is a problem. This improves chances that the test will work.
640 mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_W
, width
);
641 err
= mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_R
, width
);
645 int mmc_send_hpi_cmd(struct mmc_card
*card
, u32
*status
)
647 struct mmc_command cmd
= {0};
651 if (!card
->ext_csd
.hpi
) {
652 pr_warn("%s: Card didn't support HPI command\n",
653 mmc_hostname(card
->host
));
657 opcode
= card
->ext_csd
.hpi_cmd
;
658 if (opcode
== MMC_STOP_TRANSMISSION
)
659 cmd
.flags
= MMC_RSP_R1B
| MMC_CMD_AC
;
660 else if (opcode
== MMC_SEND_STATUS
)
661 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
664 cmd
.arg
= card
->rca
<< 16 | 1;
666 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 0);
668 pr_warn("%s: error %d interrupting operation. "
669 "HPI command response %#x\n", mmc_hostname(card
->host
),
674 *status
= cmd
.resp
[0];