lkml.org 
[lkml]   [2022]   [Dec]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRe: [PATCH V5 19/26] mmc: sdhci-uhs2: add request() and others
    Hi, Adrian

    On Wed, Nov 2, 2022 at 1:15 AM Adrian Hunter <adrian.hunter@intel.com> wrote:
    >
    > On 19/10/22 14:06, Victor Shih wrote:
    > > This is a sdhci version of mmc's request operation.
    > > It covers both UHS-I and UHS-II.
    > >
    > > Signed-off-by: Ben Chuang <ben.chuang@genesyslogic.com.tw>
    > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
    > > Signed-off-by: Victor Shih <victor.shih@genesyslogic.com.tw>
    > > ---
    > > drivers/mmc/host/sdhci-uhs2.c | 475 ++++++++++++++++++++++++++++++++++
    > > drivers/mmc/host/sdhci.c | 91 ++++---
    > > drivers/mmc/host/sdhci.h | 17 ++
    > > 3 files changed, 550 insertions(+), 33 deletions(-)
    > >
    > > diff --git a/drivers/mmc/host/sdhci-uhs2.c b/drivers/mmc/host/sdhci-uhs2.c
    > > index c9d59b8ac37f..41b089ccc200 100644
    > > --- a/drivers/mmc/host/sdhci-uhs2.c
    > > +++ b/drivers/mmc/host/sdhci-uhs2.c
    > > @@ -13,6 +13,7 @@
    > > #include <linux/delay.h>
    > > #include <linux/ktime.h>
    > > #include <linux/module.h>
    > > +#include <linux/mmc/mmc.h>
    > >
    > > #include "sdhci.h"
    > > #include "sdhci-uhs2.h"
    > > @@ -537,6 +538,479 @@ static int sdhci_uhs2_control(struct mmc_host *mmc, enum sd_uhs2_operation op)
    > > return err;
    > > }
    > >
    > > +/*****************************************************************************\
    > > + * *
    > > + * Core functions *
    > > + * *
    > > +\*****************************************************************************/
    > > +
    > > +static void sdhci_uhs2_prepare_data(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + struct mmc_data *data = cmd->data;
    > > +
    > > + sdhci_initialize_data(host, data);
    > > +
    > > + sdhci_prepare_dma(host, data);
    > > +
    > > + sdhci_writew(host, data->blksz, SDHCI_UHS2_BLOCK_SIZE);
    > > + sdhci_writew(host, data->blocks, SDHCI_UHS2_BLOCK_COUNT);
    > > +}
    > > +
    > > +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
    > > +static void sdhci_uhs2_external_dma_prepare_data(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + if (!sdhci_external_dma_setup(host, cmd)) {
    > > + __sdhci_external_dma_prepare_data(host, cmd);
    > > + } else {
    > > + sdhci_external_dma_release(host);
    > > + pr_err("%s: Cannot use external DMA, switch to the DMA/PIO which standard SDHCI provides.\n",
    > > + mmc_hostname(host->mmc));
    > > + sdhci_uhs2_prepare_data(host, cmd);
    > > + }
    > > +}
    > > +#else
    > > +static inline void sdhci_uhs2_external_dma_prepare_data(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + /* This should never happen */
    > > + WARN_ON_ONCE(1);
    > > +}
    > > +
    > > +static inline void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > +}
    > > +#endif /* CONFIG_MMC_SDHCI_EXTERNAL_DMA */
    >
    > Let's skip external DMA support to start with.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > +
    > > +static void sdhci_uhs2_finish_data(struct sdhci_host *host)
    > > +{
    > > + struct mmc_data *data = host->data;
    > > +
    > > + __sdhci_finish_data_common(host);
    > > +
    > > + /*
    > > + * FIXME: Is this condition needed?
    > > + if (host->mmc->flags & MMC_UHS2_INITIALIZED)
    > > + */
    >
    > No
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + __sdhci_finish_mrq(host, data->mrq);
    > > +}
    > > +
    > > +static void sdhci_uhs2_set_transfer_mode(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + u16 mode;
    > > + struct mmc_data *data = cmd->data;
    > > + u16 arg;
    > > +
    > > + if (!data) {
    > > + /* clear Auto CMD settings for no data CMDs */
    > > + arg = cmd->uhs2_cmd->arg;
    > > + if ((((arg & 0xF) << 8) | ((arg >> 8) & 0xFF)) ==
    >
    > Please don't open code byte-swapping
    >
    > This should be an inline function so it can be used again
    > further below:
    >
    > #define UHS2_ARG_IOADR_MASK 0xfff
    >
    > static inline u16 uhs2_dev_cmd(struct mmc_command *cmd)
    > {
    > return be16_to_cpu((__be16)cmd->uhs2_cmd->arg) & UHS2_ARG_IOADR_MASK;
    > }
    >
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + UHS2_DEV_CMD_TRANS_ABORT) {
    >
    > Please wrap at 100 columns instead of 80, here and elsewhere.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + mode = 0;
    > > + } else {
    > > + mode = sdhci_readw(host, SDHCI_UHS2_TRANS_MODE);
    > > + if (cmd->opcode == MMC_STOP_TRANSMISSION ||
    > > + cmd->opcode == MMC_ERASE)
    > > + mode |= SDHCI_UHS2_TRNS_WAIT_EBSY;
    > > + else
    > > + /* send status mode */
    > > + if (cmd->opcode == MMC_SEND_STATUS)
    > > + mode = 0;
    > > + }
    > > +
    > > + if (IS_ENABLED(CONFIG_MMC_DEBUG))
    >
    > Please don't use CONFIG_MMC_DEBUG
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + DBG("UHS2 no data trans mode is 0x%x.\n", mode);
    > > +
    > > + sdhci_writew(host, mode, SDHCI_UHS2_TRANS_MODE);
    > > + return;
    > > + }
    > > +
    > > + WARN_ON(!host->data);
    > > +
    > > + mode = SDHCI_UHS2_TRNS_BLK_CNT_EN | SDHCI_UHS2_TRNS_WAIT_EBSY;
    > > + if (data->flags & MMC_DATA_WRITE)
    > > + mode |= SDHCI_UHS2_TRNS_DATA_TRNS_WRT;
    > > +
    > > + if (data->blocks == 1 &&
    > > + data->blksz != 512 &&
    > > + cmd->opcode != MMC_READ_SINGLE_BLOCK &&
    > > + cmd->opcode != MMC_WRITE_BLOCK) {
    > > + mode &= ~SDHCI_UHS2_TRNS_BLK_CNT_EN;
    > > + mode |= SDHCI_UHS2_TRNS_BLK_BYTE_MODE;
    > > + }
    > > +
    > > + if (host->flags & SDHCI_REQ_USE_DMA)
    > > + mode |= SDHCI_UHS2_TRNS_DMA;
    > > +
    > > + if ((host->mmc->uhs2_ios.is_2L_HD_mode) && !cmd->uhs2_tmode0_flag)
    > > + mode |= SDHCI_UHS2_TRNS_2L_HD;
    > > +
    > > + sdhci_writew(host, mode, SDHCI_UHS2_TRANS_MODE);
    > > +
    > > + if (IS_ENABLED(CONFIG_MMC_DEBUG))
    >
    > Please don't use CONFIG_MMC_DEBUG
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + DBG("UHS2 trans mode is 0x%x.\n", mode);
    > > +}
    > > +
    > > +static void __sdhci_uhs2_send_command(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + int i, j;
    > > + int cmd_reg;
    > > +
    > > + if (host->mmc->flags & MMC_UHS2_INITIALIZED) {
    >
    > Not necessary to check MMC_UHS2_INITIALIZED here
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + if (!cmd->uhs2_cmd) {
    > > + pr_err("%s: fatal error, no uhs2_cmd!\n",
    > > + mmc_hostname(host->mmc));
    > > + return;
    > > + }
    > > + }
    > > +
    > > + i = 0;
    > > + sdhci_writel(host,
    > > + ((u32)cmd->uhs2_cmd->arg << 16) |
    > > + (u32)cmd->uhs2_cmd->header,
    > > + SDHCI_UHS2_CMD_PACKET + i);
    > > + i += 4;
    > > +
    > > + /*
    > > + * Per spec, playload (config) should be MSB before sending out.
    > > + * But we don't need convert here because had set payload as
    > > + * MSB when preparing config read/write commands.
    > > + */
    > > + for (j = 0; j < cmd->uhs2_cmd->payload_len / sizeof(u32); j++) {
    > > + sdhci_writel(host, *(cmd->uhs2_cmd->payload + j),
    > > + SDHCI_UHS2_CMD_PACKET + i);
    > > + i += 4;
    > > + }
    > > +
    > > + for ( ; i < SDHCI_UHS2_CMD_PACK_MAX_LEN; i += 4)
    > > + sdhci_writel(host, 0, SDHCI_UHS2_CMD_PACKET + i);
    > > +
    > > + if (IS_ENABLED(CONFIG_MMC_DEBUG)) {
    >
    > Please don't use CONFIG_MMC_DEBUG
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + DBG("UHS2 CMD packet_len = %d.\n", cmd->uhs2_cmd->packet_len);
    > > + for (i = 0; i < cmd->uhs2_cmd->packet_len; i++)
    > > + DBG("UHS2 CMD_PACKET[%d] = 0x%x.\n", i,
    > > + sdhci_readb(host, SDHCI_UHS2_CMD_PACKET + i));
    > > + }
    > > +
    > > + cmd_reg = cmd->uhs2_cmd->packet_len <<
    > > + SDHCI_UHS2_COMMAND_PACK_LEN_SHIFT;
    > > + if ((cmd->flags & MMC_CMD_MASK) == MMC_CMD_ADTC)
    > > + cmd_reg |= SDHCI_UHS2_COMMAND_DATA;
    > > + if (cmd->opcode == MMC_STOP_TRANSMISSION)
    > > + cmd_reg |= SDHCI_UHS2_COMMAND_CMD12;
    > > +
    > > + /* UHS2 Native ABORT */
    > > + if ((cmd->uhs2_cmd->header & UHS2_NATIVE_PACKET) &&
    > > + ((((cmd->uhs2_cmd->arg & 0xF) << 8) |
    > > + ((cmd->uhs2_cmd->arg >> 8) & 0xFF)) == UHS2_DEV_CMD_TRANS_ABORT))
    >
    > From above, can use (uhs2_dev_cmd(cmd) == UHS2_DEV_CMD_TRANS_ABORT)
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + cmd_reg |= SDHCI_UHS2_COMMAND_TRNS_ABORT;
    > > +
    > > + /* UHS2 Native DORMANT */
    > > + if ((cmd->uhs2_cmd->header & UHS2_NATIVE_PACKET) &&
    > > + ((((cmd->uhs2_cmd->arg & 0xF) << 8) |
    > > + ((cmd->uhs2_cmd->arg >> 8) & 0xFF)) ==
    > > + UHS2_DEV_CMD_GO_DORMANT_STATE))
    >
    > From above, can use (uhs2_dev_cmd(cmd) == UHS2_DEV_CMD_GO_DORMANT_STATE)
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + cmd_reg |= SDHCI_UHS2_COMMAND_DORMANT;
    > > +
    > > + DBG("0x%x is set to UHS2 CMD register.\n", cmd_reg);
    > > +
    > > + sdhci_writew(host, cmd_reg, SDHCI_UHS2_COMMAND);
    > > +}
    > > +
    > > +static bool sdhci_uhs2_send_command(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > +{
    > > + int flags;
    > > + u32 mask;
    > > + unsigned long timeout;
    > > +
    > > + WARN_ON(host->cmd);
    > > +
    > > + /* Initially, a command has no error */
    > > + cmd->error = 0;
    > > +
    > > + if (!(host->mmc->flags & MMC_UHS2_SUPPORT))
    > > + return sdhci_send_command(host, cmd);
    >
    > No check necessary, can remove, and please do not export
    > sdhci_send_command().
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > +
    > > + if (cmd->opcode == MMC_STOP_TRANSMISSION)
    > > + cmd->flags |= MMC_RSP_BUSY;
    > > +
    > > + mask = SDHCI_CMD_INHIBIT;
    > > +
    > > + if (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask)
    > > + return false;
    > > +
    > > + host->cmd = cmd;
    > > + host->data_timeout = 0;
    > > + if (sdhci_data_line_cmd(cmd)) {
    > > + WARN_ON(host->data_cmd);
    > > + host->data_cmd = cmd;
    > > + __sdhci_uhs2_set_timeout(host);
    > > + }
    > > +
    > > + if (cmd->data) {
    > > + if (host->use_external_dma)
    >
    > Let's skip external DMA support for now
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + sdhci_uhs2_external_dma_prepare_data(host, cmd);
    > > + else
    > > + sdhci_uhs2_prepare_data(host, cmd);
    > > + }
    > > +
    > > + sdhci_uhs2_set_transfer_mode(host, cmd);
    > > +
    > > + if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
    > > + WARN_ONCE(1, "Unsupported response type!\n");
    > > + /*
    > > + * This does not happen in practice because 136-bit response
    > > + * commands never have busy waiting, so rather than complicate
    > > + * the error path, just remove busy waiting and continue.
    > > + */
    > > + cmd->flags &= ~MMC_RSP_BUSY;
    > > + }
    > > +
    > > + if (!(cmd->flags & MMC_RSP_PRESENT))
    > > + flags = SDHCI_CMD_RESP_NONE;
    > > + else if (cmd->flags & MMC_RSP_136)
    > > + flags = SDHCI_CMD_RESP_LONG;
    > > + else if (cmd->flags & MMC_RSP_BUSY)
    > > + flags = SDHCI_CMD_RESP_SHORT_BUSY;
    > > + else
    > > + flags = SDHCI_CMD_RESP_SHORT;
    > > +
    > > + if (cmd->flags & MMC_RSP_CRC)
    > > + flags |= SDHCI_CMD_CRC;
    > > + if (cmd->flags & MMC_RSP_OPCODE)
    > > + flags |= SDHCI_CMD_INDEX;
    > > +
    > > + timeout = jiffies;
    > > + if (host->data_timeout)
    > > + timeout += nsecs_to_jiffies(host->data_timeout);
    > > + else if (!cmd->data && cmd->busy_timeout > 9000)
    > > + timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
    > > + else
    > > + timeout += 10 * HZ;
    > > + sdhci_mod_timer(host, cmd->mrq, timeout);
    > > +
    > > + if (host->use_external_dma)
    > > + sdhci_external_dma_pre_transfer(host, cmd);
    > > +
    > > + __sdhci_uhs2_send_command(host, cmd);
    > > +
    > > + return true;
    > > +}
    > > +
    > > +static bool sdhci_uhs2_send_command_retry(struct sdhci_host *host,
    > > + struct mmc_command *cmd,
    > > + unsigned long flags)
    > > + __releases(host->lock)
    > > + __acquires(host->lock)
    > > +{
    > > + struct mmc_command *deferred_cmd = host->deferred_cmd;
    > > + int timeout = 10; /* Approx. 10 ms */
    > > + bool present;
    > > +
    > > + while (!sdhci_uhs2_send_command(host, cmd)) {
    > > + if (!timeout--) {
    > > + pr_err("%s: Controller never released inhibit bit(s).\n",
    > > + mmc_hostname(host->mmc));
    > > + sdhci_dumpregs(host);
    > > + cmd->error = -EIO;
    > > + return false;
    > > + }
    > > +
    > > + spin_unlock_irqrestore(&host->lock, flags);
    > > +
    > > + usleep_range(1000, 1250);
    > > +
    > > + present = host->mmc->ops->get_cd(host->mmc);
    > > +
    > > + spin_lock_irqsave(&host->lock, flags);
    > > +
    > > + /* A deferred command might disappear, handle that */
    > > + if (cmd == deferred_cmd && cmd != host->deferred_cmd)
    > > + return true;
    > > +
    > > + if (sdhci_present_error(host, cmd, present))
    > > + return false;
    > > + }
    > > +
    > > + if (cmd == host->deferred_cmd)
    > > + host->deferred_cmd = NULL;
    > > +
    > > + return true;
    > > +}
    > > +
    > > +static void __sdhci_uhs2_finish_command(struct sdhci_host *host)
    > > +{
    > > + struct mmc_command *cmd = host->cmd;
    > > + u8 resp;
    > > + u8 ecode;
    > > + bool bReadA0 = 0;
    > > + int i;
    > > +
    > > + if (host->mmc->flags & MMC_UHS2_INITIALIZED) {
    > > + resp = sdhci_readb(host, SDHCI_UHS2_RESPONSE + 2);
    > > + if (resp & UHS2_RES_NACK_MASK) {
    > > + ecode = (resp >> UHS2_RES_ECODE_POS) &
    > > + UHS2_RES_ECODE_MASK;
    > > + pr_err("%s: NACK is got, ECODE=0x%x.\n",
    > > + mmc_hostname(host->mmc), ecode);
    > > + }
    > > + bReadA0 = 1;
    > > + }
    > > +
    > > + if (cmd->uhs2_resp &&
    > > + cmd->uhs2_resp_len && cmd->uhs2_resp_len <= 20) {
    > > + /* Get whole response of some native CCMD, like
    > > + * DEVICE_INIT, ENUMERATE.
    > > + */
    > > + for (i = 0; i < cmd->uhs2_resp_len; i++)
    > > + cmd->uhs2_resp[i] =
    > > + sdhci_readb(host, SDHCI_UHS2_RESPONSE + i);
    > > + } else {
    > > + /* Get SD CMD response and Payload for some read
    > > + * CCMD, like INQUIRY_CFG.
    > > + */
    > > + /* Per spec (p136), payload field is divided into
    > > + * a unit of DWORD and transmission order within
    > > + * a DWORD is big endian.
    > > + */
    > > + if (!bReadA0)
    > > + sdhci_readl(host, SDHCI_UHS2_RESPONSE);
    > > + for (i = 4; i < 20; i += 4) {
    > > + cmd->resp[i / 4 - 1] =
    > > + (sdhci_readb(host,
    > > + SDHCI_UHS2_RESPONSE + i) << 24) |
    > > + (sdhci_readb(host,
    > > + SDHCI_UHS2_RESPONSE + i + 1)
    > > + << 16) |
    > > + (sdhci_readb(host,
    > > + SDHCI_UHS2_RESPONSE + i + 2)
    > > + << 8) |
    > > + sdhci_readb(host, SDHCI_UHS2_RESPONSE + i + 3);
    > > + }
    > > + }
    > > +}
    > > +
    > > +static void sdhci_uhs2_finish_command(struct sdhci_host *host)
    > > +{
    > > + struct mmc_command *cmd = host->cmd;
    > > +
    > > + /* FIXME: Is this check necessary? */
    >
    > No
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + if (!(host->mmc->flags & MMC_UHS2_SUPPORT)) {
    > > + sdhci_finish_command(host);
    >
    > Please do not export sdhci_finish_command()
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + return;
    > > + }
    > > +
    > > + __sdhci_uhs2_finish_command(host);
    > > +
    > > + host->cmd = NULL;
    > > +
    > > + if (cmd->mrq->cap_cmd_during_tfr && cmd == cmd->mrq->cmd)
    > > + mmc_command_done(host->mmc, cmd->mrq);
    > > +
    > > + /*
    > > + * The host can send and interrupt when the busy state has
    > > + * ended, allowing us to wait without wasting CPU cycles.
    > > + * The busy signal uses DAT0 so this is similar to waiting
    > > + * for data to complete.
    > > + *
    > > + * Note: The 1.0 specification is a bit ambiguous about this
    > > + * feature so there might be some problems with older
    > > + * controllers.
    > > + */
    > > + if (cmd->flags & MMC_RSP_BUSY) {
    > > + if (cmd->data) {
    > > + DBG("Cannot wait for busy signal when also doing a data transfer");
    > > + } else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ) &&
    > > + cmd == host->data_cmd) {
    > > + /* Command complete before busy is ended */
    > > + return;
    > > + }
    > > + }
    > > +
    > > + /* Processed actual command. */
    > > + if (host->data && host->data_early)
    > > + sdhci_uhs2_finish_data(host);
    > > +
    > > + if (!cmd->data)
    > > + __sdhci_finish_mrq(host, cmd->mrq);
    > > +}
    > > +
    > > +void sdhci_uhs2_request(struct mmc_host *mmc, struct mmc_request *mrq)
    > > +{
    > > + struct sdhci_host *host = mmc_priv(mmc);
    > > + struct mmc_command *cmd;
    > > + unsigned long flags;
    > > + bool present;
    > > +
    > > + /* FIXME: check more flags? */
    >
    > No, it's fine.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > + if (!(sdhci_uhs2_mode(host))) {
    > > + sdhci_request(mmc, mrq);
    > > + return;
    > > + }
    >
    > We need to clear the stop cmd and sbc to prevent the
    > driver using them.
    >
    > mrq->stop = NULL;
    > mrq->sbc = NULL;
    > if (mrq->data)
    > mrq->data->stop = NULL;
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > > +
    > > + /* Firstly check card presence */
    > > + present = mmc->ops->get_cd(mmc);
    > > +
    > > + spin_lock_irqsave(&host->lock, flags);
    > > +
    > > + if (sdhci_present_error(host, mrq->cmd, present))
    > > + goto out_finish;
    > > +
    > > + cmd = mrq->cmd;
    > > +
    > > + if (!sdhci_uhs2_send_command(host, cmd))
    > > + goto out_finish;
    > > +
    > > + spin_unlock_irqrestore(&host->lock, flags);
    > > +
    > > + return;
    > > +
    > > +out_finish:
    > > + sdhci_finish_mrq(host, mrq);
    > > + spin_unlock_irqrestore(&host->lock, flags);
    > > +}
    > > +EXPORT_SYMBOL_GPL(sdhci_uhs2_request);
    > > +
    > > +int sdhci_uhs2_request_atomic(struct mmc_host *mmc, struct mmc_request *mrq)
    > > +{
    > > + struct sdhci_host *host = mmc_priv(mmc);
    > > + struct mmc_command *cmd;
    > > + unsigned long flags;
    > > + int ret = 0;
    > > +
    > > + if (!host->mmc->flags & MMC_UHS2_SUPPORT)
    > > + return sdhci_request_atomic(mmc, mrq);
    > > +
    > > + spin_lock_irqsave(&host->lock, flags);
    > > +
    > > + if (sdhci_present_error(host, mrq->cmd, true)) {
    > > + sdhci_finish_mrq(host, mrq);
    > > + goto out_finish;
    > > + }
    > > +
    > > + cmd = mrq->cmd;
    > > +
    > > + /*
    > > + * The HSQ may send a command in interrupt context without polling
    > > + * the busy signaling, which means we should return BUSY if controller
    > > + * has not released inhibit bits to allow HSQ trying to send request
    > > + * again in non-atomic context. So we should not finish this request
    > > + * here.
    > > + */
    > > + if (!sdhci_uhs2_send_command(host, cmd))
    > > + ret = -EBUSY;
    > > +
    > > +out_finish:
    > > + spin_unlock_irqrestore(&host->lock, flags);
    > > + return ret;
    > > +}
    > > +EXPORT_SYMBOL_GPL(sdhci_uhs2_request_atomic);
    > > +
    > > /*****************************************************************************\
    > > * *
    > > * Driver init/exit *
    > > @@ -692,6 +1166,7 @@ static int sdhci_uhs2_host_ops_init(struct sdhci_host *host)
    > > sdhci_uhs2_start_signal_voltage_switch;
    > > host->mmc_host_ops.uhs2_set_ios = sdhci_uhs2_set_ios;
    > > host->mmc_host_ops.uhs2_control = sdhci_uhs2_control;
    > > + host->mmc_host_ops.request = sdhci_uhs2_request;
    > >
    > > if (!host->mmc_host_ops.uhs2_detect_init)
    > > host->mmc_host_ops.uhs2_detect_init = sdhci_uhs2_do_detect_init;
    > > diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
    > > index b9db2e976010..407169468927 100644
    > > --- a/drivers/mmc/host/sdhci.c
    > > +++ b/drivers/mmc/host/sdhci.c
    > > @@ -47,8 +47,6 @@
    > > static unsigned int debug_quirks = 0;
    > > static unsigned int debug_quirks2;
    > >
    > > -static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd);
    > > -
    > > void sdhci_dumpregs(struct sdhci_host *host)
    > > {
    > > SDHCI_DUMP("============ SDHCI REGISTER DUMP ===========\n");
    > > @@ -147,10 +145,11 @@ void sdhci_enable_v4_mode(struct sdhci_host *host)
    > > }
    > > EXPORT_SYMBOL_GPL(sdhci_enable_v4_mode);
    > >
    > > -static inline bool sdhci_data_line_cmd(struct mmc_command *cmd)
    > > +bool sdhci_data_line_cmd(struct mmc_command *cmd)
    > > {
    > > return cmd->data || cmd->flags & MMC_RSP_BUSY;
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_data_line_cmd);
    > >
    > > static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
    > > {
    > > @@ -409,7 +408,7 @@ static void sdhci_reinit(struct sdhci_host *host)
    > > mmc_detect_change(host->mmc, msecs_to_jiffies(200));
    > > }
    > >
    > > -static void __sdhci_led_activate(struct sdhci_host *host)
    > > +void __sdhci_led_activate(struct sdhci_host *host)
    > > {
    > > u8 ctrl;
    > >
    > > @@ -420,8 +419,9 @@ static void __sdhci_led_activate(struct sdhci_host *host)
    > > ctrl |= SDHCI_CTRL_LED;
    > > sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
    > > }
    > > +EXPORT_SYMBOL_GPL(__sdhci_led_activate);
    >
    > The LED functions like __sdhci_led_activate() are not being used
    > and don't need to be exported.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > >
    > > -static void __sdhci_led_deactivate(struct sdhci_host *host)
    > > +void __sdhci_led_deactivate(struct sdhci_host *host)
    > > {
    > > u8 ctrl;
    > >
    > > @@ -432,6 +432,7 @@ static void __sdhci_led_deactivate(struct sdhci_host *host)
    > > ctrl &= ~SDHCI_CTRL_LED;
    > > sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
    > > }
    > > +EXPORT_SYMBOL_GPL(__sdhci_led_deactivate);
    > >
    > > #if IS_REACHABLE(CONFIG_LEDS_CLASS)
    > > static void sdhci_led_control(struct led_classdev *led,
    > > @@ -510,14 +511,15 @@ static inline void sdhci_led_deactivate(struct sdhci_host *host)
    > >
    > > #endif
    > >
    > > -static void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq,
    > > - unsigned long timeout)
    > > +void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq,
    > > + unsigned long timeout)
    > > {
    > > if (sdhci_data_line_cmd(mrq->cmd))
    > > mod_timer(&host->data_timer, timeout);
    > > else
    > > mod_timer(&host->timer, timeout);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_mod_timer);
    > >
    > > static void sdhci_del_timer(struct sdhci_host *host, struct mmc_request *mrq)
    > > {
    > > @@ -1098,8 +1100,7 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
    > > __sdhci_set_timeout(host, cmd);
    > > }
    > >
    > > -static void sdhci_initialize_data(struct sdhci_host *host,
    > > - struct mmc_data *data)
    > > +void sdhci_initialize_data(struct sdhci_host *host, struct mmc_data *data)
    > > {
    > > WARN_ON(host->data);
    > >
    > > @@ -1112,6 +1113,7 @@ static void sdhci_initialize_data(struct sdhci_host *host,
    > > host->data_early = 0;
    > > host->data->bytes_xfered = 0;
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_initialize_data);
    > >
    > > static inline void sdhci_set_block_info(struct sdhci_host *host,
    > > struct mmc_data *data)
    > > @@ -1134,12 +1136,8 @@ static inline void sdhci_set_block_info(struct sdhci_host *host,
    > > }
    > > }
    > >
    > > -static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
    > > +void sdhci_prepare_dma(struct sdhci_host *host, struct mmc_data *data)
    > > {
    > > - struct mmc_data *data = cmd->data;
    > > -
    > > - sdhci_initialize_data(host, data);
    > > -
    > > if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
    > > struct scatterlist *sg;
    > > unsigned int length_mask, offset_mask;
    > > @@ -1224,6 +1222,16 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
    > > }
    > >
    > > sdhci_set_transfer_irqs(host);
    > > +}
    > > +EXPORT_SYMBOL_GPL(sdhci_prepare_dma);
    > > +
    > > +static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
    > > +{
    > > + struct mmc_data *data = cmd->data;
    > > +
    > > + sdhci_initialize_data(host, data);
    > > +
    > > + sdhci_prepare_dma(host, data);
    > >
    > > sdhci_set_block_info(host, data);
    > > }
    > > @@ -1266,8 +1274,7 @@ static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
    > > return data->flags & MMC_DATA_WRITE ? host->tx_chan : host->rx_chan;
    > > }
    > >
    > > -static int sdhci_external_dma_setup(struct sdhci_host *host,
    > > - struct mmc_command *cmd)
    > > +int sdhci_external_dma_setup(struct sdhci_host *host, struct mmc_command *cmd)
    > > {
    > > int ret, i;
    > > enum dma_transfer_direction dir;
    > > @@ -1320,8 +1327,9 @@ static int sdhci_external_dma_setup(struct sdhci_host *host,
    > >
    > > return ret;
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_external_dma_setup);
    > >
    > > -static void sdhci_external_dma_release(struct sdhci_host *host)
    > > +void sdhci_external_dma_release(struct sdhci_host *host)
    > > {
    > > if (host->tx_chan) {
    > > dma_release_channel(host->tx_chan);
    > > @@ -1335,9 +1343,10 @@ static void sdhci_external_dma_release(struct sdhci_host *host)
    > >
    > > sdhci_switch_external_dma(host, false);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_external_dma_release);
    > >
    > > -static void __sdhci_external_dma_prepare_data(struct sdhci_host *host,
    > > - struct mmc_command *cmd)
    > > +void __sdhci_external_dma_prepare_data(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > {
    > > struct mmc_data *data = cmd->data;
    > >
    > > @@ -1348,6 +1357,7 @@ static void __sdhci_external_dma_prepare_data(struct sdhci_host *host,
    > >
    > > sdhci_set_block_info(host, data);
    > > }
    > > +EXPORT_SYMBOL(__sdhci_external_dma_prepare_data);
    > >
    > > static void sdhci_external_dma_prepare_data(struct sdhci_host *host,
    > > struct mmc_command *cmd)
    > > @@ -1362,8 +1372,8 @@ static void sdhci_external_dma_prepare_data(struct sdhci_host *host,
    > > }
    > > }
    > >
    > > -static void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
    > > - struct mmc_command *cmd)
    > > +void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
    > > + struct mmc_command *cmd)
    > > {
    > > struct dma_chan *chan;
    > >
    > > @@ -1374,6 +1384,7 @@ static void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
    > > if (chan)
    > > dma_async_issue_pending(chan);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_external_dma_pre_transfer);
    > >
    > > #else
    > >
    > > @@ -1425,11 +1436,11 @@ static inline bool sdhci_auto_cmd23(struct sdhci_host *host,
    > > return mrq->sbc && (host->flags & SDHCI_AUTO_CMD23);
    > > }
    > >
    > > -static inline bool sdhci_manual_cmd23(struct sdhci_host *host,
    > > - struct mmc_request *mrq)
    > > +bool sdhci_manual_cmd23(struct sdhci_host *host, struct mmc_request *mrq)
    > > {
    > > return mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_manual_cmd23);
    >
    > Also don't see sdhci_manual_cmd23() being used.
    > Please check what is being exported.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > >
    > > static inline void sdhci_auto_cmd_select(struct sdhci_host *host,
    > > struct mmc_command *cmd,
    > > @@ -1541,7 +1552,7 @@ static void sdhci_set_mrq_done(struct sdhci_host *host, struct mmc_request *mrq)
    > > WARN_ON(i >= SDHCI_MAX_MRQS);
    > > }
    > >
    > > -static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
    > > +void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
    > > {
    > > if (host->cmd && host->cmd->mrq == mrq)
    > > host->cmd = NULL;
    > > @@ -1565,15 +1576,17 @@ static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
    > > if (!sdhci_has_requests(host))
    > > sdhci_led_deactivate(host);
    > > }
    > > +EXPORT_SYMBOL_GPL(__sdhci_finish_mrq);
    > >
    > > -static void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
    > > +void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
    > > {
    > > __sdhci_finish_mrq(host, mrq);
    > >
    > > queue_work(host->complete_wq, &host->complete_work);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_finish_mrq);
    > >
    > > -static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout)
    > > +void __sdhci_finish_data_common(struct sdhci_host *host)
    > > {
    > > struct mmc_command *data_cmd = host->data_cmd;
    > > struct mmc_data *data = host->data;
    > > @@ -1607,6 +1620,14 @@ static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout)
    > > data->bytes_xfered = 0;
    > > else
    > > data->bytes_xfered = data->blksz * data->blocks;
    > > +}
    > > +EXPORT_SYMBOL_GPL(__sdhci_finish_data_common);
    > > +
    > > +static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout)
    > > +{
    > > + struct mmc_data *data = host->data;
    > > +
    > > + __sdhci_finish_data_common(host);
    > >
    > > /*
    > > * Need to send CMD12 if -
    > > @@ -1645,12 +1666,13 @@ static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout)
    > > }
    > > }
    > >
    > > -static void sdhci_finish_data(struct sdhci_host *host)
    > > +void sdhci_finish_data(struct sdhci_host *host)
    > > {
    > > __sdhci_finish_data(host, false);
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_finish_data);
    >
    > Also don't see sdhci_finish_data() being used.
    > Please check what is being exported.
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > >
    > > -static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
    > > +bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
    > > {
    > > int flags;
    > > u32 mask;
    > > @@ -1692,8 +1714,6 @@ static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
    > > sdhci_prepare_data(host, cmd);
    > > }
    > >
    > > - sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
    > > -
    > > sdhci_set_transfer_mode(host, cmd);
    > >
    > > if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
    > > @@ -1737,13 +1757,16 @@ static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
    > > if (host->use_external_dma)
    > > sdhci_external_dma_pre_transfer(host, cmd);
    > >
    > > + sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
    >
    > If this move of "sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT)"
    > is intentional, it should be a separate patch.
    >
    > > +
    > > sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
    > >
    > > return true;
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_send_command);
    >
    > It is not necessary to export sdhci_send_command()
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > >
    > > -static bool sdhci_present_error(struct sdhci_host *host,
    > > - struct mmc_command *cmd, bool present)
    > > +bool sdhci_present_error(struct sdhci_host *host,
    > > + struct mmc_command *cmd, bool present)
    > > {
    > > if (!present || host->flags & SDHCI_DEVICE_DEAD) {
    > > cmd->error = -ENOMEDIUM;
    > > @@ -1752,6 +1775,7 @@ static bool sdhci_present_error(struct sdhci_host *host,
    > >
    > > return false;
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_present_error);
    > >
    > > static bool sdhci_send_command_retry(struct sdhci_host *host,
    > > struct mmc_command *cmd,
    > > @@ -1815,7 +1839,7 @@ static void sdhci_read_rsp_136(struct sdhci_host *host, struct mmc_command *cmd)
    > > }
    > > }
    > >
    > > -static void sdhci_finish_command(struct sdhci_host *host)
    > > +void sdhci_finish_command(struct sdhci_host *host)
    > > {
    > > struct mmc_command *cmd = host->cmd;
    > >
    > > @@ -1868,6 +1892,7 @@ static void sdhci_finish_command(struct sdhci_host *host)
    > > __sdhci_finish_mrq(host, cmd->mrq);
    > > }
    > > }
    > > +EXPORT_SYMBOL_GPL(sdhci_finish_command);
    >
    > It is not necessary to export sdhci_finish_command()
    >

    I will update it in the patch#18 of the new [PATCH V6].

    > >
    > > static u16 sdhci_get_preset_value(struct sdhci_host *host)
    > > {
    > > diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
    > > index f049331bd0bc..1a9924e7972d 100644
    > > --- a/drivers/mmc/host/sdhci.h
    > > +++ b/drivers/mmc/host/sdhci.h
    > > @@ -850,8 +850,25 @@ static inline void sdhci_read_caps(struct sdhci_host *host)
    > > __sdhci_read_caps(host, NULL, NULL, NULL);
    > > }
    > >
    > > +bool sdhci_data_line_cmd(struct mmc_command *cmd);
    > > void sdhci_runtime_pm_bus_on(struct sdhci_host *host);
    > > void sdhci_runtime_pm_bus_off(struct sdhci_host *host);
    > > +void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq, unsigned long timeout);
    > > +void sdhci_initialize_data(struct sdhci_host *host, struct mmc_data *data);
    > > +void sdhci_prepare_dma(struct sdhci_host *host, struct mmc_data *data);
    > > +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
    > > +int sdhci_external_dma_setup(struct sdhci_host *host, struct mmc_command *cmd);
    > > +void sdhci_external_dma_release(struct sdhci_host *host);
    > > +void __sdhci_external_dma_prepare_data(struct sdhci_host *host, struct mmc_command *cmd);
    > > +void sdhci_external_dma_pre_transfer(struct sdhci_host *host, struct mmc_command *cmd);
    > > +#endif
    > > +bool sdhci_manual_cmd23(struct sdhci_host *host, struct mmc_request *mrq);
    > > +void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq);
    > > +void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq);
    > > +void __sdhci_finish_data_common(struct sdhci_host *host);
    > > +bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd);
    > > +void sdhci_finish_command(struct sdhci_host *host);
    > > +bool sdhci_present_error(struct sdhci_host *host, struct mmc_command *cmd, bool present);
    > > u16 sdhci_calc_clk(struct sdhci_host *host, unsigned int clock,
    > > unsigned int *actual_clock);
    > > void sdhci_set_clock(struct sdhci_host *host, unsigned int clock);
    >

    Thanks, Victor Shih

    \
     
     \ /
      Last update: 2022-12-13 09:50    [W:3.217 / U:1.884 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site