mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Ulf Hansson](/assets/img/avatar_default.png)
Commit76bfc7ccc2
("mmc: core: adjust polling interval for CMD1"), significantly decreased the polling period from ~10-12ms into just a couple of us. The purpose was to decrease the total time spent in the busy polling loop, but unfortunate it has lead to problems, that causes eMMC cards to never gets out busy and thus fails to be initialized. To fix the problem, but also to try to keep some of the new improved behaviour, let's start by using a polling period of 1-2ms, which then increases for each loop, according to common polling loop in __mmc_poll_for_busy(). Reported-by: Jean Rene Dawin <jdawin@math.uni-bielefeld.de> Reported-by: H. Nikolaus Schaller <hns@goldelico.com> Cc: Huijin Park <huijin.park@samsung.com> Fixes:76bfc7ccc2
("mmc: core: adjust polling interval for CMD1") Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org> Tested-by: Jean Rene Dawin <jdawin@math.uni-bielefeld.de> Tested-by: H. Nikolaus Schaller <hns@goldelico.com> Link: https://lore.kernel.org/r/20220304105656.149281-1-ulf.hansson@linaro.org
1070 lines
25 KiB
C
1070 lines
25 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* linux/drivers/mmc/core/mmc_ops.h
|
|
*
|
|
* Copyright 2006-2007 Pierre Ossman
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/export.h>
|
|
#include <linux/types.h>
|
|
#include <linux/scatterlist.h>
|
|
|
|
#include <linux/mmc/host.h>
|
|
#include <linux/mmc/card.h>
|
|
#include <linux/mmc/mmc.h>
|
|
|
|
#include "core.h"
|
|
#include "card.h"
|
|
#include "host.h"
|
|
#include "mmc_ops.h"
|
|
|
|
#define MMC_BKOPS_TIMEOUT_MS (120 * 1000) /* 120s */
|
|
#define MMC_SANITIZE_TIMEOUT_MS (240 * 1000) /* 240s */
|
|
#define MMC_OP_COND_PERIOD_US (1 * 1000) /* 1ms */
|
|
#define MMC_OP_COND_TIMEOUT_MS 1000 /* 1s */
|
|
|
|
static const u8 tuning_blk_pattern_4bit[] = {
|
|
0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
|
|
0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
|
|
0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
|
|
0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
|
|
0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
|
|
0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
|
|
0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
|
|
0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
|
|
};
|
|
|
|
static const u8 tuning_blk_pattern_8bit[] = {
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
|
|
0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
|
|
0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
|
|
0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
|
|
0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
|
|
0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
|
|
0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
|
|
0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
|
|
0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
|
|
0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
|
|
0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
|
|
0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
|
|
0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
|
|
0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
|
|
0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
|
|
};
|
|
|
|
struct mmc_busy_data {
|
|
struct mmc_card *card;
|
|
bool retry_crc_err;
|
|
enum mmc_busy_cmd busy_cmd;
|
|
};
|
|
|
|
struct mmc_op_cond_busy_data {
|
|
struct mmc_host *host;
|
|
u32 ocr;
|
|
struct mmc_command *cmd;
|
|
};
|
|
|
|
int __mmc_send_status(struct mmc_card *card, u32 *status, unsigned int retries)
|
|
{
|
|
int err;
|
|
struct mmc_command cmd = {};
|
|
|
|
cmd.opcode = MMC_SEND_STATUS;
|
|
if (!mmc_host_is_spi(card->host))
|
|
cmd.arg = card->rca << 16;
|
|
cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
err = mmc_wait_for_cmd(card->host, &cmd, retries);
|
|
if (err)
|
|
return err;
|
|
|
|
/* NOTE: callers are required to understand the difference
|
|
* between "native" and SPI format status words!
|
|
*/
|
|
if (status)
|
|
*status = cmd.resp[0];
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__mmc_send_status);
|
|
|
|
int mmc_send_status(struct mmc_card *card, u32 *status)
|
|
{
|
|
return __mmc_send_status(card, status, MMC_CMD_RETRIES);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_send_status);
|
|
|
|
static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
|
|
cmd.opcode = MMC_SELECT_CARD;
|
|
|
|
if (card) {
|
|
cmd.arg = card->rca << 16;
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
|
|
} else {
|
|
cmd.arg = 0;
|
|
cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
|
|
}
|
|
|
|
return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
|
|
}
|
|
|
|
int mmc_select_card(struct mmc_card *card)
|
|
{
|
|
|
|
return _mmc_select_card(card->host, card);
|
|
}
|
|
|
|
int mmc_deselect_cards(struct mmc_host *host)
|
|
{
|
|
return _mmc_select_card(host, NULL);
|
|
}
|
|
|
|
/*
|
|
* Write the value specified in the device tree or board code into the optional
|
|
* 16 bit Driver Stage Register. This can be used to tune raise/fall times and
|
|
* drive strength of the DAT and CMD outputs. The actual meaning of a given
|
|
* value is hardware dependant.
|
|
* The presence of the DSR register can be determined from the CSD register,
|
|
* bit 76.
|
|
*/
|
|
int mmc_set_dsr(struct mmc_host *host)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
|
|
cmd.opcode = MMC_SET_DSR;
|
|
|
|
cmd.arg = (host->dsr << 16) | 0xffff;
|
|
cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
|
|
|
|
return mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
|
|
}
|
|
|
|
int mmc_go_idle(struct mmc_host *host)
|
|
{
|
|
int err;
|
|
struct mmc_command cmd = {};
|
|
|
|
/*
|
|
* Non-SPI hosts need to prevent chipselect going active during
|
|
* GO_IDLE; that would put chips into SPI mode. Remind them of
|
|
* that in case of hardware that won't pull up DAT3/nCS otherwise.
|
|
*
|
|
* SPI hosts ignore ios.chip_select; it's managed according to
|
|
* rules that must accommodate non-MMC slaves which this layer
|
|
* won't even know about.
|
|
*/
|
|
if (!mmc_host_is_spi(host)) {
|
|
mmc_set_chip_select(host, MMC_CS_HIGH);
|
|
mmc_delay(1);
|
|
}
|
|
|
|
cmd.opcode = MMC_GO_IDLE_STATE;
|
|
cmd.arg = 0;
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
|
|
mmc_delay(1);
|
|
|
|
if (!mmc_host_is_spi(host)) {
|
|
mmc_set_chip_select(host, MMC_CS_DONTCARE);
|
|
mmc_delay(1);
|
|
}
|
|
|
|
host->use_spi_crc = 0;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int __mmc_send_op_cond_cb(void *cb_data, bool *busy)
|
|
{
|
|
struct mmc_op_cond_busy_data *data = cb_data;
|
|
struct mmc_host *host = data->host;
|
|
struct mmc_command *cmd = data->cmd;
|
|
u32 ocr = data->ocr;
|
|
int err = 0;
|
|
|
|
err = mmc_wait_for_cmd(host, cmd, 0);
|
|
if (err)
|
|
return err;
|
|
|
|
if (mmc_host_is_spi(host)) {
|
|
if (!(cmd->resp[0] & R1_SPI_IDLE)) {
|
|
*busy = false;
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (cmd->resp[0] & MMC_CARD_BUSY) {
|
|
*busy = false;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
*busy = true;
|
|
|
|
/*
|
|
* According to eMMC specification v5.1 section 6.4.3, we
|
|
* should issue CMD1 repeatedly in the idle state until
|
|
* the eMMC is ready. Otherwise some eMMC devices seem to enter
|
|
* the inactive mode after mmc_init_card() issued CMD0 when
|
|
* the eMMC device is busy.
|
|
*/
|
|
if (!ocr && !mmc_host_is_spi(host))
|
|
cmd->arg = cmd->resp[0] | BIT(30);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
int err = 0;
|
|
struct mmc_op_cond_busy_data cb_data = {
|
|
.host = host,
|
|
.ocr = ocr,
|
|
.cmd = &cmd
|
|
};
|
|
|
|
cmd.opcode = MMC_SEND_OP_COND;
|
|
cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
|
|
|
|
err = __mmc_poll_for_busy(host, MMC_OP_COND_PERIOD_US,
|
|
MMC_OP_COND_TIMEOUT_MS,
|
|
&__mmc_send_op_cond_cb, &cb_data);
|
|
if (err)
|
|
return err;
|
|
|
|
if (rocr && !mmc_host_is_spi(host))
|
|
*rocr = cmd.resp[0];
|
|
|
|
return err;
|
|
}
|
|
|
|
int mmc_set_relative_addr(struct mmc_card *card)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
|
|
cmd.opcode = MMC_SET_RELATIVE_ADDR;
|
|
cmd.arg = card->rca << 16;
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
return mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
|
|
}
|
|
|
|
static int
|
|
mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
|
|
{
|
|
int err;
|
|
struct mmc_command cmd = {};
|
|
|
|
cmd.opcode = opcode;
|
|
cmd.arg = arg;
|
|
cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
|
|
if (err)
|
|
return err;
|
|
|
|
memcpy(cxd, cmd.resp, sizeof(u32) * 4);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* NOTE: void *buf, caller for the buf is required to use DMA-capable
|
|
* buffer or on-stack buffer (with some overhead in callee).
|
|
*/
|
|
int mmc_send_adtc_data(struct mmc_card *card, struct mmc_host *host, u32 opcode,
|
|
u32 args, void *buf, unsigned len)
|
|
{
|
|
struct mmc_request mrq = {};
|
|
struct mmc_command cmd = {};
|
|
struct mmc_data data = {};
|
|
struct scatterlist sg;
|
|
|
|
mrq.cmd = &cmd;
|
|
mrq.data = &data;
|
|
|
|
cmd.opcode = opcode;
|
|
cmd.arg = args;
|
|
|
|
/* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
|
|
* rely on callers to never use this with "native" calls for reading
|
|
* CSD or CID. Native versions of those commands use the R2 type,
|
|
* not R1 plus a data block.
|
|
*/
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
|
|
|
|
data.blksz = len;
|
|
data.blocks = 1;
|
|
data.flags = MMC_DATA_READ;
|
|
data.sg = &sg;
|
|
data.sg_len = 1;
|
|
|
|
sg_init_one(&sg, buf, len);
|
|
|
|
if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
|
|
/*
|
|
* The spec states that CSR and CID accesses have a timeout
|
|
* of 64 clock cycles.
|
|
*/
|
|
data.timeout_ns = 0;
|
|
data.timeout_clks = 64;
|
|
} else
|
|
mmc_set_data_timeout(&data, card);
|
|
|
|
mmc_wait_for_req(host, &mrq);
|
|
|
|
if (cmd.error)
|
|
return cmd.error;
|
|
if (data.error)
|
|
return data.error;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mmc_spi_send_cxd(struct mmc_host *host, u32 *cxd, u32 opcode)
|
|
{
|
|
int ret, i;
|
|
__be32 *cxd_tmp;
|
|
|
|
cxd_tmp = kzalloc(16, GFP_KERNEL);
|
|
if (!cxd_tmp)
|
|
return -ENOMEM;
|
|
|
|
ret = mmc_send_adtc_data(NULL, host, opcode, 0, cxd_tmp, 16);
|
|
if (ret)
|
|
goto err;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
cxd[i] = be32_to_cpu(cxd_tmp[i]);
|
|
|
|
err:
|
|
kfree(cxd_tmp);
|
|
return ret;
|
|
}
|
|
|
|
int mmc_send_csd(struct mmc_card *card, u32 *csd)
|
|
{
|
|
if (mmc_host_is_spi(card->host))
|
|
return mmc_spi_send_cxd(card->host, csd, MMC_SEND_CSD);
|
|
|
|
return mmc_send_cxd_native(card->host, card->rca << 16, csd,
|
|
MMC_SEND_CSD);
|
|
}
|
|
|
|
int mmc_send_cid(struct mmc_host *host, u32 *cid)
|
|
{
|
|
if (mmc_host_is_spi(host))
|
|
return mmc_spi_send_cxd(host, cid, MMC_SEND_CID);
|
|
|
|
return mmc_send_cxd_native(host, 0, cid, MMC_ALL_SEND_CID);
|
|
}
|
|
|
|
int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
|
|
{
|
|
int err;
|
|
u8 *ext_csd;
|
|
|
|
if (!card || !new_ext_csd)
|
|
return -EINVAL;
|
|
|
|
if (!mmc_can_ext_csd(card))
|
|
return -EOPNOTSUPP;
|
|
|
|
/*
|
|
* As the ext_csd is so large and mostly unused, we don't store the
|
|
* raw block in mmc_card.
|
|
*/
|
|
ext_csd = kzalloc(512, GFP_KERNEL);
|
|
if (!ext_csd)
|
|
return -ENOMEM;
|
|
|
|
err = mmc_send_adtc_data(card, card->host, MMC_SEND_EXT_CSD, 0, ext_csd,
|
|
512);
|
|
if (err)
|
|
kfree(ext_csd);
|
|
else
|
|
*new_ext_csd = ext_csd;
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_get_ext_csd);
|
|
|
|
int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
int err;
|
|
|
|
cmd.opcode = MMC_SPI_READ_OCR;
|
|
cmd.arg = highcap ? (1 << 30) : 0;
|
|
cmd.flags = MMC_RSP_SPI_R3;
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
|
|
*ocrp = cmd.resp[1];
|
|
return err;
|
|
}
|
|
|
|
int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
int err;
|
|
|
|
cmd.opcode = MMC_SPI_CRC_ON_OFF;
|
|
cmd.flags = MMC_RSP_SPI_R1;
|
|
cmd.arg = use_crc;
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
if (!err)
|
|
host->use_spi_crc = use_crc;
|
|
return err;
|
|
}
|
|
|
|
static int mmc_switch_status_error(struct mmc_host *host, u32 status)
|
|
{
|
|
if (mmc_host_is_spi(host)) {
|
|
if (status & R1_SPI_ILLEGAL_COMMAND)
|
|
return -EBADMSG;
|
|
} else {
|
|
if (R1_STATUS(status))
|
|
pr_warn("%s: unexpected status %#x after switch\n",
|
|
mmc_hostname(host), status);
|
|
if (status & R1_SWITCH_ERROR)
|
|
return -EBADMSG;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Caller must hold re-tuning */
|
|
int mmc_switch_status(struct mmc_card *card, bool crc_err_fatal)
|
|
{
|
|
u32 status;
|
|
int err;
|
|
|
|
err = mmc_send_status(card, &status);
|
|
if (!crc_err_fatal && err == -EILSEQ)
|
|
return 0;
|
|
if (err)
|
|
return err;
|
|
|
|
return mmc_switch_status_error(card->host, status);
|
|
}
|
|
|
|
static int mmc_busy_cb(void *cb_data, bool *busy)
|
|
{
|
|
struct mmc_busy_data *data = cb_data;
|
|
struct mmc_host *host = data->card->host;
|
|
u32 status = 0;
|
|
int err;
|
|
|
|
if (data->busy_cmd != MMC_BUSY_IO && host->ops->card_busy) {
|
|
*busy = host->ops->card_busy(host);
|
|
return 0;
|
|
}
|
|
|
|
err = mmc_send_status(data->card, &status);
|
|
if (data->retry_crc_err && err == -EILSEQ) {
|
|
*busy = true;
|
|
return 0;
|
|
}
|
|
if (err)
|
|
return err;
|
|
|
|
switch (data->busy_cmd) {
|
|
case MMC_BUSY_CMD6:
|
|
err = mmc_switch_status_error(host, status);
|
|
break;
|
|
case MMC_BUSY_ERASE:
|
|
err = R1_STATUS(status) ? -EIO : 0;
|
|
break;
|
|
case MMC_BUSY_HPI:
|
|
case MMC_BUSY_EXTR_SINGLE:
|
|
case MMC_BUSY_IO:
|
|
break;
|
|
default:
|
|
err = -EINVAL;
|
|
}
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
*busy = !mmc_ready_for_data(status);
|
|
return 0;
|
|
}
|
|
|
|
int __mmc_poll_for_busy(struct mmc_host *host, unsigned int period_us,
|
|
unsigned int timeout_ms,
|
|
int (*busy_cb)(void *cb_data, bool *busy),
|
|
void *cb_data)
|
|
{
|
|
int err;
|
|
unsigned long timeout;
|
|
unsigned int udelay = period_us ? period_us : 32, udelay_max = 32768;
|
|
bool expired = false;
|
|
bool busy = false;
|
|
|
|
timeout = jiffies + msecs_to_jiffies(timeout_ms) + 1;
|
|
do {
|
|
/*
|
|
* Due to the possibility of being preempted while polling,
|
|
* check the expiration time first.
|
|
*/
|
|
expired = time_after(jiffies, timeout);
|
|
|
|
err = (*busy_cb)(cb_data, &busy);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Timeout if the device still remains busy. */
|
|
if (expired && busy) {
|
|
pr_err("%s: Card stuck being busy! %s\n",
|
|
mmc_hostname(host), __func__);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
/* Throttle the polling rate to avoid hogging the CPU. */
|
|
if (busy) {
|
|
usleep_range(udelay, udelay * 2);
|
|
if (udelay < udelay_max)
|
|
udelay *= 2;
|
|
}
|
|
} while (busy);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__mmc_poll_for_busy);
|
|
|
|
int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms,
|
|
bool retry_crc_err, enum mmc_busy_cmd busy_cmd)
|
|
{
|
|
struct mmc_host *host = card->host;
|
|
struct mmc_busy_data cb_data;
|
|
|
|
cb_data.card = card;
|
|
cb_data.retry_crc_err = retry_crc_err;
|
|
cb_data.busy_cmd = busy_cmd;
|
|
|
|
return __mmc_poll_for_busy(host, 0, timeout_ms, &mmc_busy_cb, &cb_data);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_poll_for_busy);
|
|
|
|
bool mmc_prepare_busy_cmd(struct mmc_host *host, struct mmc_command *cmd,
|
|
unsigned int timeout_ms)
|
|
{
|
|
/*
|
|
* If the max_busy_timeout of the host is specified, make sure it's
|
|
* enough to fit the used timeout_ms. In case it's not, let's instruct
|
|
* the host to avoid HW busy detection, by converting to a R1 response
|
|
* instead of a R1B. Note, some hosts requires R1B, which also means
|
|
* they are on their own when it comes to deal with the busy timeout.
|
|
*/
|
|
if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
|
|
(timeout_ms > host->max_busy_timeout)) {
|
|
cmd->flags = MMC_CMD_AC | MMC_RSP_SPI_R1 | MMC_RSP_R1;
|
|
return false;
|
|
}
|
|
|
|
cmd->flags = MMC_CMD_AC | MMC_RSP_SPI_R1B | MMC_RSP_R1B;
|
|
cmd->busy_timeout = timeout_ms;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* __mmc_switch - modify EXT_CSD register
|
|
* @card: the MMC card associated with the data transfer
|
|
* @set: cmd set values
|
|
* @index: EXT_CSD register index
|
|
* @value: value to program into EXT_CSD register
|
|
* @timeout_ms: timeout (ms) for operation performed by register write,
|
|
* timeout of zero implies maximum possible timeout
|
|
* @timing: new timing to change to
|
|
* @send_status: send status cmd to poll for busy
|
|
* @retry_crc_err: retry when CRC errors when polling with CMD13 for busy
|
|
* @retries: number of retries
|
|
*
|
|
* Modifies the EXT_CSD register for selected card.
|
|
*/
|
|
int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
|
|
unsigned int timeout_ms, unsigned char timing,
|
|
bool send_status, bool retry_crc_err, unsigned int retries)
|
|
{
|
|
struct mmc_host *host = card->host;
|
|
int err;
|
|
struct mmc_command cmd = {};
|
|
bool use_r1b_resp;
|
|
unsigned char old_timing = host->ios.timing;
|
|
|
|
mmc_retune_hold(host);
|
|
|
|
if (!timeout_ms) {
|
|
pr_warn("%s: unspecified timeout for CMD6 - use generic\n",
|
|
mmc_hostname(host));
|
|
timeout_ms = card->ext_csd.generic_cmd6_time;
|
|
}
|
|
|
|
cmd.opcode = MMC_SWITCH;
|
|
cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
|
|
(index << 16) |
|
|
(value << 8) |
|
|
set;
|
|
use_r1b_resp = mmc_prepare_busy_cmd(host, &cmd, timeout_ms);
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, retries);
|
|
if (err)
|
|
goto out;
|
|
|
|
/*If SPI or used HW busy detection above, then we don't need to poll. */
|
|
if (((host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp) ||
|
|
mmc_host_is_spi(host))
|
|
goto out_tim;
|
|
|
|
/*
|
|
* If the host doesn't support HW polling via the ->card_busy() ops and
|
|
* when it's not allowed to poll by using CMD13, then we need to rely on
|
|
* waiting the stated timeout to be sufficient.
|
|
*/
|
|
if (!send_status && !host->ops->card_busy) {
|
|
mmc_delay(timeout_ms);
|
|
goto out_tim;
|
|
}
|
|
|
|
/* Let's try to poll to find out when the command is completed. */
|
|
err = mmc_poll_for_busy(card, timeout_ms, retry_crc_err, MMC_BUSY_CMD6);
|
|
if (err)
|
|
goto out;
|
|
|
|
out_tim:
|
|
/* Switch to new timing before check switch status. */
|
|
if (timing)
|
|
mmc_set_timing(host, timing);
|
|
|
|
if (send_status) {
|
|
err = mmc_switch_status(card, true);
|
|
if (err && timing)
|
|
mmc_set_timing(host, old_timing);
|
|
}
|
|
out:
|
|
mmc_retune_release(host);
|
|
|
|
return err;
|
|
}
|
|
|
|
int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
|
|
unsigned int timeout_ms)
|
|
{
|
|
return __mmc_switch(card, set, index, value, timeout_ms, 0,
|
|
true, false, MMC_CMD_RETRIES);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_switch);
|
|
|
|
int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error)
|
|
{
|
|
struct mmc_request mrq = {};
|
|
struct mmc_command cmd = {};
|
|
struct mmc_data data = {};
|
|
struct scatterlist sg;
|
|
struct mmc_ios *ios = &host->ios;
|
|
const u8 *tuning_block_pattern;
|
|
int size, err = 0;
|
|
u8 *data_buf;
|
|
|
|
if (ios->bus_width == MMC_BUS_WIDTH_8) {
|
|
tuning_block_pattern = tuning_blk_pattern_8bit;
|
|
size = sizeof(tuning_blk_pattern_8bit);
|
|
} else if (ios->bus_width == MMC_BUS_WIDTH_4) {
|
|
tuning_block_pattern = tuning_blk_pattern_4bit;
|
|
size = sizeof(tuning_blk_pattern_4bit);
|
|
} else
|
|
return -EINVAL;
|
|
|
|
data_buf = kzalloc(size, GFP_KERNEL);
|
|
if (!data_buf)
|
|
return -ENOMEM;
|
|
|
|
mrq.cmd = &cmd;
|
|
mrq.data = &data;
|
|
|
|
cmd.opcode = opcode;
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
|
|
|
|
data.blksz = size;
|
|
data.blocks = 1;
|
|
data.flags = MMC_DATA_READ;
|
|
|
|
/*
|
|
* According to the tuning specs, Tuning process
|
|
* is normally shorter 40 executions of CMD19,
|
|
* and timeout value should be shorter than 150 ms
|
|
*/
|
|
data.timeout_ns = 150 * NSEC_PER_MSEC;
|
|
|
|
data.sg = &sg;
|
|
data.sg_len = 1;
|
|
sg_init_one(&sg, data_buf, size);
|
|
|
|
mmc_wait_for_req(host, &mrq);
|
|
|
|
if (cmd_error)
|
|
*cmd_error = cmd.error;
|
|
|
|
if (cmd.error) {
|
|
err = cmd.error;
|
|
goto out;
|
|
}
|
|
|
|
if (data.error) {
|
|
err = data.error;
|
|
goto out;
|
|
}
|
|
|
|
if (memcmp(data_buf, tuning_block_pattern, size))
|
|
err = -EIO;
|
|
|
|
out:
|
|
kfree(data_buf);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_send_tuning);
|
|
|
|
int mmc_send_abort_tuning(struct mmc_host *host, u32 opcode)
|
|
{
|
|
struct mmc_command cmd = {};
|
|
|
|
/*
|
|
* eMMC specification specifies that CMD12 can be used to stop a tuning
|
|
* command, but SD specification does not, so do nothing unless it is
|
|
* eMMC.
|
|
*/
|
|
if (opcode != MMC_SEND_TUNING_BLOCK_HS200)
|
|
return 0;
|
|
|
|
cmd.opcode = MMC_STOP_TRANSMISSION;
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
/*
|
|
* For drivers that override R1 to R1b, set an arbitrary timeout based
|
|
* on the tuning timeout i.e. 150ms.
|
|
*/
|
|
cmd.busy_timeout = 150;
|
|
|
|
return mmc_wait_for_cmd(host, &cmd, 0);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_send_abort_tuning);
|
|
|
|
static int
|
|
mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
|
|
u8 len)
|
|
{
|
|
struct mmc_request mrq = {};
|
|
struct mmc_command cmd = {};
|
|
struct mmc_data data = {};
|
|
struct scatterlist sg;
|
|
u8 *data_buf;
|
|
u8 *test_buf;
|
|
int i, err;
|
|
static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
|
|
static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 };
|
|
|
|
/* dma onto stack is unsafe/nonportable, but callers to this
|
|
* routine normally provide temporary on-stack buffers ...
|
|
*/
|
|
data_buf = kmalloc(len, GFP_KERNEL);
|
|
if (!data_buf)
|
|
return -ENOMEM;
|
|
|
|
if (len == 8)
|
|
test_buf = testdata_8bit;
|
|
else if (len == 4)
|
|
test_buf = testdata_4bit;
|
|
else {
|
|
pr_err("%s: Invalid bus_width %d\n",
|
|
mmc_hostname(host), len);
|
|
kfree(data_buf);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (opcode == MMC_BUS_TEST_W)
|
|
memcpy(data_buf, test_buf, len);
|
|
|
|
mrq.cmd = &cmd;
|
|
mrq.data = &data;
|
|
cmd.opcode = opcode;
|
|
cmd.arg = 0;
|
|
|
|
/* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
|
|
* rely on callers to never use this with "native" calls for reading
|
|
* CSD or CID. Native versions of those commands use the R2 type,
|
|
* not R1 plus a data block.
|
|
*/
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
|
|
|
|
data.blksz = len;
|
|
data.blocks = 1;
|
|
if (opcode == MMC_BUS_TEST_R)
|
|
data.flags = MMC_DATA_READ;
|
|
else
|
|
data.flags = MMC_DATA_WRITE;
|
|
|
|
data.sg = &sg;
|
|
data.sg_len = 1;
|
|
mmc_set_data_timeout(&data, card);
|
|
sg_init_one(&sg, data_buf, len);
|
|
mmc_wait_for_req(host, &mrq);
|
|
err = 0;
|
|
if (opcode == MMC_BUS_TEST_R) {
|
|
for (i = 0; i < len / 4; i++)
|
|
if ((test_buf[i] ^ data_buf[i]) != 0xff) {
|
|
err = -EIO;
|
|
break;
|
|
}
|
|
}
|
|
kfree(data_buf);
|
|
|
|
if (cmd.error)
|
|
return cmd.error;
|
|
if (data.error)
|
|
return data.error;
|
|
|
|
return err;
|
|
}
|
|
|
|
int mmc_bus_test(struct mmc_card *card, u8 bus_width)
|
|
{
|
|
int width;
|
|
|
|
if (bus_width == MMC_BUS_WIDTH_8)
|
|
width = 8;
|
|
else if (bus_width == MMC_BUS_WIDTH_4)
|
|
width = 4;
|
|
else if (bus_width == MMC_BUS_WIDTH_1)
|
|
return 0; /* no need for test */
|
|
else
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
|
|
* is a problem. This improves chances that the test will work.
|
|
*/
|
|
mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width);
|
|
return mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width);
|
|
}
|
|
|
|
static int mmc_send_hpi_cmd(struct mmc_card *card)
|
|
{
|
|
unsigned int busy_timeout_ms = card->ext_csd.out_of_int_time;
|
|
struct mmc_host *host = card->host;
|
|
bool use_r1b_resp = false;
|
|
struct mmc_command cmd = {};
|
|
int err;
|
|
|
|
cmd.opcode = card->ext_csd.hpi_cmd;
|
|
cmd.arg = card->rca << 16 | 1;
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
if (cmd.opcode == MMC_STOP_TRANSMISSION)
|
|
use_r1b_resp = mmc_prepare_busy_cmd(host, &cmd,
|
|
busy_timeout_ms);
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
if (err) {
|
|
pr_warn("%s: HPI error %d. Command response %#x\n",
|
|
mmc_hostname(host), err, cmd.resp[0]);
|
|
return err;
|
|
}
|
|
|
|
/* No need to poll when using HW busy detection. */
|
|
if (host->caps & MMC_CAP_WAIT_WHILE_BUSY && use_r1b_resp)
|
|
return 0;
|
|
|
|
/* Let's poll to find out when the HPI request completes. */
|
|
return mmc_poll_for_busy(card, busy_timeout_ms, false, MMC_BUSY_HPI);
|
|
}
|
|
|
|
/**
|
|
* mmc_interrupt_hpi - Issue for High priority Interrupt
|
|
* @card: the MMC card associated with the HPI transfer
|
|
*
|
|
* Issued High Priority Interrupt, and check for card status
|
|
* until out-of prg-state.
|
|
*/
|
|
static int mmc_interrupt_hpi(struct mmc_card *card)
|
|
{
|
|
int err;
|
|
u32 status;
|
|
|
|
if (!card->ext_csd.hpi_en) {
|
|
pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
|
|
return 1;
|
|
}
|
|
|
|
err = mmc_send_status(card, &status);
|
|
if (err) {
|
|
pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
|
|
goto out;
|
|
}
|
|
|
|
switch (R1_CURRENT_STATE(status)) {
|
|
case R1_STATE_IDLE:
|
|
case R1_STATE_READY:
|
|
case R1_STATE_STBY:
|
|
case R1_STATE_TRAN:
|
|
/*
|
|
* In idle and transfer states, HPI is not needed and the caller
|
|
* can issue the next intended command immediately
|
|
*/
|
|
goto out;
|
|
case R1_STATE_PRG:
|
|
break;
|
|
default:
|
|
/* In all other states, it's illegal to issue HPI */
|
|
pr_debug("%s: HPI cannot be sent. Card state=%d\n",
|
|
mmc_hostname(card->host), R1_CURRENT_STATE(status));
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
err = mmc_send_hpi_cmd(card);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
int mmc_can_ext_csd(struct mmc_card *card)
|
|
{
|
|
return (card && card->csd.mmca_vsn > CSD_SPEC_VER_3);
|
|
}
|
|
|
|
static int mmc_read_bkops_status(struct mmc_card *card)
|
|
{
|
|
int err;
|
|
u8 *ext_csd;
|
|
|
|
err = mmc_get_ext_csd(card, &ext_csd);
|
|
if (err)
|
|
return err;
|
|
|
|
card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
|
|
card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
|
|
kfree(ext_csd);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* mmc_run_bkops - Run BKOPS for supported cards
|
|
* @card: MMC card to run BKOPS for
|
|
*
|
|
* Run background operations synchronously for cards having manual BKOPS
|
|
* enabled and in case it reports urgent BKOPS level.
|
|
*/
|
|
void mmc_run_bkops(struct mmc_card *card)
|
|
{
|
|
int err;
|
|
|
|
if (!card->ext_csd.man_bkops_en)
|
|
return;
|
|
|
|
err = mmc_read_bkops_status(card);
|
|
if (err) {
|
|
pr_err("%s: Failed to read bkops status: %d\n",
|
|
mmc_hostname(card->host), err);
|
|
return;
|
|
}
|
|
|
|
if (!card->ext_csd.raw_bkops_status ||
|
|
card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
|
|
return;
|
|
|
|
mmc_retune_hold(card->host);
|
|
|
|
/*
|
|
* For urgent BKOPS status, LEVEL_2 and higher, let's execute
|
|
* synchronously. Future wise, we may consider to start BKOPS, for less
|
|
* urgent levels by using an asynchronous background task, when idle.
|
|
*/
|
|
err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
|
|
EXT_CSD_BKOPS_START, 1, MMC_BKOPS_TIMEOUT_MS);
|
|
/*
|
|
* If the BKOPS timed out, the card is probably still busy in the
|
|
* R1_STATE_PRG. Rather than continue to wait, let's try to abort
|
|
* it with a HPI command to get back into R1_STATE_TRAN.
|
|
*/
|
|
if (err == -ETIMEDOUT && !mmc_interrupt_hpi(card))
|
|
pr_warn("%s: BKOPS aborted\n", mmc_hostname(card->host));
|
|
else if (err)
|
|
pr_warn("%s: Error %d running bkops\n",
|
|
mmc_hostname(card->host), err);
|
|
|
|
mmc_retune_release(card->host);
|
|
}
|
|
EXPORT_SYMBOL(mmc_run_bkops);
|
|
|
|
static int mmc_cmdq_switch(struct mmc_card *card, bool enable)
|
|
{
|
|
u8 val = enable ? EXT_CSD_CMDQ_MODE_ENABLED : 0;
|
|
int err;
|
|
|
|
if (!card->ext_csd.cmdq_support)
|
|
return -EOPNOTSUPP;
|
|
|
|
err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_CMDQ_MODE_EN,
|
|
val, card->ext_csd.generic_cmd6_time);
|
|
if (!err)
|
|
card->ext_csd.cmdq_en = enable;
|
|
|
|
return err;
|
|
}
|
|
|
|
int mmc_cmdq_enable(struct mmc_card *card)
|
|
{
|
|
return mmc_cmdq_switch(card, true);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_cmdq_enable);
|
|
|
|
int mmc_cmdq_disable(struct mmc_card *card)
|
|
{
|
|
return mmc_cmdq_switch(card, false);
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_cmdq_disable);
|
|
|
|
int mmc_sanitize(struct mmc_card *card, unsigned int timeout_ms)
|
|
{
|
|
struct mmc_host *host = card->host;
|
|
int err;
|
|
|
|
if (!mmc_can_sanitize(card)) {
|
|
pr_warn("%s: Sanitize not supported\n", mmc_hostname(host));
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
if (!timeout_ms)
|
|
timeout_ms = MMC_SANITIZE_TIMEOUT_MS;
|
|
|
|
pr_debug("%s: Sanitize in progress...\n", mmc_hostname(host));
|
|
|
|
mmc_retune_hold(host);
|
|
|
|
err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_SANITIZE_START,
|
|
1, timeout_ms, 0, true, false, 0);
|
|
if (err)
|
|
pr_err("%s: Sanitize failed err=%d\n", mmc_hostname(host), err);
|
|
|
|
/*
|
|
* If the sanitize operation timed out, the card is probably still busy
|
|
* in the R1_STATE_PRG. Rather than continue to wait, let's try to abort
|
|
* it with a HPI command to get back into R1_STATE_TRAN.
|
|
*/
|
|
if (err == -ETIMEDOUT && !mmc_interrupt_hpi(card))
|
|
pr_warn("%s: Sanitize aborted\n", mmc_hostname(host));
|
|
|
|
mmc_retune_release(host);
|
|
|
|
pr_debug("%s: Sanitize completed\n", mmc_hostname(host));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mmc_sanitize);
|