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 int _mmc_select_card(struct mmc_host
*host
, struct mmc_card
*card
)
29 struct mmc_command cmd
= {0};
33 cmd
.opcode
= MMC_SELECT_CARD
;
36 cmd
.arg
= card
->rca
<< 16;
37 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
40 cmd
.flags
= MMC_RSP_NONE
| MMC_CMD_AC
;
43 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
50 int mmc_select_card(struct mmc_card
*card
)
54 return _mmc_select_card(card
->host
, card
);
57 int mmc_deselect_cards(struct mmc_host
*host
)
59 return _mmc_select_card(host
, NULL
);
62 int mmc_card_sleepawake(struct mmc_host
*host
, int sleep
)
64 struct mmc_command cmd
= {0};
65 struct mmc_card
*card
= host
->card
;
69 mmc_deselect_cards(host
);
71 cmd
.opcode
= MMC_SLEEP_AWAKE
;
72 cmd
.arg
= card
->rca
<< 16;
76 cmd
.flags
= MMC_RSP_R1B
| MMC_CMD_AC
;
77 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
82 * If the host does not wait while the card signals busy, then we will
83 * will have to wait the sleep/awake timeout. Note, we cannot use the
84 * SEND_STATUS command to poll the status because that command (and most
85 * others) is invalid while the card sleeps.
87 if (!(host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
))
88 mmc_delay(DIV_ROUND_UP(card
->ext_csd
.sa_timeout
, 10000));
91 err
= mmc_select_card(card
);
96 int mmc_go_idle(struct mmc_host
*host
)
99 struct mmc_command cmd
= {0};
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.
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.
110 if (!mmc_host_is_spi(host
)) {
111 mmc_set_chip_select(host
, MMC_CS_HIGH
);
115 cmd
.opcode
= MMC_GO_IDLE_STATE
;
117 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_NONE
| MMC_CMD_BC
;
119 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
123 if (!mmc_host_is_spi(host
)) {
124 mmc_set_chip_select(host
, MMC_CS_DONTCARE
);
128 host
->use_spi_crc
= 0;
133 int mmc_send_op_cond(struct mmc_host
*host
, u32 ocr
, u32
*rocr
)
135 struct mmc_command cmd
= {0};
140 cmd
.opcode
= MMC_SEND_OP_COND
;
141 cmd
.arg
= mmc_host_is_spi(host
) ? 0 : ocr
;
142 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R3
| MMC_CMD_BCR
;
144 for (i
= 100; i
; i
--) {
145 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
149 /* if we're just probing, do a single pass */
153 /* otherwise wait until reset completes */
154 if (mmc_host_is_spi(host
)) {
155 if (!(cmd
.resp
[0] & R1_SPI_IDLE
))
158 if (cmd
.resp
[0] & MMC_CARD_BUSY
)
167 if (rocr
&& !mmc_host_is_spi(host
))
173 int mmc_all_send_cid(struct mmc_host
*host
, u32
*cid
)
176 struct mmc_command cmd
= {0};
181 cmd
.opcode
= MMC_ALL_SEND_CID
;
183 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_BCR
;
185 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
189 memcpy(cid
, cmd
.resp
, sizeof(u32
) * 4);
194 int mmc_set_relative_addr(struct mmc_card
*card
)
197 struct mmc_command cmd
= {0};
202 cmd
.opcode
= MMC_SET_RELATIVE_ADDR
;
203 cmd
.arg
= card
->rca
<< 16;
204 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
206 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
214 mmc_send_cxd_native(struct mmc_host
*host
, u32 arg
, u32
*cxd
, int opcode
)
217 struct mmc_command cmd
= {0};
224 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_AC
;
226 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
230 memcpy(cxd
, cmd
.resp
, sizeof(u32
) * 4);
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).
240 mmc_send_cxd_data(struct mmc_card
*card
, struct mmc_host
*host
,
241 u32 opcode
, void *buf
, unsigned len
)
243 struct mmc_request mrq
= {NULL
};
244 struct mmc_command cmd
= {0};
245 struct mmc_data data
= {0};
246 struct scatterlist sg
;
250 is_on_stack
= object_is_on_stack(buf
);
253 * dma onto stack is unsafe/nonportable, but callers to this
254 * routine normally provide temporary on-stack buffers ...
256 data_buf
= kmalloc(len
, GFP_KERNEL
);
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.
273 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
277 data
.flags
= MMC_DATA_READ
;
281 sg_init_one(&sg
, data_buf
, len
);
283 if (opcode
== MMC_SEND_CSD
|| opcode
== MMC_SEND_CID
) {
285 * The spec states that CSR and CID accesses have a timeout
286 * of 64 clock cycles.
289 data
.timeout_clks
= 64;
291 mmc_set_data_timeout(&data
, card
);
293 mmc_wait_for_req(host
, &mrq
);
296 memcpy(buf
, data_buf
, len
);
308 int mmc_send_csd(struct mmc_card
*card
, u32
*csd
)
313 if (!mmc_host_is_spi(card
->host
))
314 return mmc_send_cxd_native(card
->host
, card
->rca
<< 16,
317 csd_tmp
= kmalloc(16, GFP_KERNEL
);
321 ret
= mmc_send_cxd_data(card
, card
->host
, MMC_SEND_CSD
, csd_tmp
, 16);
325 for (i
= 0;i
< 4;i
++)
326 csd
[i
] = be32_to_cpu(csd_tmp
[i
]);
333 int mmc_send_cid(struct mmc_host
*host
, u32
*cid
)
338 if (!mmc_host_is_spi(host
)) {
341 return mmc_send_cxd_native(host
, host
->card
->rca
<< 16,
345 cid_tmp
= kmalloc(16, GFP_KERNEL
);
349 ret
= mmc_send_cxd_data(NULL
, host
, MMC_SEND_CID
, cid_tmp
, 16);
353 for (i
= 0;i
< 4;i
++)
354 cid
[i
] = be32_to_cpu(cid_tmp
[i
]);
361 int mmc_send_ext_csd(struct mmc_card
*card
, u8
*ext_csd
)
363 return mmc_send_cxd_data(card
, card
->host
, MMC_SEND_EXT_CSD
,
367 int mmc_spi_read_ocr(struct mmc_host
*host
, int highcap
, u32
*ocrp
)
369 struct mmc_command cmd
= {0};
372 cmd
.opcode
= MMC_SPI_READ_OCR
;
373 cmd
.arg
= highcap
? (1 << 30) : 0;
374 cmd
.flags
= MMC_RSP_SPI_R3
;
376 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
382 int mmc_spi_set_crc(struct mmc_host
*host
, int use_crc
)
384 struct mmc_command cmd
= {0};
387 cmd
.opcode
= MMC_SPI_CRC_ON_OFF
;
388 cmd
.flags
= MMC_RSP_SPI_R1
;
391 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
393 host
->use_spi_crc
= use_crc
;
398 * __mmc_switch - modify EXT_CSD register
399 * @card: the MMC card associated with the data transfer
400 * @set: cmd set values
401 * @index: EXT_CSD register index
402 * @value: value to program into EXT_CSD register
403 * @timeout_ms: timeout (ms) for operation performed by register write,
404 * timeout of zero implies maximum possible timeout
405 * @use_busy_signal: use the busy signal as response type
407 * Modifies the EXT_CSD register for selected card.
409 int __mmc_switch(struct mmc_card
*card
, u8 set
, u8 index
, u8 value
,
410 unsigned int timeout_ms
, bool use_busy_signal
)
413 struct mmc_command cmd
= {0};
414 unsigned long timeout
;
420 cmd
.opcode
= MMC_SWITCH
;
421 cmd
.arg
= (MMC_SWITCH_MODE_WRITE_BYTE
<< 24) |
425 cmd
.flags
= MMC_CMD_AC
;
427 cmd
.flags
|= MMC_RSP_SPI_R1B
| MMC_RSP_R1B
;
429 cmd
.flags
|= MMC_RSP_SPI_R1
| MMC_RSP_R1
;
432 cmd
.cmd_timeout_ms
= timeout_ms
;
434 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
438 /* No need to check card status in case of unblocking command */
439 if (!use_busy_signal
)
442 /* Must check status to be sure of no errors */
443 timeout
= jiffies
+ msecs_to_jiffies(MMC_OPS_TIMEOUT_MS
);
445 err
= mmc_send_status(card
, &status
);
448 if (card
->host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
)
450 if (mmc_host_is_spi(card
->host
))
453 /* Timeout if the device never leaves the program state. */
454 if (time_after(jiffies
, timeout
)) {
455 pr_err("%s: Card stuck in programming state! %s\n",
456 mmc_hostname(card
->host
), __func__
);
459 } while (R1_CURRENT_STATE(status
) == R1_STATE_PRG
);
461 if (mmc_host_is_spi(card
->host
)) {
462 if (status
& R1_SPI_ILLEGAL_COMMAND
)
465 if (status
& 0xFDFFA000)
466 pr_warning("%s: unexpected status %#x after "
467 "switch", mmc_hostname(card
->host
), status
);
468 if (status
& R1_SWITCH_ERROR
)
474 EXPORT_SYMBOL_GPL(__mmc_switch
);
476 int mmc_switch(struct mmc_card
*card
, u8 set
, u8 index
, u8 value
,
477 unsigned int timeout_ms
)
479 return __mmc_switch(card
, set
, index
, value
, timeout_ms
, true);
481 EXPORT_SYMBOL_GPL(mmc_switch
);
483 int mmc_send_status(struct mmc_card
*card
, u32
*status
)
486 struct mmc_command cmd
= {0};
491 cmd
.opcode
= MMC_SEND_STATUS
;
492 if (!mmc_host_is_spi(card
->host
))
493 cmd
.arg
= card
->rca
<< 16;
494 cmd
.flags
= MMC_RSP_SPI_R2
| MMC_RSP_R1
| MMC_CMD_AC
;
496 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
500 /* NOTE: callers are required to understand the difference
501 * between "native" and SPI format status words!
504 *status
= cmd
.resp
[0];
510 mmc_send_bus_test(struct mmc_card
*card
, struct mmc_host
*host
, u8 opcode
,
513 struct mmc_request mrq
= {NULL
};
514 struct mmc_command cmd
= {0};
515 struct mmc_data data
= {0};
516 struct scatterlist sg
;
520 static u8 testdata_8bit
[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
521 static u8 testdata_4bit
[4] = { 0x5a, 0, 0, 0 };
523 /* dma onto stack is unsafe/nonportable, but callers to this
524 * routine normally provide temporary on-stack buffers ...
526 data_buf
= kmalloc(len
, GFP_KERNEL
);
531 test_buf
= testdata_8bit
;
533 test_buf
= testdata_4bit
;
535 pr_err("%s: Invalid bus_width %d\n",
536 mmc_hostname(host
), len
);
541 if (opcode
== MMC_BUS_TEST_W
)
542 memcpy(data_buf
, test_buf
, len
);
549 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
550 * rely on callers to never use this with "native" calls for reading
551 * CSD or CID. Native versions of those commands use the R2 type,
552 * not R1 plus a data block.
554 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
558 if (opcode
== MMC_BUS_TEST_R
)
559 data
.flags
= MMC_DATA_READ
;
561 data
.flags
= MMC_DATA_WRITE
;
565 sg_init_one(&sg
, data_buf
, len
);
566 mmc_wait_for_req(host
, &mrq
);
568 if (opcode
== MMC_BUS_TEST_R
) {
569 for (i
= 0; i
< len
/ 4; i
++)
570 if ((test_buf
[i
] ^ data_buf
[i
]) != 0xff) {
585 int mmc_bus_test(struct mmc_card
*card
, u8 bus_width
)
589 if (bus_width
== MMC_BUS_WIDTH_8
)
591 else if (bus_width
== MMC_BUS_WIDTH_4
)
593 else if (bus_width
== MMC_BUS_WIDTH_1
)
594 return 0; /* no need for test */
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.
602 mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_W
, width
);
603 err
= mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_R
, width
);
607 int mmc_send_hpi_cmd(struct mmc_card
*card
, u32
*status
)
609 struct mmc_command cmd
= {0};
613 if (!card
->ext_csd
.hpi
) {
614 pr_warning("%s: Card didn't support HPI command\n",
615 mmc_hostname(card
->host
));
619 opcode
= card
->ext_csd
.hpi_cmd
;
620 if (opcode
== MMC_STOP_TRANSMISSION
)
621 cmd
.flags
= MMC_RSP_R1B
| MMC_CMD_AC
;
622 else if (opcode
== MMC_SEND_STATUS
)
623 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
626 cmd
.arg
= card
->rca
<< 16 | 1;
628 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 0);
630 pr_warn("%s: error %d interrupting operation. "
631 "HPI command response %#x\n", mmc_hostname(card
->host
),
636 *status
= cmd
.resp
[0];