Re: [PATCH v4 3/3] mmc: Add driver for LiteX's LiteSDCard interface

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Joel,

On Fri, Dec 10, 2021 at 09:54:30AM -0500, Gabriel Somlo wrote:
> LiteX (https://github.com/enjoy-digital/litex) is a SoC framework
> that targets FPGAs. LiteSDCard is a small footprint, configurable
> SDCard core commonly used in LiteX designs.
> 
> The driver was first written in May 2020 and has been maintained
> cooperatively by the LiteX community. Thanks to all contributors!
> 
> Co-developed-by: Kamil Rakoczy <krakoczy@xxxxxxxxxxxx>
> Signed-off-by: Kamil Rakoczy <krakoczy@xxxxxxxxxxxx>
> Co-developed-by: Maciej Dudek <mdudek@xxxxxxxxxxxxxxxxxxxxxxxx>
> Signed-off-by: Maciej Dudek <mdudek@xxxxxxxxxxxxxxxxxxxxxxxx>
> Co-developed-by: Paul Mackerras <paulus@xxxxxxxxxx>
> Signed-off-by: Paul Mackerras <paulus@xxxxxxxxxx>
> Signed-off-by: Gabriel Somlo <gsomlo@xxxxxxxxx>
> Cc: Mateusz Holenko <mholenko@xxxxxxxxxxxx>
> Cc: Karol Gugala <kgugala@xxxxxxxxxxxx>
> Cc: Joel Stanley <joel@xxxxxxxxx>
> Cc: Stafford Horne <shorne@xxxxxxxxx>
> Cc: Geert Uytterhoeven <geert@xxxxxxxxxxxxxx>
> Cc: David Abdurachmanov <david.abdurachmanov@xxxxxxxxxx>
> Cc: Florent Kermarrec <florent@xxxxxxxxxxxxxxxx>
> ---
> 
> New in v4:
>   - struct litex_mmc_host fields re-ordered so that `pahole` reports
>     no holes on either 32- or 64-bit builds
>   - litex_mmc_set_bus_width() now encapsulates check for
>     host->is_bus_width_set
>   - litex_mmc_request() - factor out dma data setup into separate
>     helper function: litex_mmc_do_dma()
> 
> > New in v3:
> >   - fixed function signature (no line split), and naming (litex_mmc_*)
> >   - more informative MODULE_AUTHOR() entries
> >     - also added matching "Copyright" entries in file header
> >   - fixed description and dependencies in Kconfig
> >   - removed magic constants
> >   - removed litex_map_status(), have sdcard_wait_done() return *real*
> >     error codes directly instead.
> >   - streamlined litex_mmc_reponse_len()
> >   - call litex_mmc_set_bus_width() only once, and ensure it returns
> >     correct error code(s)
> >   - use readx_poll_timeout() -- more concise -- instead of
> >     read_poll_timeout()
> >   - use dev_err() in litex_mmc_send_cmd() (instead of pr_err())
> >   - litex_mmc_setclk() will update host->clock before returning
> >   - separate irq initialization into its own function,
> >     litex_mmc_irq_init()
> >   - document rationale for f_min, f_max
> >   - use dmam_alloc_coherent(), which simplifies cleanup significantly
> >   - bump dma_set_mask_and_coherent() to 64-bits on suitable
> >     architectures
> >   - clock source picked up from dedicated DT clock reference property
> >   - remove gpio card-detect logic (needs testing and a dt binding
> >     example before being eligible for upstream inclusion)
> >   - large `if (data) { ... }` block in litex_mmc_request() left as-is,
> >     there are too many variables shared with the rest of the parent
> >     function body to easily separate (e.g., `len`, `transfer`, `direct`).
> >     If this is indeed a blocker, I can take another shot at refactoring
> >     it in a future revision!
> 
>  drivers/mmc/host/Kconfig     |   9 +
>  drivers/mmc/host/Makefile    |   1 +
>  drivers/mmc/host/litex_mmc.c | 654 +++++++++++++++++++++++++++++++++++
>  3 files changed, 664 insertions(+)
>  create mode 100644 drivers/mmc/host/litex_mmc.c
> 
> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> index 5af8494c31b5..c1b66d06d1c9 100644
> --- a/drivers/mmc/host/Kconfig
> +++ b/drivers/mmc/host/Kconfig
> @@ -1093,3 +1093,12 @@ config MMC_OWL
>  
>  config MMC_SDHCI_EXTERNAL_DMA
>  	bool
> +
> +config MMC_LITEX
> +	tristate "LiteX MMC Host Controller support"

I remembered I still owe you an answer on whether this was ever
successfully tested as a module: The answer is *yes* -- if configured
as a loadable module, it loads OK with modprobe, works fine, and can
be unloaded (with `modprobe -r`) and re-loaded indefinitely.

Thanks again,
--Gabriel

> +	depends on OF
> +	depends on PPC_MICROWATT || LITEX || COMPILE_TEST
> +	help
> +	  This selects support for the MMC Host Controller found in LiteX SoCs.
> +
> +	  If unsure, say N.
> diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
> index ea36d379bd3c..4e4ceb32c4b4 100644
> --- a/drivers/mmc/host/Makefile
> +++ b/drivers/mmc/host/Makefile
> @@ -101,6 +101,7 @@ obj-$(CONFIG_MMC_CQHCI)			+= cqhci.o
>  cqhci-y					+= cqhci-core.o
>  cqhci-$(CONFIG_MMC_CRYPTO)		+= cqhci-crypto.o
>  obj-$(CONFIG_MMC_HSQ)			+= mmc_hsq.o
> +obj-$(CONFIG_MMC_LITEX)			+= litex_mmc.o
>  
>  ifeq ($(CONFIG_CB710_DEBUG),y)
>  	CFLAGS-cb710-mmc	+= -DDEBUG
> diff --git a/drivers/mmc/host/litex_mmc.c b/drivers/mmc/host/litex_mmc.c
> new file mode 100644
> index 000000000000..5609ab42539d
> --- /dev/null
> +++ b/drivers/mmc/host/litex_mmc.c
> @@ -0,0 +1,654 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * LiteX LiteSDCard driver
> + *
> + * Copyright (C) 2019-2020 Antmicro <contact@xxxxxxxxxxxx>
> + * Copyright (C) 2019-2020 Kamil Rakoczy <krakoczy@xxxxxxxxxxxx>
> + * Copyright (C) 2019-2020 Maciej Dudek <mdudek@xxxxxxxxxxxxxxxxxxxxxxxx>
> + * Copyright (C) 2020 Paul Mackerras <paulus@xxxxxxxxxx>
> + * Copyright (C) 2020-2021 Gabriel Somlo <gsomlo@xxxxxxxxx>
> + *
> + */
> +
> +#include <linux/module.h>
> +#include <linux/litex.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <linux/clk.h>
> +#include <linux/interrupt.h>
> +#include <linux/iopoll.h>
> +#include <linux/mmc/sd.h>
> +#include <linux/mmc/mmc.h>
> +#include <linux/mmc/host.h>
> +#include <linux/delay.h>
> +#include <linux/dma-mapping.h>
> +
> +#define LITEX_PHY_CARDDETECT  0x00
> +#define LITEX_PHY_CLOCKERDIV  0x04
> +#define LITEX_PHY_INITIALIZE  0x08
> +#define LITEX_PHY_WRITESTATUS 0x0C
> +#define LITEX_CORE_CMDARG     0x00
> +#define LITEX_CORE_CMDCMD     0x04
> +#define LITEX_CORE_CMDSND     0x08
> +#define LITEX_CORE_CMDRSP     0x0C
> +#define LITEX_CORE_CMDEVT     0x1C
> +#define LITEX_CORE_DATAEVT    0x20
> +#define LITEX_CORE_BLKLEN     0x24
> +#define LITEX_CORE_BLKCNT     0x28
> +#define LITEX_BLK2MEM_BASE    0x00
> +#define LITEX_BLK2MEM_LEN     0x08
> +#define LITEX_BLK2MEM_ENA     0x0C
> +#define LITEX_BLK2MEM_DONE    0x10
> +#define LITEX_BLK2MEM_LOOP    0x14
> +#define LITEX_MEM2BLK_BASE    0x00
> +#define LITEX_MEM2BLK_LEN     0x08
> +#define LITEX_MEM2BLK_ENA     0x0C
> +#define LITEX_MEM2BLK_DONE    0x10
> +#define LITEX_MEM2BLK_LOOP    0x14
> +#define LITEX_MEM2BLK         0x18
> +#define LITEX_IRQ_STATUS      0x00
> +#define LITEX_IRQ_PENDING     0x04
> +#define LITEX_IRQ_ENABLE      0x08
> +
> +#define SDCARD_CTRL_DATA_TRANSFER_NONE  0
> +#define SDCARD_CTRL_DATA_TRANSFER_READ  1
> +#define SDCARD_CTRL_DATA_TRANSFER_WRITE 2
> +
> +#define SDCARD_CTRL_RESPONSE_NONE       0
> +#define SDCARD_CTRL_RESPONSE_SHORT      1
> +#define SDCARD_CTRL_RESPONSE_LONG       2
> +#define SDCARD_CTRL_RESPONSE_SHORT_BUSY 3
> +
> +#define SD_BIT_DONE    BIT(0)
> +#define SD_BIT_WR_ERR  BIT(1)
> +#define SD_BIT_TIMEOUT BIT(2)
> +#define SD_BIT_CRC_ERR BIT(3)
> +
> +#define SD_SLEEP_US       5
> +#define SD_TIMEOUT_US 20000
> +
> +#define SDIRQ_CARD_DETECT    1
> +#define SDIRQ_SD_TO_MEM_DONE 2
> +#define SDIRQ_MEM_TO_SD_DONE 4
> +#define SDIRQ_CMD_DONE       8
> +
> +struct litex_mmc_host {
> +	struct mmc_host *mmc;
> +	struct platform_device *dev;
> +
> +	void __iomem *sdphy;
> +	void __iomem *sdcore;
> +	void __iomem *sdreader;
> +	void __iomem *sdwriter;
> +	void __iomem *sdirq;
> +
> +	void *buffer;
> +	size_t buf_size;
> +	dma_addr_t dma;
> +
> +	struct completion cmd_done;
> +	int irq;
> +
> +	unsigned int ref_clk;
> +	unsigned int sd_clk;
> +
> +	u32 resp[4];
> +	u16 rca;
> +
> +	bool is_bus_width_set;
> +	bool app_cmd;
> +};
> +
> +static int litex_mmc_sdcard_wait_done(void __iomem *reg)
> +{
> +	u8 evt;
> +	int ret;
> +
> +	ret = readx_poll_timeout(litex_read8, reg, evt, (evt & SD_BIT_DONE),
> +				 SD_SLEEP_US, SD_TIMEOUT_US);
> +	if (ret || (evt & SD_BIT_TIMEOUT))
> +		return -ETIMEDOUT;
> +	if (evt == SD_BIT_DONE)
> +		return 0;
> +	if (evt & SD_BIT_WR_ERR)
> +		return -EIO;
> +	if (evt & SD_BIT_CRC_ERR)
> +		return -EILSEQ;
> +	pr_err("%s: unknown error evt=%x\n", __func__, evt);
> +	return -EINVAL;
> +}
> +
> +static int litex_mmc_send_cmd(struct litex_mmc_host *host,
> +			      u8 cmd, u32 arg, u8 response_len, u8 transfer)
> +{
> +	struct device *dev = mmc_dev(host->mmc);
> +	void __iomem *reg;
> +	int ret;
> +	u8 evt;
> +
> +	litex_write32(host->sdcore + LITEX_CORE_CMDARG, arg);
> +	litex_write32(host->sdcore + LITEX_CORE_CMDCMD,
> +		      cmd << 8 | transfer << 5 | response_len);
> +	litex_write8(host->sdcore + LITEX_CORE_CMDSND, 1);
> +
> +	/* Wait for an interrupt if we have an interrupt and either there is
> +	 * data to be transferred, or if the card can report busy via DAT0.
> +	 */
> +	if (host->irq > 0 &&
> +	    (transfer != SDCARD_CTRL_DATA_TRANSFER_NONE ||
> +	     response_len == SDCARD_CTRL_RESPONSE_SHORT_BUSY)) {
> +		reinit_completion(&host->cmd_done);
> +		litex_write32(host->sdirq + LITEX_IRQ_ENABLE,
> +			      SDIRQ_CMD_DONE | SDIRQ_CARD_DETECT);
> +		wait_for_completion(&host->cmd_done);
> +	}
> +
> +	ret = litex_mmc_sdcard_wait_done(host->sdcore + LITEX_CORE_CMDEVT);
> +	if (ret) {
> +		dev_err(dev, "Command (cmd %d) error, status %d\n", cmd, ret);
> +		return ret;
> +	}
> +
> +	if (response_len != SDCARD_CTRL_RESPONSE_NONE) {
> +		int i;
> +
> +		reg = host->sdcore + LITEX_CORE_CMDRSP;
> +		for (i = 0; i < 4; i++) {
> +			host->resp[i] = litex_read32(reg);
> +			reg += sizeof(u32);
> +		}
> +	}
> +
> +	if (!host->app_cmd && cmd == SD_SEND_RELATIVE_ADDR)
> +		host->rca = (host->resp[3] >> 16) & 0xffff;
> +
> +	host->app_cmd = (cmd == MMC_APP_CMD);
> +
> +	if (transfer == SDCARD_CTRL_DATA_TRANSFER_NONE)
> +		return ret; /* OK from prior litex_mmc_sdcard_wait_done() */
> +
> +	ret = litex_mmc_sdcard_wait_done(host->sdcore + LITEX_CORE_DATAEVT);
> +	if (ret) {
> +		dev_err(dev, "Data xfer (cmd %d) error, status %d\n", cmd, ret);
> +		return ret;
> +	}
> +
> +	/* wait for completion of (read or write) DMA transfer */
> +	reg = (transfer == SDCARD_CTRL_DATA_TRANSFER_READ) ?
> +		host->sdreader + LITEX_BLK2MEM_DONE :
> +		host->sdwriter + LITEX_MEM2BLK_DONE;
> +	ret = readx_poll_timeout(litex_read8, reg, evt, (evt & SD_BIT_DONE),
> +				 SD_SLEEP_US, SD_TIMEOUT_US);
> +	if (ret)
> +		dev_err(dev, "DMA timeout (cmd %d)\n", cmd);
> +
> +	return ret;
> +}
> +
> +static int litex_mmc_send_app_cmd(struct litex_mmc_host *host)
> +{
> +	return litex_mmc_send_cmd(host, MMC_APP_CMD, host->rca << 16,
> +				  SDCARD_CTRL_RESPONSE_SHORT,
> +				  SDCARD_CTRL_DATA_TRANSFER_NONE);
> +}
> +
> +static int litex_mmc_send_set_bus_w_cmd(struct litex_mmc_host *host, u32 width)
> +{
> +	return litex_mmc_send_cmd(host, SD_APP_SET_BUS_WIDTH, width,
> +				  SDCARD_CTRL_RESPONSE_SHORT,
> +				  SDCARD_CTRL_DATA_TRANSFER_NONE);
> +}
> +
> +static int litex_mmc_set_bus_width(struct litex_mmc_host *host)
> +{
> +	bool app_cmd_sent;
> +	int ret;
> +
> +	if (host->is_bus_width_set)
> +		return 0;
> +
> +	/* ensure 'app_cmd' precedes 'app_set_bus_width_cmd' */
> +	app_cmd_sent = host->app_cmd; /* was preceding command app_cmd? */
> +	if (!app_cmd_sent) {
> +		ret = litex_mmc_send_app_cmd(host);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	/* litesdcard only supports 4-bit bus width */
> +	ret = litex_mmc_send_set_bus_w_cmd(host, MMC_BUS_WIDTH_4);
> +	if (ret)
> +		return ret;
> +
> +	/* re-send 'app_cmd' if necessary */
> +	if (app_cmd_sent) {
> +		ret = litex_mmc_send_app_cmd(host);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	host->is_bus_width_set = true;
> +
> +	return 0;
> +}
> +
> +static int litex_mmc_get_cd(struct mmc_host *mmc)
> +{
> +	struct litex_mmc_host *host = mmc_priv(mmc);
> +	int ret;
> +
> +	if (!mmc_card_is_removable(mmc))
> +		return 1;
> +
> +	ret = !litex_read8(host->sdphy + LITEX_PHY_CARDDETECT);
> +
> +	/* ensure bus width will be set (again) upon card (re)insertion */
> +	if (ret == 0)
> +		host->is_bus_width_set = false;
> +
> +	return ret;
> +}
> +
> +static irqreturn_t litex_mmc_interrupt(int irq, void *arg)
> +{
> +	struct mmc_host *mmc = arg;
> +	struct litex_mmc_host *host = mmc_priv(mmc);
> +	u32 pending = litex_read32(host->sdirq + LITEX_IRQ_PENDING);
> +
> +	/* Check for card change interrupt */
> +	if (pending & SDIRQ_CARD_DETECT) {
> +		litex_write32(host->sdirq + LITEX_IRQ_PENDING,
> +			      SDIRQ_CARD_DETECT);
> +		mmc_detect_change(mmc, msecs_to_jiffies(10));
> +	}
> +
> +	/* Check for command completed */
> +	if (pending & SDIRQ_CMD_DONE) {
> +		/* Disable it so it doesn't keep interrupting */
> +		litex_write32(host->sdirq + LITEX_IRQ_ENABLE,
> +			      SDIRQ_CARD_DETECT);
> +		complete(&host->cmd_done);
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static u32 litex_mmc_response_len(struct mmc_command *cmd)
> +{
> +	if (cmd->flags & MMC_RSP_136)
> +		return SDCARD_CTRL_RESPONSE_LONG;
> +	if (!(cmd->flags & MMC_RSP_PRESENT))
> +		return SDCARD_CTRL_RESPONSE_NONE;
> +	if (cmd->flags & MMC_RSP_BUSY)
> +		return SDCARD_CTRL_RESPONSE_SHORT_BUSY;
> +	return SDCARD_CTRL_RESPONSE_SHORT;
> +}
> +
> +static void litex_mmc_do_dma(struct litex_mmc_host *host, struct mmc_data *data,
> +			     unsigned int *len, bool *direct, u8 *transfer)
> +{
> +	struct device *dev = mmc_dev(host->mmc);
> +	dma_addr_t dma;
> +	int sg_count;
> +
> +	/* Try to DMA directly to/from the data buffer.
> +	 * We can do that if the buffer can be mapped for DMA
> +	 * in one contiguous chunk.
> +	 */
> +	dma = host->dma;
> +	*len = data->blksz * data->blocks;
> +	sg_count = dma_map_sg(dev, data->sg, data->sg_len,
> +			      mmc_get_dma_dir(data));
> +	if (sg_count == 1) {
> +		dma = sg_dma_address(data->sg);
> +		*len = sg_dma_len(data->sg);
> +		*direct = true;
> +	} else if (*len > host->buf_size)
> +		*len = host->buf_size;
> +
> +	if (data->flags & MMC_DATA_READ) {
> +		litex_write8(host->sdreader + LITEX_BLK2MEM_ENA, 0);
> +		litex_write64(host->sdreader + LITEX_BLK2MEM_BASE, dma);
> +		litex_write32(host->sdreader + LITEX_BLK2MEM_LEN, *len);
> +		litex_write8(host->sdreader + LITEX_BLK2MEM_ENA, 1);
> +		*transfer = SDCARD_CTRL_DATA_TRANSFER_READ;
> +	} else if (data->flags & MMC_DATA_WRITE) {
> +		if (!*direct)
> +			sg_copy_to_buffer(data->sg, data->sg_len,
> +					  host->buffer, *len);
> +		litex_write8(host->sdwriter + LITEX_MEM2BLK_ENA, 0);
> +		litex_write64(host->sdwriter + LITEX_MEM2BLK_BASE, dma);
> +		litex_write32(host->sdwriter + LITEX_MEM2BLK_LEN, *len);
> +		litex_write8(host->sdwriter + LITEX_MEM2BLK_ENA, 1);
> +		*transfer = SDCARD_CTRL_DATA_TRANSFER_WRITE;
> +	} else {
> +		dev_warn(dev, "Data present w/o read or write flag.\n");
> +		/* Continue: set cmd status, mark req done */
> +	}
> +
> +	litex_write16(host->sdcore + LITEX_CORE_BLKLEN, data->blksz);
> +	litex_write32(host->sdcore + LITEX_CORE_BLKCNT, data->blocks);
> +}
> +
> +static void litex_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
> +{
> +	struct litex_mmc_host *host = mmc_priv(mmc);
> +	struct device *dev = mmc_dev(mmc);
> +	struct mmc_command *cmd = mrq->cmd;
> +	struct mmc_command *sbc = mrq->sbc;
> +	struct mmc_data *data = mrq->data;
> +	struct mmc_command *stop = mrq->stop;
> +	unsigned int retries = cmd->retries;
> +	unsigned int len = 0;
> +	bool direct = false;
> +	u32 response_len = litex_mmc_response_len(cmd);
> +	u8 transfer = SDCARD_CTRL_DATA_TRANSFER_NONE;
> +
> +	/* First check that the card is still there */
> +	if (!litex_mmc_get_cd(mmc)) {
> +		cmd->error = -ENOMEDIUM;
> +		mmc_request_done(mmc, mrq);
> +		return;
> +	}
> +
> +	/* Send set-block-count command if needed */
> +	if (sbc) {
> +		sbc->error = litex_mmc_send_cmd(host, sbc->opcode, sbc->arg,
> +						litex_mmc_response_len(sbc),
> +						SDCARD_CTRL_DATA_TRANSFER_NONE);
> +		if (sbc->error) {
> +			host->is_bus_width_set = false;
> +			mmc_request_done(mmc, mrq);
> +			return;
> +		}
> +	}
> +
> +	if (data) {
> +		/* LiteSDCard only supports 4-bit bus width; therefore, we MUST
> +		 * inject a SET_BUS_WIDTH (acmd6) before the very first data
> +		 * transfer, earlier than when the mmc subsystem would normally
> +		 * get around to it!
> +		 */
> +		cmd->error = litex_mmc_set_bus_width(host);
> +		if (cmd->error) {
> +			dev_err(dev, "Can't set bus width!\n");
> +			mmc_request_done(mmc, mrq);
> +			return;
> +		}
> +
> +		litex_mmc_do_dma(host, data, &len, &direct, &transfer);
> +	}
> +
> +	do {
> +		cmd->error = litex_mmc_send_cmd(host, cmd->opcode, cmd->arg,
> +						response_len, transfer);
> +	} while (cmd->error && retries-- > 0);
> +
> +	if (cmd->error) {
> +		/* card may be gone; don't assume bus width is still set */
> +		host->is_bus_width_set = false;
> +	}
> +
> +	if (response_len == SDCARD_CTRL_RESPONSE_SHORT) {
> +		/* pull short response fields from appropriate host registers */
> +		cmd->resp[0] = host->resp[3];
> +		cmd->resp[1] = host->resp[2] & 0xFF;
> +	} else if (response_len == SDCARD_CTRL_RESPONSE_LONG) {
> +		cmd->resp[0] = host->resp[0];
> +		cmd->resp[1] = host->resp[1];
> +		cmd->resp[2] = host->resp[2];
> +		cmd->resp[3] = host->resp[3];
> +	}
> +
> +	/* Send stop-transmission command if required */
> +	if (stop && (cmd->error || !sbc)) {
> +		stop->error = litex_mmc_send_cmd(host, stop->opcode, stop->arg,
> +						litex_mmc_response_len(stop),
> +						SDCARD_CTRL_DATA_TRANSFER_NONE);
> +		if (stop->error)
> +			host->is_bus_width_set = false;
> +	}
> +
> +	if (data) {
> +		dma_unmap_sg(dev, data->sg, data->sg_len,
> +			     mmc_get_dma_dir(data));
> +	}
> +
> +	if (!cmd->error && transfer != SDCARD_CTRL_DATA_TRANSFER_NONE) {
> +		data->bytes_xfered = min(len, mmc->max_req_size);
> +		if (transfer == SDCARD_CTRL_DATA_TRANSFER_READ && !direct) {
> +			sg_copy_from_buffer(data->sg, sg_nents(data->sg),
> +					    host->buffer, data->bytes_xfered);
> +		}
> +	}
> +
> +	mmc_request_done(mmc, mrq);
> +}
> +
> +static void litex_mmc_setclk(struct litex_mmc_host *host, unsigned int freq)
> +{
> +	struct device *dev = mmc_dev(host->mmc);
> +	u32 div;
> +
> +	div = freq ? host->ref_clk / freq : 256U;
> +	div = roundup_pow_of_two(div);
> +	div = min(max(div, 2U), 256U);
> +	dev_dbg(dev, "sd_clk_freq=%d: set to %d via div=%d\n",
> +		freq, host->ref_clk / div, div);
> +	litex_write16(host->sdphy + LITEX_PHY_CLOCKERDIV, div);
> +	host->sd_clk = freq;
> +}
> +
> +static void litex_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
> +{
> +	struct litex_mmc_host *host = mmc_priv(mmc);
> +
> +	/* NOTE: Ignore any ios->bus_width updates; they occur right after
> +	 * the mmc core sends its own acmd6 bus-width change notification,
> +	 * which is redundant since we snoop on the command flow and inject
> +	 * an early acmd6 before the first data transfer command is sent!
> +	 */
> +
> +	/* update sd_clk */
> +	if (ios->clock != host->sd_clk)
> +		litex_mmc_setclk(host, ios->clock);
> +}
> +
> +static const struct mmc_host_ops litex_mmc_ops = {
> +	.get_cd = litex_mmc_get_cd,
> +	.request = litex_mmc_request,
> +	.set_ios = litex_mmc_set_ios,
> +};
> +
> +static int litex_mmc_irq_init(struct litex_mmc_host *host)
> +{
> +	struct device *dev = mmc_dev(host->mmc);
> +	int ret;
> +
> +	host->irq = platform_get_irq_optional(host->dev, 0);
> +	if (host->irq <= 0) {
> +		dev_warn(dev, "Failed to get IRQ, using polling\n");
> +		goto use_polling;
> +	}
> +
> +	host->sdirq = devm_platform_ioremap_resource_byname(host->dev, "irq");
> +	if (IS_ERR(host->sdirq))
> +		return PTR_ERR(host->sdirq);
> +
> +	ret = request_irq(host->irq, litex_mmc_interrupt, 0,
> +			  "litex-mmc", host->mmc);
> +	if (ret < 0) {
> +		dev_warn(dev, "IRQ request error %d, using polling\n", ret);
> +		goto use_polling;
> +	}
> +
> +	/* clear & enable card-change interrupts */
> +	litex_write32(host->sdirq + LITEX_IRQ_PENDING, SDIRQ_CARD_DETECT);
> +	litex_write32(host->sdirq + LITEX_IRQ_ENABLE, SDIRQ_CARD_DETECT);
> +
> +	return 0;
> +
> +use_polling:
> +	host->mmc->caps |= MMC_CAP_NEEDS_POLL;
> +	host->irq = 0;
> +	return 0;
> +}
> +
> +static int litex_mmc_probe(struct platform_device *pdev)
> +{
> +	struct litex_mmc_host *host;
> +	struct mmc_host *mmc;
> +	struct clk *clk;
> +	int ret;
> +
> +	mmc = mmc_alloc_host(sizeof(struct litex_mmc_host), &pdev->dev);
> +	/* NOTE: defaults to max_[req,seg]_size=PAGE_SIZE, max_blk_size=512,
> +	 * and max_blk_count accordingly set to 8;
> +	 * If for some reason we need to modify max_blk_count, we must also
> +	 * re-calculate `max_[req,seg]_size = max_blk_size * max_blk_count;`
> +	 */
> +	if (!mmc)
> +		return -ENOMEM;
> +
> +	host = mmc_priv(mmc);
> +	host->mmc = mmc;
> +	host->dev = pdev;
> +
> +	/* initialize clock source */
> +	clk = devm_clk_get(&pdev->dev, NULL);
> +	if (IS_ERR(clk)) {
> +		ret = dev_err_probe(&pdev->dev,
> +				    PTR_ERR(clk), "can't get clock\n");
> +		goto err;
> +	}
> +	host->ref_clk = clk_get_rate(clk);
> +	host->sd_clk = 0;
> +
> +	/* LiteSDCard only supports 4-bit bus width; therefore, we MUST inject
> +	 * a SET_BUS_WIDTH (acmd6) before the very first data transfer, earlier
> +	 * than when the mmc subsystem would normally get around to it!
> +	 */
> +	host->is_bus_width_set = false;
> +	host->app_cmd = false;
> +
> +#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
> +	/* increase from default 32 on 64-bit-DMA capable architectures */
> +	ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
> +	if (ret)
> +		goto err;
> +#endif
> +
> +	host->buf_size = mmc->max_req_size * 2;
> +	host->buffer = dmam_alloc_coherent(&pdev->dev, host->buf_size,
> +					   &host->dma, GFP_DMA);
> +	if (host->buffer == NULL) {
> +		ret = -ENOMEM;
> +		goto err;
> +	}
> +
> +	host->sdphy = devm_platform_ioremap_resource_byname(pdev, "phy");
> +	if (IS_ERR(host->sdphy)) {
> +		ret = PTR_ERR(host->sdphy);
> +		goto err;
> +	}
> +
> +	host->sdcore = devm_platform_ioremap_resource_byname(pdev, "core");
> +	if (IS_ERR(host->sdcore)) {
> +		ret = PTR_ERR(host->sdcore);
> +		goto err;
> +	}
> +
> +	host->sdreader = devm_platform_ioremap_resource_byname(pdev, "reader");
> +	if (IS_ERR(host->sdreader)) {
> +		ret = PTR_ERR(host->sdreader);
> +		goto err;
> +	}
> +
> +	host->sdwriter = devm_platform_ioremap_resource_byname(pdev, "writer");
> +	if (IS_ERR(host->sdwriter)) {
> +		ret = PTR_ERR(host->sdwriter);
> +		goto err;
> +	}
> +
> +	/* ensure DMA bus masters are disabled */
> +	litex_write8(host->sdreader + LITEX_BLK2MEM_ENA, 0);
> +	litex_write8(host->sdwriter + LITEX_MEM2BLK_ENA, 0);
> +
> +	init_completion(&host->cmd_done);
> +	ret = litex_mmc_irq_init(host);
> +	if (ret)
> +		goto err;
> +
> +	mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
> +	mmc->ops = &litex_mmc_ops;
> +
> +	/* set default sd_clk frequency range based on empirical observations
> +	 * of LiteSDCard gateware behavior on typical SDCard media
> +	 */
> +	mmc->f_min = 12.5e6;
> +	mmc->f_max = 50e6;
> +
> +	ret = mmc_of_parse(mmc);
> +	if (ret)
> +		goto err;
> +
> +	/* force 4-bit bus_width (only width supported by hardware) */
> +	mmc->caps &= ~MMC_CAP_8_BIT_DATA;
> +	mmc->caps |= MMC_CAP_4_BIT_DATA;
> +
> +	/* set default capabilities */
> +	mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY |
> +		     MMC_CAP_DRIVER_TYPE_D |
> +		     MMC_CAP_CMD23;
> +	mmc->caps2 |= MMC_CAP2_NO_WRITE_PROTECT |
> +		      MMC_CAP2_FULL_PWR_CYCLE |
> +		      MMC_CAP2_NO_SDIO;
> +
> +	platform_set_drvdata(pdev, host);
> +
> +	ret = mmc_add_host(mmc);
> +	if (ret < 0)
> +		goto err;
> +
> +	return 0;
> +
> +err:
> +	mmc_free_host(mmc);
> +	return ret;
> +}
> +
> +static int litex_mmc_remove(struct platform_device *pdev)
> +{
> +	struct litex_mmc_host *host = dev_get_drvdata(&pdev->dev);
> +
> +	if (host->irq > 0)
> +		free_irq(host->irq, host->mmc);
> +	mmc_remove_host(host->mmc);
> +	mmc_free_host(host->mmc);
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id litex_match[] = {
> +	{ .compatible = "litex,mmc" },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, litex_match);
> +
> +static struct platform_driver litex_mmc_driver = {
> +	.probe = litex_mmc_probe,
> +	.remove = litex_mmc_remove,
> +	.driver = {
> +		.name = "litex-mmc",
> +		.of_match_table = of_match_ptr(litex_match),
> +	},
> +};
> +module_platform_driver(litex_mmc_driver);
> +
> +MODULE_DESCRIPTION("LiteX SDCard driver");
> +MODULE_AUTHOR("Antmicro <contact@xxxxxxxxxxxx>");
> +MODULE_AUTHOR("Kamil Rakoczy <krakoczy@xxxxxxxxxxxx>");
> +MODULE_AUTHOR("Maciej Dudek <mdudek@xxxxxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_AUTHOR("Paul Mackerras <paulus@xxxxxxxxxx>");
> +MODULE_AUTHOR("Gabriel Somlo <gsomlo@xxxxxxxxx>");
> +MODULE_LICENSE("GPL v2");
> -- 
> 2.31.1
> 



[Index of Archives]     [Linux Memonry Technology]     [Linux USB Devel]     [Linux Media]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux