1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * linux/drivers/mmc/core/mmc_ops.h
5 * Copyright 2006-2007 Pierre Ossman
8 #include <linux/slab.h>
9 #include <linux/export.h>
10 #include <linux/types.h>
11 #include <linux/scatterlist.h>
13 #include <linux/mmc/host.h>
14 #include <linux/mmc/card.h>
15 #include <linux/mmc/mmc.h>
22 #define MMC_BKOPS_TIMEOUT_MS (120 * 1000) /* 120s */
23 #define MMC_CACHE_FLUSH_TIMEOUT_MS (30 * 1000) /* 30s */
25 static const u8 tuning_blk_pattern_4bit[] = {
26 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
27 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
28 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
29 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
30 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
31 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
32 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
33 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
36 static const u8 tuning_blk_pattern_8bit[] = {
37 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
38 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
39 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
40 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
41 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
42 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
43 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
44 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
45 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
46 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
47 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
48 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
49 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
50 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
51 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
52 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
55 int __mmc_send_status(struct mmc_card *card, u32 *status, unsigned int retries)
58 struct mmc_command cmd = {};
60 cmd.opcode = MMC_SEND_STATUS;
61 if (!mmc_host_is_spi(card->host))
62 cmd.arg = card->rca << 16;
63 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
65 err = mmc_wait_for_cmd(card->host, &cmd, retries);
69 /* NOTE: callers are required to understand the difference
70 * between "native" and SPI format status words!
73 *status = cmd.resp[0];
77 EXPORT_SYMBOL_GPL(__mmc_send_status);
79 int mmc_send_status(struct mmc_card *card, u32 *status)
81 return __mmc_send_status(card, status, MMC_CMD_RETRIES);
83 EXPORT_SYMBOL_GPL(mmc_send_status);
85 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
87 struct mmc_command cmd = {};
89 cmd.opcode = MMC_SELECT_CARD;
92 cmd.arg = card->rca << 16;
93 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
96 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
99 return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
102 int mmc_select_card(struct mmc_card *card)
105 return _mmc_select_card(card->host, card);
108 int mmc_deselect_cards(struct mmc_host *host)
110 return _mmc_select_card(host, NULL);
114 * Write the value specified in the device tree or board code into the optional
115 * 16 bit Driver Stage Register. This can be used to tune raise/fall times and
116 * drive strength of the DAT and CMD outputs. The actual meaning of a given
117 * value is hardware dependant.
118 * The presence of the DSR register can be determined from the CSD register,
121 int mmc_set_dsr(struct mmc_host *host)
123 struct mmc_command cmd = {};
125 cmd.opcode = MMC_SET_DSR;
127 cmd.arg = (host->dsr << 16) | 0xffff;
128 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
130 return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
133 int mmc_go_idle(struct mmc_host *host)
136 struct mmc_command cmd = {};
139 * Non-SPI hosts need to prevent chipselect going active during
140 * GO_IDLE; that would put chips into SPI mode. Remind them of
141 * that in case of hardware that won't pull up DAT3/nCS otherwise.
143 * SPI hosts ignore ios.chip_select; it's managed according to
144 * rules that must accommodate non-MMC slaves which this layer
145 * won't even know about.
147 if (!mmc_host_is_spi(host)) {
148 mmc_set_chip_select(host, MMC_CS_HIGH);
152 cmd.opcode = MMC_GO_IDLE_STATE;
154 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
156 err = mmc_wait_for_cmd(host, &cmd, 0);
160 if (!mmc_host_is_spi(host)) {
161 mmc_set_chip_select(host, MMC_CS_DONTCARE);
165 host->use_spi_crc = 0;
170 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
172 struct mmc_command cmd = {};
175 cmd.opcode = MMC_SEND_OP_COND;
176 cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
177 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
179 for (i = 100; i; i--) {
180 err = mmc_wait_for_cmd(host, &cmd, 0);
184 /* wait until reset completes */
185 if (mmc_host_is_spi(host)) {
186 if (!(cmd.resp[0] & R1_SPI_IDLE))
189 if (cmd.resp[0] & MMC_CARD_BUSY)
198 * According to eMMC specification v5.1 section 6.4.3, we
199 * should issue CMD1 repeatedly in the idle state until
200 * the eMMC is ready. Otherwise some eMMC devices seem to enter
201 * the inactive mode after mmc_init_card() issued CMD0 when
202 * the eMMC device is busy.
204 if (!ocr && !mmc_host_is_spi(host))
205 cmd.arg = cmd.resp[0] | BIT(30);
208 if (rocr && !mmc_host_is_spi(host))
214 int mmc_set_relative_addr(struct mmc_card *card)
216 struct mmc_command cmd = {};
218 cmd.opcode = MMC_SET_RELATIVE_ADDR;
219 cmd.arg = card->rca << 16;
220 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
222 return mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
226 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
229 struct mmc_command cmd = {};
233 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
235 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
239 memcpy(cxd, cmd.resp, sizeof(u32) * 4);
245 * NOTE: void *buf, caller for the buf is required to use DMA-capable
246 * buffer or on-stack buffer (with some overhead in callee).
249 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
250 u32 opcode, void *buf, unsigned len)
252 struct mmc_request mrq = {};
253 struct mmc_command cmd = {};
254 struct mmc_data data = {};
255 struct scatterlist sg;
263 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
264 * rely on callers to never use this with "native" calls for reading
265 * CSD or CID. Native versions of those commands use the R2 type,
266 * not R1 plus a data block.
268 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
272 data.flags = MMC_DATA_READ;
276 sg_init_one(&sg, buf, len);
278 if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
280 * The spec states that CSR and CID accesses have a timeout
281 * of 64 clock cycles.
284 data.timeout_clks = 64;
286 mmc_set_data_timeout(&data, card);
288 mmc_wait_for_req(host, &mrq);
298 static int mmc_spi_send_csd(struct mmc_card *card, u32 *csd)
303 csd_tmp = kzalloc(16, GFP_KERNEL);
307 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
311 for (i = 0; i < 4; i++)
312 csd[i] = be32_to_cpu(csd_tmp[i]);
319 int mmc_send_csd(struct mmc_card *card, u32 *csd)
321 if (mmc_host_is_spi(card->host))
322 return mmc_spi_send_csd(card, csd);
324 return mmc_send_cxd_native(card->host, card->rca << 16, csd,
328 static int mmc_spi_send_cid(struct mmc_host *host, u32 *cid)
333 cid_tmp = kzalloc(16, GFP_KERNEL);
337 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
341 for (i = 0; i < 4; i++)
342 cid[i] = be32_to_cpu(cid_tmp[i]);
349 int mmc_send_cid(struct mmc_host *host, u32 *cid)
351 if (mmc_host_is_spi(host))
352 return mmc_spi_send_cid(host, cid);
354 return mmc_send_cxd_native(host, 0, cid, MMC_ALL_SEND_CID);
357 int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
362 if (!card || !new_ext_csd)
365 if (!mmc_can_ext_csd(card))
369 * As the ext_csd is so large and mostly unused, we don't store the
370 * raw block in mmc_card.
372 ext_csd = kzalloc(512, GFP_KERNEL);
376 err = mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, ext_csd,
381 *new_ext_csd = ext_csd;
385 EXPORT_SYMBOL_GPL(mmc_get_ext_csd);
387 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
389 struct mmc_command cmd = {};
392 cmd.opcode = MMC_SPI_READ_OCR;
393 cmd.arg = highcap ? (1 << 30) : 0;
394 cmd.flags = MMC_RSP_SPI_R3;
396 err = mmc_wait_for_cmd(host, &cmd, 0);
402 int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
404 struct mmc_command cmd = {};
407 cmd.opcode = MMC_SPI_CRC_ON_OFF;
408 cmd.flags = MMC_RSP_SPI_R1;
411 err = mmc_wait_for_cmd(host, &cmd, 0);
413 host->use_spi_crc = use_crc;
417 static int mmc_switch_status_error(struct mmc_host *host, u32 status)
419 if (mmc_host_is_spi(host)) {
420 if (status & R1_SPI_ILLEGAL_COMMAND)
423 if (R1_STATUS(status))
424 pr_warn("%s: unexpected status %#x after switch\n",
425 mmc_hostname(host), status);
426 if (status & R1_SWITCH_ERROR)
432 /* Caller must hold re-tuning */
433 int mmc_switch_status(struct mmc_card *card, bool crc_err_fatal)
438 err = mmc_send_status(card, &status);
439 if (!crc_err_fatal && err == -EILSEQ)
444 return mmc_switch_status_error(card->host, status);
447 static int mmc_busy_status(struct mmc_card *card, bool retry_crc_err,
450 struct mmc_host *host = card->host;
454 if (host->ops->card_busy) {
455 *busy = host->ops->card_busy(host);
459 err = mmc_send_status(card, &status);
460 if (retry_crc_err && err == -EILSEQ) {
467 err = mmc_switch_status_error(card->host, status);
471 *busy = !mmc_ready_for_data(status);
475 static int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms,
476 bool send_status, bool retry_crc_err)
478 struct mmc_host *host = card->host;
480 unsigned long timeout;
481 unsigned int udelay = 32, udelay_max = 32768;
482 bool expired = false;
486 * In cases when not allowed to poll by using CMD13 or because we aren't
487 * capable of polling by using ->card_busy(), then rely on waiting the
488 * stated timeout to be sufficient.
490 if (!send_status && !host->ops->card_busy) {
491 mmc_delay(timeout_ms);
495 timeout = jiffies + msecs_to_jiffies(timeout_ms) + 1;
498 * Due to the possibility of being preempted while polling,
499 * check the expiration time first.
501 expired = time_after(jiffies, timeout);
503 err = mmc_busy_status(card, retry_crc_err, &busy);
507 /* Timeout if the device still remains busy. */
508 if (expired && busy) {
509 pr_err("%s: Card stuck being busy! %s\n",
510 mmc_hostname(host), __func__);
514 /* Throttle the polling rate to avoid hogging the CPU. */
516 usleep_range(udelay, udelay * 2);
517 if (udelay < udelay_max)
526 * __mmc_switch - modify EXT_CSD register
527 * @card: the MMC card associated with the data transfer
528 * @set: cmd set values
529 * @index: EXT_CSD register index
530 * @value: value to program into EXT_CSD register
531 * @timeout_ms: timeout (ms) for operation performed by register write,
532 * timeout of zero implies maximum possible timeout
533 * @timing: new timing to change to
534 * @send_status: send status cmd to poll for busy
535 * @retry_crc_err: retry when CRC errors when polling with CMD13 for busy
537 * Modifies the EXT_CSD register for selected card.
539 int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
540 unsigned int timeout_ms, unsigned char timing,
541 bool send_status, bool retry_crc_err)
543 struct mmc_host *host = card->host;
545 struct mmc_command cmd = {};
546 bool use_r1b_resp = true;
547 unsigned char old_timing = host->ios.timing;
549 mmc_retune_hold(host);
552 pr_warn("%s: unspecified timeout for CMD6 - use generic\n",
554 timeout_ms = card->ext_csd.generic_cmd6_time;
558 * If the max_busy_timeout of the host is specified, make sure it's
559 * enough to fit the used timeout_ms. In case it's not, let's instruct
560 * the host to avoid HW busy detection, by converting to a R1 response
561 * instead of a R1B. Note, some hosts requires R1B, which also means
562 * they are on their own when it comes to deal with the busy timeout.
564 if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
565 (timeout_ms > host->max_busy_timeout))
566 use_r1b_resp = false;
568 cmd.opcode = MMC_SWITCH;
569 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
573 cmd.flags = MMC_CMD_AC;
575 cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
576 cmd.busy_timeout = timeout_ms;
578 cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
581 if (index == EXT_CSD_SANITIZE_START)
582 cmd.sanitize_busy = true;
584 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
588 /*If SPI or used HW busy detection above, then we don't need to poll. */
589 if (((host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp) ||
590 mmc_host_is_spi(host))
593 /* Let's try to poll to find out when the command is completed. */
594 err = mmc_poll_for_busy(card, timeout_ms, send_status, retry_crc_err);
599 /* Switch to new timing before check switch status. */
601 mmc_set_timing(host, timing);
604 err = mmc_switch_status(card, true);
606 mmc_set_timing(host, old_timing);
609 mmc_retune_release(host);
614 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
615 unsigned int timeout_ms)
617 return __mmc_switch(card, set, index, value, timeout_ms, 0,
620 EXPORT_SYMBOL_GPL(mmc_switch);
622 int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error)
624 struct mmc_request mrq = {};
625 struct mmc_command cmd = {};
626 struct mmc_data data = {};
627 struct scatterlist sg;
628 struct mmc_ios *ios = &host->ios;
629 const u8 *tuning_block_pattern;
633 if (ios->bus_width == MMC_BUS_WIDTH_8) {
634 tuning_block_pattern = tuning_blk_pattern_8bit;
635 size = sizeof(tuning_blk_pattern_8bit);
636 } else if (ios->bus_width == MMC_BUS_WIDTH_4) {
637 tuning_block_pattern = tuning_blk_pattern_4bit;
638 size = sizeof(tuning_blk_pattern_4bit);
642 data_buf = kzalloc(size, GFP_KERNEL);
650 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
654 data.flags = MMC_DATA_READ;
657 * According to the tuning specs, Tuning process
658 * is normally shorter 40 executions of CMD19,
659 * and timeout value should be shorter than 150 ms
661 data.timeout_ns = 150 * NSEC_PER_MSEC;
665 sg_init_one(&sg, data_buf, size);
667 mmc_wait_for_req(host, &mrq);
670 *cmd_error = cmd.error;
682 if (memcmp(data_buf, tuning_block_pattern, size))
689 EXPORT_SYMBOL_GPL(mmc_send_tuning);
691 int mmc_abort_tuning(struct mmc_host *host, u32 opcode)
693 struct mmc_command cmd = {};
696 * eMMC specification specifies that CMD12 can be used to stop a tuning
697 * command, but SD specification does not, so do nothing unless it is
700 if (opcode != MMC_SEND_TUNING_BLOCK_HS200)
703 cmd.opcode = MMC_STOP_TRANSMISSION;
704 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
707 * For drivers that override R1 to R1b, set an arbitrary timeout based
708 * on the tuning timeout i.e. 150ms.
710 cmd.busy_timeout = 150;
712 return mmc_wait_for_cmd(host, &cmd, 0);
714 EXPORT_SYMBOL_GPL(mmc_abort_tuning);
717 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
720 struct mmc_request mrq = {};
721 struct mmc_command cmd = {};
722 struct mmc_data data = {};
723 struct scatterlist sg;
727 static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
728 static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
730 /* dma onto stack is unsafe/nonportable, but callers to this
731 * routine normally provide temporary on-stack buffers ...
733 data_buf = kmalloc(len, GFP_KERNEL);
738 test_buf = testdata_8bit;
740 test_buf = testdata_4bit;
742 pr_err("%s: Invalid bus_width %d\n",
743 mmc_hostname(host), len);
748 if (opcode == MMC_BUS_TEST_W)
749 memcpy(data_buf, test_buf, len);
756 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
757 * rely on callers to never use this with "native" calls for reading
758 * CSD or CID. Native versions of those commands use the R2 type,
759 * not R1 plus a data block.
761 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
765 if (opcode == MMC_BUS_TEST_R)
766 data.flags = MMC_DATA_READ;
768 data.flags = MMC_DATA_WRITE;
772 mmc_set_data_timeout(&data, card);
773 sg_init_one(&sg, data_buf, len);
774 mmc_wait_for_req(host, &mrq);
776 if (opcode == MMC_BUS_TEST_R) {
777 for (i = 0; i < len / 4; i++)
778 if ((test_buf[i] ^ data_buf[i]) != 0xff) {
793 int mmc_bus_test(struct mmc_card *card, u8 bus_width)
797 if (bus_width == MMC_BUS_WIDTH_8)
799 else if (bus_width == MMC_BUS_WIDTH_4)
801 else if (bus_width == MMC_BUS_WIDTH_1)
802 return 0; /* no need for test */
807 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
808 * is a problem. This improves chances that the test will work.
810 mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
811 return mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
814 static int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
816 struct mmc_command cmd = {};
820 opcode = card->ext_csd.hpi_cmd;
821 if (opcode == MMC_STOP_TRANSMISSION)
822 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
823 else if (opcode == MMC_SEND_STATUS)
824 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
827 cmd.arg = card->rca << 16 | 1;
829 err = mmc_wait_for_cmd(card->host, &cmd, 0);
831 pr_warn("%s: error %d interrupting operation. "
832 "HPI command response %#x\n", mmc_hostname(card->host),
837 *status = cmd.resp[0];
843 * mmc_interrupt_hpi - Issue for High priority Interrupt
844 * @card: the MMC card associated with the HPI transfer
846 * Issued High Priority Interrupt, and check for card status
847 * until out-of prg-state.
849 int mmc_interrupt_hpi(struct mmc_card *card)
853 unsigned long prg_wait;
855 if (!card->ext_csd.hpi_en) {
856 pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
860 err = mmc_send_status(card, &status);
862 pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
866 switch (R1_CURRENT_STATE(status)) {
872 * In idle and transfer states, HPI is not needed and the caller
873 * can issue the next intended command immediately
879 /* In all other states, it's illegal to issue HPI */
880 pr_debug("%s: HPI cannot be sent. Card state=%d\n",
881 mmc_hostname(card->host), R1_CURRENT_STATE(status));
886 err = mmc_send_hpi_cmd(card, &status);
890 prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time);
892 err = mmc_send_status(card, &status);
894 if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN)
896 if (time_after(jiffies, prg_wait))
904 int mmc_can_ext_csd(struct mmc_card *card)
906 return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3);
909 static int mmc_read_bkops_status(struct mmc_card *card)
914 err = mmc_get_ext_csd(card, &ext_csd);
918 card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
919 card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
925 * mmc_run_bkops - Run BKOPS for supported cards
926 * @card: MMC card to run BKOPS for
928 * Run background operations synchronously for cards having manual BKOPS
929 * enabled and in case it reports urgent BKOPS level.
931 void mmc_run_bkops(struct mmc_card *card)
935 if (!card->ext_csd.man_bkops_en)
938 err = mmc_read_bkops_status(card);
940 pr_err("%s: Failed to read bkops status: %d\n",
941 mmc_hostname(card->host), err);
945 if (!card->ext_csd.raw_bkops_status ||
946 card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
949 mmc_retune_hold(card->host);
952 * For urgent BKOPS status, LEVEL_2 and higher, let's execute
953 * synchronously. Future wise, we may consider to start BKOPS, for less
954 * urgent levels by using an asynchronous background task, when idle.
956 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
957 EXT_CSD_BKOPS_START, 1, MMC_BKOPS_TIMEOUT_MS);
959 pr_warn("%s: Error %d starting bkops\n",
960 mmc_hostname(card->host), err);
962 mmc_retune_release(card->host);
964 EXPORT_SYMBOL(mmc_run_bkops);
967 * Flush the cache to the non-volatile storage.
969 int mmc_flush_cache(struct mmc_card *card)
973 if (mmc_card_mmc(card) &&
974 (card->ext_csd.cache_size > 0) &&
975 (card->ext_csd.cache_ctrl & 1)) {
976 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
977 EXT_CSD_FLUSH_CACHE, 1,
978 MMC_CACHE_FLUSH_TIMEOUT_MS);
980 pr_err("%s: cache flush error %d\n",
981 mmc_hostname(card->host), err);
986 EXPORT_SYMBOL(mmc_flush_cache);
988 static int mmc_cmdq_switch(struct mmc_card *card, bool enable)
990 u8 val = enable ? EXT_CSD_CMDQ_MODE_ENABLED : 0;
993 if (!card->ext_csd.cmdq_support)
996 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_CMDQ_MODE_EN,
997 val, card->ext_csd.generic_cmd6_time);
999 card->ext_csd.cmdq_en = enable;
1004 int mmc_cmdq_enable(struct mmc_card *card)
1006 return mmc_cmdq_switch(card, true);
1008 EXPORT_SYMBOL_GPL(mmc_cmdq_enable);
1010 int mmc_cmdq_disable(struct mmc_card *card)
1012 return mmc_cmdq_switch(card, false);
1014 EXPORT_SYMBOL_GPL(mmc_cmdq_disable);