Commit 9c7e7050 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'mmc-v5.15-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc 

Pull MMC fixes from Ulf Hansson:
 "A couple of MMC host fixes:

   - meson-gx: Fix read/write access for dram-access-quirk

   - sdhci-of-at91: Fix calibration sequence"

* tag 'mmc-v5.15-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc:
  mmc: meson-gx: do not use memcpy_to/fromio for dram-access-quirk
  mmc: sdhci-of-at91: replace while loop with read_poll_timeout
  mmc: sdhci-of-at91: wait for calibration done before proceed
parents 0068dc8c 8a38a4d5

drivers/mmc/host/meson-gx-mmc.c

+59 −14
Original line number Diff line number Diff line
@@ -746,7 +746,7 @@ static void meson_mmc_desc_chain_transfer(struct mmc_host *mmc, u32 cmd_cfg) 
	writel(start, host->regs + SD_EMMC_START);

}



/* local sg copy to buffer version with _to/fromio usage for dram_access_quirk */

/* local sg copy for dram_access_quirk */

static void meson_mmc_copy_buffer(struct meson_host *host, struct mmc_data *data,

				  size_t buflen, bool to_buffer)

{
@@ -764,21 +764,27 @@ static void meson_mmc_copy_buffer(struct meson_host *host, struct mmc_data *data 
	sg_miter_start(&miter, sgl, nents, sg_flags);



	while ((offset < buflen) && sg_miter_next(&miter)) {

		unsigned int len;

		unsigned int buf_offset = 0;

		unsigned int len, left;

		u32 *buf = miter.addr;



		len = min(miter.length, buflen - offset);

		left = len;



		/* When dram_access_quirk, the bounce buffer is a iomem mapping */

		if (host->dram_access_quirk) {

			if (to_buffer)

				memcpy_toio(host->bounce_iomem_buf + offset, miter.addr, len);

			else

				memcpy_fromio(miter.addr, host->bounce_iomem_buf + offset, len);

		if (to_buffer) {

			do {

				writel(*buf++, host->bounce_iomem_buf + offset + buf_offset);



				buf_offset += 4;

				left -= 4;

			} while (left);

		} else {

			if (to_buffer)

				memcpy(host->bounce_buf + offset, miter.addr, len);

			else

				memcpy(miter.addr, host->bounce_buf + offset, len);

			do {

				*buf++ = readl(host->bounce_iomem_buf + offset + buf_offset);



				buf_offset += 4;

				left -= 4;

			} while (left);

		}



		offset += len;
@@ -830,7 +836,11 @@ static void meson_mmc_start_cmd(struct mmc_host *mmc, struct mmc_command *cmd) 
		if (data->flags & MMC_DATA_WRITE) {

			cmd_cfg |= CMD_CFG_DATA_WR;

			WARN_ON(xfer_bytes > host->bounce_buf_size);

			if (host->dram_access_quirk)

				meson_mmc_copy_buffer(host, data, xfer_bytes, true);

			else

				sg_copy_to_buffer(data->sg, data->sg_len,

						  host->bounce_buf, xfer_bytes);

			dma_wmb();

		}
@@ -849,12 +859,43 @@ static void meson_mmc_start_cmd(struct mmc_host *mmc, struct mmc_command *cmd) 
	writel(cmd->arg, host->regs + SD_EMMC_CMD_ARG);

}



static int meson_mmc_validate_dram_access(struct mmc_host *mmc, struct mmc_data *data)

{

	struct scatterlist *sg;

	int i;



	/* Reject request if any element offset or size is not 32bit aligned */

	for_each_sg(data->sg, sg, data->sg_len, i) {

		if (!IS_ALIGNED(sg->offset, sizeof(u32)) ||

		    !IS_ALIGNED(sg->length, sizeof(u32))) {

			dev_err(mmc_dev(mmc), "unaligned sg offset %u len %u\n",

				data->sg->offset, data->sg->length);

			return -EINVAL;

		}

	}



	return 0;

}



static void meson_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)

{

	struct meson_host *host = mmc_priv(mmc);

	bool needs_pre_post_req = mrq->data &&

			!(mrq->data->host_cookie & SD_EMMC_PRE_REQ_DONE);



	/*

	 * The memory at the end of the controller used as bounce buffer for

	 * the dram_access_quirk only accepts 32bit read/write access,

	 * check the aligment and length of the data before starting the request.

	 */

	if (host->dram_access_quirk && mrq->data) {

		mrq->cmd->error = meson_mmc_validate_dram_access(mmc, mrq->data);

		if (mrq->cmd->error) {

			mmc_request_done(mmc, mrq);

			return;

		}

	}



	if (needs_pre_post_req) {

		meson_mmc_get_transfer_mode(mmc, mrq);

		if (!meson_mmc_desc_chain_mode(mrq->data))
@@ -999,7 +1040,11 @@ static irqreturn_t meson_mmc_irq_thread(int irq, void *dev_id) 
	if (meson_mmc_bounce_buf_read(data)) {

		xfer_bytes = data->blksz * data->blocks;

		WARN_ON(xfer_bytes > host->bounce_buf_size);

		if (host->dram_access_quirk)

			meson_mmc_copy_buffer(host, data, xfer_bytes, false);

		else

			sg_copy_from_buffer(data->sg, data->sg_len,

					    host->bounce_buf, xfer_bytes);

	}



	next_cmd = meson_mmc_get_next_command(cmd);

drivers/mmc/host/sdhci-of-at91.c

+11 −11
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/delay.h>

#include <linux/err.h>

#include <linux/io.h>

#include <linux/iopoll.h>

#include <linux/kernel.h>

#include <linux/mmc/host.h>

#include <linux/mmc/slot-gpio.h>
@@ -61,7 +62,6 @@ static void sdhci_at91_set_force_card_detect(struct sdhci_host *host) 
static void sdhci_at91_set_clock(struct sdhci_host *host, unsigned int clock)

{

	u16 clk;

	unsigned long timeout;



	host->mmc->actual_clock = 0;
@@ -86,17 +86,12 @@ static void sdhci_at91_set_clock(struct sdhci_host *host, unsigned int clock) 
	sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);



	/* Wait max 20 ms */

	timeout = 20;

	while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))

		& SDHCI_CLOCK_INT_STABLE)) {

		if (timeout == 0) {

	if (read_poll_timeout(sdhci_readw, clk, (clk & SDHCI_CLOCK_INT_STABLE),

			      1000, 20000, false, host, SDHCI_CLOCK_CONTROL)) {

		pr_err("%s: Internal clock never stabilised.\n",

		       mmc_hostname(host->mmc));

		return;

	}

		timeout--;

		mdelay(1);

	}



	clk |= SDHCI_CLOCK_CARD_EN;

	sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
@@ -114,6 +109,7 @@ static void sdhci_at91_reset(struct sdhci_host *host, u8 mask) 
{

	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);

	struct sdhci_at91_priv *priv = sdhci_pltfm_priv(pltfm_host);

	unsigned int tmp;



	sdhci_reset(host, mask);
@@ -126,6 +122,10 @@ static void sdhci_at91_reset(struct sdhci_host *host, u8 mask) 


		sdhci_writel(host, calcr | SDMMC_CALCR_ALWYSON | SDMMC_CALCR_EN,

			     SDMMC_CALCR);



		if (read_poll_timeout(sdhci_readl, tmp, !(tmp & SDMMC_CALCR_EN),

				      10, 20000, false, host, SDMMC_CALCR))

			dev_err(mmc_dev(host->mmc), "Failed to calibrate\n");

	}

}