Linux-mmc Archive on lore.kernel.org
 help / color / Atom feed
* [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap
@ 2020-01-06 11:01 Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 01/11] dt-bindings: sdhci-omap: Add properties for using external dma Faiz Abbas
                   ` (10 more replies)
  0 siblings, 11 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

The following add driver patches for porting TI's am335x and am437x devices to
the sdhci-omap driver.

Patches 1-4 Add Support for external DMA to the sdhci driver.

Patches 5-7 refactor the sdhci_set_timeout() function and use it disable
data timeout interrupt for erase commands

Patches 8-9 port the ti,needs-special-reset property from omap_hsmmc driver.

Patches 10-11 add new compatibles for am335x and am43xx devices to the
sdhci-omap driver.

DT changes will be posted as a separate series.

Tested on: am335x-evm, am335x-boneblack, am335x-bonegreen-wireless,
am335x-sk, am335x-bone, am437x-idk, am43xx-gp-evm, am43xx-epos-evm.

I need some help with testing all other am335x variants and SDIO cards.

Here's a branch for testing: https://github.com/faizinator/linux/tree/sdhci-omap_v4_2

RESEND ALERT: I sent these patches from a new computer yesterday but non
of them appeared in any of the mailing lists. Apologies if you receive a
duplicate series. Please ignore the previous one.

v4:
1. Made the factoring out of initialize_data, block_info and mrqs_done as a
   separate patch
2. Replaced the patch introducing the quirk to disable DTO during erase
   operations to a set_timeout() callback in sdhci-omap
3. Ported the ti,needs-special-reset property from omap_hsmmc to sdhci-omap.
4. Minor style changes.

v3:
1. Dropped patch 1 because the tasklet was removed by Adrian in an
   earlier series.
2. Added dma bindings in sdhci-omap as optional properties.
3. Rebased on top of latest mainline.

v2:
1. sdhci is using two bottom halves. One threaded_rq for card detect and a
   tasklet for finishing mmc requests. Patch 1 removes the tasklet and
   moves its function to the threaded_irq. This enables me to
   terminate_sync() in sdhci_request_done()

2. Factored out common code for between the normal adn external dma case

3. Using existing API sdhci_data_timeout_irq for disabling DTO during
   erase commands.

4. Fixed subject line for dt-bindings patch.

Chunyan Zhang (3):
  dt-bindings: sdhci-omap: Add properties for using external dma
  mmc: sdhci: add support for using external DMA devices
  mmc: sdhci-omap: Add using external dma

Faiz Abbas (8):
  mmc: sdhci: Factor out some operations set to their own functions
  mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static
  mmc: sdhci: Refactor sdhci_set_timeout()
  mmc: sdhci-omap: Disable data timeout interrupt during erase
  dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset
    property
  mmc: sdhci-omap: Add ti,needs-special-reset property
  dt-bindings: sdhci-omap: Add am335x and am437x specific bindings
  mmc: sdhci-omap: Add am335x and am437x specific compatibles

 .../devicetree/bindings/mmc/sdhci-omap.txt    |  12 +
 drivers/mmc/host/Kconfig                      |   4 +
 drivers/mmc/host/sdhci-omap.c                 |  61 ++-
 drivers/mmc/host/sdhci.c                      | 355 +++++++++++++++---
 drivers/mmc/host/sdhci.h                      |  10 +
 5 files changed, 384 insertions(+), 58 deletions(-)

-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 01/11] dt-bindings: sdhci-omap: Add properties for using external dma
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions Faiz Abbas
                   ` (9 subsequent siblings)
  10 siblings, 0 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

From: Chunyan Zhang <zhang.chunyan@linaro.org>

sdhci-omap can support both external dma controller via dmaengine
framework as well as ADMA which standard SD host controller
provides. Add binding documentation for these external dma properties.

Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---
 Documentation/devicetree/bindings/mmc/sdhci-omap.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
index 72c4dec7e1db..97efb01617dd 100644
--- a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
+++ b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
@@ -15,6 +15,13 @@ Required properties:
 		 "hs200_1_8v",
 - pinctrl-<n> : Pinctrl states as described in bindings/pinctrl/pinctrl-bindings.txt
 
+Optional properties:
+- dmas:		List of DMA specifiers with the controller specific format as described
+		in the generic DMA client binding. A tx and rx specifier is required.
+- dma-names:	List of DMA request names. These strings correspond 1:1 with the
+		DMA specifiers listed in dmas. The string naming is to be "tx"
+		and "rx" for TX and RX DMA requests, respectively.
+
 Example:
 	mmc1: mmc@4809c000 {
 		compatible = "ti,dra7-sdhci";
@@ -22,4 +29,6 @@ Example:
 		ti,hwmods = "mmc1";
 		bus-width = <4>;
 		vmmc-supply = <&vmmc>; /* phandle to regulator node */
+		dmas = <&sdma 61 &sdma 62>;
+		dma-names = "tx", "rx";
 	};
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 01/11] dt-bindings: sdhci-omap: Add properties for using external dma Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-07  6:34   ` Baolin Wang
  2020-01-15 10:55   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices Faiz Abbas
                   ` (8 subsequent siblings)
  10 siblings, 2 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

In preparation for adding external dma support, factor out data initialization,
block info and mrq_done to their own functions.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci.c | 96 +++++++++++++++++++++++-----------------
 1 file changed, 55 insertions(+), 41 deletions(-)

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 1b1c26da3fe0..f6999054abcf 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1025,18 +1025,9 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
 	}
 }
 
-static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
+static void sdhci_initialize_data(struct sdhci_host *host,
+				  struct mmc_data *data)
 {
-	struct mmc_data *data = cmd->data;
-
-	host->data_timeout = 0;
-
-	if (sdhci_data_line_cmd(cmd))
-		sdhci_set_timeout(host, cmd);
-
-	if (!data)
-		return;
-
 	WARN_ON(host->data);
 
 	/* Sanity checks */
@@ -1048,6 +1039,36 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
 	host->data_early = 0;
 	host->data->bytes_xfered = 0;
 
+}
+
+static inline void sdhci_set_block_info(struct sdhci_host *host,
+					struct mmc_data *data)
+{
+
+	/* Set the DMA boundary value and block size */
+	sdhci_writew(host,
+		     SDHCI_MAKE_BLKSZ(host->sdma_boundary, host->data->blksz),
+		     SDHCI_BLOCK_SIZE);
+	/*
+	 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
+	 * can be supported, in that case 16-bit block count register must be 0.
+	 */
+	if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
+	    (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
+		if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
+			sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
+		sdhci_writew(host, host->data->blocks, SDHCI_32BIT_BLK_CNT);
+	} else {
+		sdhci_writew(host, host->data->blocks, SDHCI_BLOCK_COUNT);
+	}
+}
+
+static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
+{
+	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;
@@ -1133,22 +1154,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
 
 	sdhci_set_transfer_irqs(host);
 
-	/* Set the DMA boundary value and block size */
-	sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz),
-		     SDHCI_BLOCK_SIZE);
-
-	/*
-	 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
-	 * can be supported, in that case 16-bit block count register must be 0.
-	 */
-	if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
-	    (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
-		if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
-			sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
-		sdhci_writew(host, data->blocks, SDHCI_32BIT_BLK_CNT);
-	} else {
-		sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
-	}
+	sdhci_set_block_info(host, data);
 }
 
 static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
@@ -1245,22 +1251,10 @@ static bool sdhci_needs_reset(struct sdhci_host *host, struct mmc_request *mrq)
 		 (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST)));
 }
 
-static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
+static void sdhci_set_mrq_done(struct sdhci_host *host, struct mmc_request *mrq)
 {
 	int i;
 
-	if (host->cmd && host->cmd->mrq == mrq)
-		host->cmd = NULL;
-
-	if (host->data_cmd && host->data_cmd->mrq == mrq)
-		host->data_cmd = NULL;
-
-	if (host->data && host->data->mrq == mrq)
-		host->data = NULL;
-
-	if (sdhci_needs_reset(host, mrq))
-		host->pending_reset = true;
-
 	for (i = 0; i < SDHCI_MAX_MRQS; i++) {
 		if (host->mrqs_done[i] == mrq) {
 			WARN_ON(1);
@@ -1276,6 +1270,23 @@ static void __sdhci_finish_mrq(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)
+{
+	if (host->cmd && host->cmd->mrq == mrq)
+		host->cmd = NULL;
+
+	if (host->data_cmd && host->data_cmd->mrq == mrq)
+		host->data_cmd = NULL;
+
+	if (host->data && host->data->mrq == mrq)
+		host->data = NULL;
+
+	if (sdhci_needs_reset(host, mrq))
+		host->pending_reset = true;
+
+	sdhci_set_mrq_done(host, mrq);
 
 	sdhci_del_timer(host, mrq);
 
@@ -1390,12 +1401,15 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
 	}
 
 	host->cmd = cmd;
+	host->data_timeout = 0;
 	if (sdhci_data_line_cmd(cmd)) {
 		WARN_ON(host->data_cmd);
 		host->data_cmd = cmd;
+		sdhci_set_timeout(host, cmd);
 	}
 
-	sdhci_prepare_data(host, cmd);
+	if (cmd->data)
+		sdhci_prepare_data(host, cmd);
 
 	sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
 
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 01/11] dt-bindings: sdhci-omap: Add properties for using external dma Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-08  1:28   ` Baolin Wang
  2020-01-15 12:01   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma Faiz Abbas
                   ` (7 subsequent siblings)
  10 siblings, 2 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

From: Chunyan Zhang <zhang.chunyan@linaro.org>

Some standard SD host controllers can support both external dma
controllers as well as ADMA/SDMA in which the SD host controller
acts as DMA master. TI's omap controller is the case as an example.

Currently the generic SDHCI code supports ADMA/SDMA integrated in
the host controller but does not have any support for external DMA
controllers implemented using dmaengine, meaning that custom code is
needed for any systems that use an external DMA controller with SDHCI.

Fixes by Faiz Abbas <faiz_abbas@ti.com>:
1. Map scatterlists before dmaengine_prep_slave_sg()
2. Use dma_async() functions inside of the send_command() path and call
terminate_sync() in non-atomic context in case of an error.

Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/Kconfig |   3 +
 drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
 drivers/mmc/host/sdhci.h |   8 ++
 3 files changed, 237 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index d06b2dfe3c95..adef971582a1 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -1040,3 +1040,6 @@ config MMC_OWL
 	help
 	  This selects support for the SD/MMC Host Controller on
 	  Actions Semi Owl SoCs.
+
+config MMC_SDHCI_EXTERNAL_DMA
+	bool
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index f6999054abcf..8cc78c76bc3d 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/dmaengine.h>
 #include <linux/ktime.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
@@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
 	sdhci_set_block_info(host, data);
 }
 
+#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
+
+static int sdhci_external_dma_init(struct sdhci_host *host)
+{
+	int ret = 0;
+	struct mmc_host *mmc = host->mmc;
+
+	host->tx_chan = dma_request_chan(mmc->parent, "tx");
+	if (IS_ERR(host->tx_chan)) {
+		ret = PTR_ERR(host->tx_chan);
+		if (ret != -EPROBE_DEFER)
+			pr_warn("Failed to request TX DMA channel.\n");
+		host->tx_chan = NULL;
+		return ret;
+	}
+
+	host->rx_chan = dma_request_chan(mmc->parent, "rx");
+	if (IS_ERR(host->rx_chan)) {
+		if (host->tx_chan) {
+			dma_release_channel(host->tx_chan);
+			host->tx_chan = NULL;
+		}
+
+		ret = PTR_ERR(host->rx_chan);
+		if (ret != -EPROBE_DEFER)
+			pr_warn("Failed to request RX DMA channel.\n");
+		host->rx_chan = NULL;
+	}
+
+	return ret;
+}
+
+static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
+						   struct mmc_data *data)
+{
+	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 ret, i;
+	struct dma_async_tx_descriptor *desc;
+	struct mmc_data *data = cmd->data;
+	struct dma_chan *chan;
+	struct dma_slave_config cfg;
+	dma_cookie_t cookie;
+	int sg_cnt;
+
+	if (!host->mapbase)
+		return -EINVAL;
+
+	cfg.src_addr = host->mapbase + SDHCI_BUFFER;
+	cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
+	cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+	cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+	cfg.src_maxburst = data->blksz / 4;
+	cfg.dst_maxburst = data->blksz / 4;
+
+	/* Sanity check: all the SG entries must be aligned by block size. */
+	for (i = 0; i < data->sg_len; i++) {
+		if ((data->sg + i)->length % data->blksz)
+			return -EINVAL;
+	}
+
+	chan = sdhci_external_dma_channel(host, data);
+
+	ret = dmaengine_slave_config(chan, &cfg);
+	if (ret)
+		return ret;
+
+	sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
+	if (sg_cnt <= 0)
+		return -EINVAL;
+
+	desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
+				       mmc_get_dma_dir(data),
+				       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+	if (!desc)
+		return -EINVAL;
+
+	desc->callback = NULL;
+	desc->callback_param = NULL;
+
+	cookie = dmaengine_submit(desc);
+	if (cookie < 0)
+		ret = cookie;
+
+	return ret;
+}
+
+static void sdhci_external_dma_release(struct sdhci_host *host)
+{
+	if (host->tx_chan) {
+		dma_release_channel(host->tx_chan);
+		host->tx_chan = NULL;
+	}
+
+	if (host->rx_chan) {
+		dma_release_channel(host->rx_chan);
+		host->rx_chan = NULL;
+	}
+
+	sdhci_switch_external_dma(host, false);
+}
+
+static void __sdhci_external_dma_prepare_data(struct sdhci_host *host,
+					      struct mmc_command *cmd)
+{
+	struct mmc_data *data = cmd->data;
+
+	sdhci_initialize_data(host, data);
+
+	host->flags |= SDHCI_REQ_USE_DMA;
+	sdhci_set_transfer_irqs(host);
+
+	sdhci_set_block_info(host, data);
+}
+
+static void sdhci_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_prepare_data(host, cmd);
+	}
+}
+
+static void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
+					    struct mmc_command *cmd)
+{
+	struct dma_chan *chan;
+
+	if (!cmd->data)
+		return;
+
+	chan = sdhci_external_dma_channel(host, cmd->data);
+	if (chan)
+		dma_async_issue_pending(chan);
+}
+
+#else
+
+static inline int sdhci_external_dma_init(struct sdhci_host *host)
+{
+	return -EOPNOTSUPP;
+}
+
+static inline void sdhci_external_dma_release(struct sdhci_host *host)
+{
+}
+
+static inline void sdhci_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)
+{
+}
+
+static inline struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
+							  struct mmc_data *data)
+{
+	return NULL;
+}
+
+#endif
+
+void sdhci_switch_external_dma(struct sdhci_host *host, bool en)
+{
+	host->use_external_dma = en;
+}
+EXPORT_SYMBOL_GPL(sdhci_switch_external_dma);
+
 static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
 				    struct mmc_request *mrq)
 {
@@ -1408,8 +1591,12 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
 		sdhci_set_timeout(host, cmd);
 	}
 
-	if (cmd->data)
-		sdhci_prepare_data(host, cmd);
+	if (cmd->data) {
+		if (host->use_external_dma)
+			sdhci_external_dma_prepare_data(host, cmd);
+		else
+			sdhci_prepare_data(host, cmd);
+	}
 
 	sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
 
@@ -1451,6 +1638,9 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
 		timeout += 10 * HZ;
 	sdhci_mod_timer(host, cmd->mrq, timeout);
 
+	if (host->use_external_dma)
+		sdhci_external_dma_pre_transfer(host, cmd);
+
 	sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
 }
 EXPORT_SYMBOL_GPL(sdhci_send_command);
@@ -2675,6 +2865,17 @@ static bool sdhci_request_done(struct sdhci_host *host)
 	if (host->flags & SDHCI_REQ_USE_DMA) {
 		struct mmc_data *data = mrq->data;
 
+		if (host->use_external_dma && data &&
+		    (mrq->cmd->error || data->error)) {
+			struct dma_chan *chan = sdhci_external_dma_channel(host, data);
+
+			host->mrqs_done[i] = NULL;
+			spin_unlock_irqrestore(&host->lock, flags);
+			dmaengine_terminate_sync(chan);
+			spin_lock_irqsave(&host->lock, flags);
+			sdhci_set_mrq_done(host, mrq);
+		}
+
 		if (data && data->host_cookie == COOKIE_MAPPED) {
 			if (host->bounce_buffer) {
 				/*
@@ -3810,6 +4011,21 @@ int sdhci_setup_host(struct sdhci_host *host)
 	if (sdhci_can_64bit_dma(host))
 		host->flags |= SDHCI_USE_64_BIT_DMA;
 
+	if (host->use_external_dma) {
+		ret = sdhci_external_dma_init(host);
+		if (ret == -EPROBE_DEFER)
+			goto unreg;
+		/*
+		 * Fall back to use the DMA/PIO integrated in standard SDHCI
+		 * instead of external DMA devices.
+		 */
+		else if (ret)
+			sdhci_switch_external_dma(host, false);
+		/* Disable internal DMA sources */
+		else
+			host->flags &= ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA);
+	}
+
 	if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
 		if (host->ops->set_dma_mask)
 			ret = host->ops->set_dma_mask(host);
@@ -4290,6 +4506,10 @@ void sdhci_cleanup_host(struct sdhci_host *host)
 		dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
 				  host->adma_table_sz, host->align_buffer,
 				  host->align_addr);
+
+	if (host->use_external_dma)
+		sdhci_external_dma_release(host);
+
 	host->adma_table = NULL;
 	host->align_buffer = NULL;
 }
@@ -4335,6 +4555,7 @@ int __sdhci_add_host(struct sdhci_host *host)
 
 	pr_info("%s: SDHCI controller on %s [%s] using %s\n",
 		mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
+		host->use_external_dma ? "External DMA" :
 		(host->flags & SDHCI_USE_ADMA) ?
 		(host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
 		(host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
@@ -4423,6 +4644,9 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 				  host->adma_table_sz, host->align_buffer,
 				  host->align_addr);
 
+	if (host->use_external_dma)
+		sdhci_external_dma_release(host);
+
 	host->adma_table = NULL;
 	host->align_buffer = NULL;
 }
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index fe83ece6965b..3166b3ecef89 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -487,6 +487,7 @@ struct sdhci_host {
 
 	int irq;		/* Device IRQ */
 	void __iomem *ioaddr;	/* Mapped address */
+	phys_addr_t mapbase;	/* physical address base */
 	char *bounce_buffer;	/* For packing SDMA reads/writes */
 	dma_addr_t bounce_addr;
 	unsigned int bounce_buffer_size;
@@ -535,6 +536,7 @@ struct sdhci_host {
 	bool pending_reset;	/* Cmd/data reset is pending */
 	bool irq_wake_enabled;	/* IRQ wakeup is enabled */
 	bool v4_mode;		/* Host Version 4 Enable */
+	bool use_external_dma;	/* Host selects to use external DMA */
 
 	struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];	/* Requests done */
 	struct mmc_command *cmd;	/* Current command */
@@ -564,6 +566,11 @@ struct sdhci_host {
 	struct timer_list timer;	/* Timer for timeouts */
 	struct timer_list data_timer;	/* Timer for data timeouts */
 
+#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
+	struct dma_chan *rx_chan;
+	struct dma_chan *tx_chan;
+#endif
+
 	u32 caps;		/* CAPABILITY_0 */
 	u32 caps1;		/* CAPABILITY_1 */
 	bool read_caps;		/* Capability flags have been read */
@@ -795,5 +802,6 @@ void sdhci_end_tuning(struct sdhci_host *host);
 void sdhci_reset_tuning(struct sdhci_host *host);
 void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
 void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
+void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
 
 #endif /* __SDHCI_HW_H */
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (2 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-15 12:02   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static Faiz Abbas
                   ` (6 subsequent siblings)
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

From: Chunyan Zhang <zhang.chunyan@linaro.org>

sdhci-omap can support both external dma controller via dmaengine framework
as well as ADMA which standard SD host controller provides.

Fixes by Faiz Abbas <fazi_abbas@ti.com>:
1. Switch to DMA slave mode when using external DMA
2. Add offset to mapbase

Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/Kconfig      |  1 +
 drivers/mmc/host/sdhci-omap.c | 16 +++++++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index adef971582a1..2c0d90b9383e 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -1010,6 +1010,7 @@ config MMC_SDHCI_OMAP
 	depends on MMC_SDHCI_PLTFM && OF
 	select THERMAL
 	imply TI_SOC_THERMAL
+	select MMC_SDHCI_EXTERNAL_DMA if DMA_ENGINE
 	help
 	  This selects the Secure Digital Host Controller Interface (SDHCI)
 	  support present in TI's DRA7 SOCs. The controller supports
diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
index 083e7e053c95..84d85aa743da 100644
--- a/drivers/mmc/host/sdhci-omap.c
+++ b/drivers/mmc/host/sdhci-omap.c
@@ -685,7 +685,11 @@ static int sdhci_omap_enable_dma(struct sdhci_host *host)
 	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
 
 	reg = sdhci_omap_readl(omap_host, SDHCI_OMAP_CON);
-	reg |= CON_DMA_MASTER;
+	reg &= ~CON_DMA_MASTER;
+	/* Switch to DMA slave mode when using external DMA */
+	if (!host->use_external_dma)
+		reg |= CON_DMA_MASTER;
+
 	sdhci_omap_writel(omap_host, SDHCI_OMAP_CON, reg);
 
 	return 0;
@@ -1037,6 +1041,7 @@ static int sdhci_omap_probe(struct platform_device *pdev)
 	const struct of_device_id *match;
 	struct sdhci_omap_data *data;
 	const struct soc_device_attribute *soc;
+	struct resource *regs;
 
 	match = of_match_device(omap_sdhci_match, dev);
 	if (!match)
@@ -1049,6 +1054,10 @@ static int sdhci_omap_probe(struct platform_device *pdev)
 	}
 	offset = data->offset;
 
+	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!regs)
+		return -ENXIO;
+
 	host = sdhci_pltfm_init(pdev, &sdhci_omap_pdata,
 				sizeof(*omap_host));
 	if (IS_ERR(host)) {
@@ -1065,6 +1074,7 @@ static int sdhci_omap_probe(struct platform_device *pdev)
 	omap_host->timing = MMC_TIMING_LEGACY;
 	omap_host->flags = data->flags;
 	host->ioaddr += offset;
+	host->mapbase = regs->start + offset;
 
 	mmc = host->mmc;
 	sdhci_get_of_property(pdev);
@@ -1134,6 +1144,10 @@ static int sdhci_omap_probe(struct platform_device *pdev)
 	host->mmc_host_ops.execute_tuning = sdhci_omap_execute_tuning;
 	host->mmc_host_ops.enable_sdio_irq = sdhci_omap_enable_sdio_irq;
 
+	/* Switch to external DMA only if there is the "dmas" property */
+	if (of_find_property(dev->of_node, "dmas", NULL))
+		sdhci_switch_external_dma(host, true);
+
 	ret = sdhci_setup_host(host);
 	if (ret)
 		goto err_put_sync;
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (3 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-15 12:03   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout() Faiz Abbas
                   ` (5 subsequent siblings)
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Export sdhci_set_timeout_irq() so that it is accessible from platform drivers.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci.c | 3 ++-
 drivers/mmc/host/sdhci.h | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 8cc78c76bc3d..56f46bd7cdad 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -993,7 +993,7 @@ static void sdhci_set_transfer_irqs(struct sdhci_host *host)
 	sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
 }
 
-static void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
+void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
 {
 	if (enable)
 		host->ier |= SDHCI_INT_DATA_TIMEOUT;
@@ -1002,6 +1002,7 @@ static void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
 	sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
 	sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
 }
+EXPORT_SYMBOL_GPL(sdhci_set_data_timeout_irq);
 
 static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
 {
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 3166b3ecef89..928c6f35fcad 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -803,5 +803,6 @@ void sdhci_reset_tuning(struct sdhci_host *host);
 void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
 void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
 void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
+void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable);
 
 #endif /* __SDHCI_HW_H */
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout()
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (4 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-15 12:04   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase Faiz Abbas
                   ` (4 subsequent siblings)
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Refactor sdhci_set_timeout() such that platform drivers can do some
functionality in a set_timeout() callback and then call
__sdhci_set_timeout() to complete the operation.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci.c | 36 +++++++++++++++++++-----------------
 drivers/mmc/host/sdhci.h |  1 +
 2 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 56f46bd7cdad..adb3e8ccefb8 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1004,27 +1004,29 @@ void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
 }
 EXPORT_SYMBOL_GPL(sdhci_set_data_timeout_irq);
 
-static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
+void __sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
 {
-	u8 count;
+	bool too_big = false;
+	u8 count = sdhci_calc_timeout(host, cmd, &too_big);
 
-	if (host->ops->set_timeout) {
-		host->ops->set_timeout(host, cmd);
-	} else {
-		bool too_big = false;
-
-		count = sdhci_calc_timeout(host, cmd, &too_big);
+	if (too_big &&
+	    host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) {
+		sdhci_calc_sw_timeout(host, cmd);
+		sdhci_set_data_timeout_irq(host, false);
+	} else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) {
+		sdhci_set_data_timeout_irq(host, true);
+	}
 
-		if (too_big &&
-		    host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) {
-			sdhci_calc_sw_timeout(host, cmd);
-			sdhci_set_data_timeout_irq(host, false);
-		} else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) {
-			sdhci_set_data_timeout_irq(host, true);
-		}
+	sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
+}
+EXPORT_SYMBOL_GPL(__sdhci_set_timeout);
 
-		sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
-	}
+static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
+{
+	if (host->ops->set_timeout)
+		host->ops->set_timeout(host, cmd);
+	else
+		__sdhci_set_timeout(host, cmd);
 }
 
 static void sdhci_initialize_data(struct sdhci_host *host,
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 928c6f35fcad..1fe230c2ed84 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -804,5 +804,6 @@ void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
 void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
 void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
 void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable);
+void __sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd);
 
 #endif /* __SDHCI_HW_H */
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (5 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout() Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-15 12:05   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property Faiz Abbas
                   ` (3 subsequent siblings)
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Disable data timeout interrupt during an erase operation

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci-omap.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
index 84d85aa743da..1f05c8e98d62 100644
--- a/drivers/mmc/host/sdhci-omap.c
+++ b/drivers/mmc/host/sdhci-omap.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/mmc/mmc.h>
 #include <linux/mmc/slot-gpio.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -827,6 +828,15 @@ static u32 sdhci_omap_irq(struct sdhci_host *host, u32 intmask)
 	return intmask;
 }
 
+static void sdhci_omap_set_timeout(struct sdhci_host *host,
+				   struct mmc_command *cmd)
+{
+	if (cmd->opcode == MMC_ERASE)
+		sdhci_set_data_timeout_irq(host, false);
+
+	__sdhci_set_timeout(host, cmd);
+}
+
 static struct sdhci_ops sdhci_omap_ops = {
 	.set_clock = sdhci_omap_set_clock,
 	.set_power = sdhci_omap_set_power,
@@ -838,6 +848,7 @@ static struct sdhci_ops sdhci_omap_ops = {
 	.reset = sdhci_omap_reset,
 	.set_uhs_signaling = sdhci_omap_set_uhs_signaling,
 	.irq = sdhci_omap_irq,
+	.set_timeout = sdhci_omap_set_timeout,
 };
 
 static int sdhci_omap_set_capabilities(struct sdhci_omap_host *omap_host)
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (6 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-06 22:03   ` Rob Herring
  2020-01-06 11:01 ` [PATCH v4 09/11] mmc: sdhci-omap: Add " Faiz Abbas
                   ` (2 subsequent siblings)
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Some controllers need a special software reset sequence. Document the
ti,needs-special-reset binding to indicate that a controller needs this.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 Documentation/devicetree/bindings/mmc/sdhci-omap.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
index 97efb01617dd..0f5389c72bda 100644
--- a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
+++ b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
@@ -21,6 +21,7 @@ Optional properties:
 - dma-names:	List of DMA request names. These strings correspond 1:1 with the
 		DMA specifiers listed in dmas. The string naming is to be "tx"
 		and "rx" for TX and RX DMA requests, respectively.
+- ti,needs-special-reset: Requires a special softreset sequence
 
 Example:
 	mmc1: mmc@4809c000 {
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 09/11] mmc: sdhci-omap: Add ti,needs-special-reset property
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (7 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property Faiz Abbas
@ 2020-01-06 11:01 ` " Faiz Abbas
  2020-01-15 12:14   ` Adrian Hunter
  2020-01-06 11:01 ` [PATCH v4 10/11] dt-bindings: sdhci-omap: Add am335x and am437x specific bindings Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles Faiz Abbas
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Some omap controllers need software to monitor a 0->1->0 for software
reset. Add a ti,needs-special-reset property to indicate this and use
the special_reset member to indicate when a controller needs this.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci-omap.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
index 1f05c8e98d62..34df30edd450 100644
--- a/drivers/mmc/host/sdhci-omap.c
+++ b/drivers/mmc/host/sdhci-omap.c
@@ -107,6 +107,7 @@ struct sdhci_omap_host {
 	struct pinctrl		*pinctrl;
 	struct pinctrl_state	**pinctrl_state;
 	bool			is_tuning;
+	bool			special_reset;
 };
 
 static void sdhci_omap_start_clock(struct sdhci_omap_host *omap_host);
@@ -779,15 +780,35 @@ static void sdhci_omap_set_uhs_signaling(struct sdhci_host *host,
 	sdhci_omap_start_clock(omap_host);
 }
 
+#define MMC_TIMEOUT_US		20000		/* 20000 micro Sec */
 static void sdhci_omap_reset(struct sdhci_host *host, u8 mask)
 {
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
+	unsigned long limit = MMC_TIMEOUT_US;
+	unsigned long i = 0;
 
 	/* Don't reset data lines during tuning operation */
 	if (omap_host->is_tuning)
 		mask &= ~SDHCI_RESET_DATA;
 
+	if (omap_host->special_reset) {
+		sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
+		while ((!(sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask)) &&
+		       (i++ < limit))
+			udelay(1);
+		i = 0;
+		while ((sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) &&
+		       (i++ < limit))
+			udelay(1);
+
+		if (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask)
+			dev_err(mmc_dev(host->mmc),
+				"Timeout waiting on controller reset in %s\n",
+				__func__);
+		return;
+	}
+
 	sdhci_reset(host, mask);
 }
 
@@ -1107,6 +1128,9 @@ static int sdhci_omap_probe(struct platform_device *pdev)
 	if (!mmc_can_gpio_ro(mmc))
 		mmc->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
 
+	if (of_find_property(dev->of_node, "ti,needs-special-reset", NULL))
+		omap_host->special_reset = true;
+
 	pltfm_host->clk = devm_clk_get(dev, "fck");
 	if (IS_ERR(pltfm_host->clk)) {
 		ret = PTR_ERR(pltfm_host->clk);
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 10/11] dt-bindings: sdhci-omap: Add am335x and am437x specific bindings
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (8 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 09/11] mmc: sdhci-omap: Add " Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-06 11:01 ` [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles Faiz Abbas
  10 siblings, 0 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Add binding for the TI's sdhci-omap controller present in am335x and
am437x devices.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---
 Documentation/devicetree/bindings/mmc/sdhci-omap.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
index 0f5389c72bda..5a6f74366558 100644
--- a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
+++ b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
@@ -7,6 +7,8 @@ For UHS devices which require tuning, the device tree should have a "cpu_thermal
 Required properties:
 - compatible: Should be "ti,dra7-sdhci" for DRA7 and DRA72 controllers
 	      Should be "ti,k2g-sdhci" for K2G
+	      Should be "ti,am335-sdhci" for am335x controllers
+	      Should be "ti,am437-sdhci" for am437x controllers
 - ti,hwmods: Must be "mmc<n>", <n> is controller instance starting 1
 	     (Not required for K2G).
 - pinctrl-names: Should be subset of "default", "hs", "sdr12", "sdr25", "sdr50",
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles
  2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
                   ` (9 preceding siblings ...)
  2020-01-06 11:01 ` [PATCH v4 10/11] dt-bindings: sdhci-omap: Add am335x and am437x specific bindings Faiz Abbas
@ 2020-01-06 11:01 ` Faiz Abbas
  2020-01-15 12:14   ` Adrian Hunter
  10 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-06 11:01 UTC (permalink / raw)
  To: linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, adrian.hunter, mark.rutland, robh+dt, ulf.hansson, tony,
	faiz_abbas

Add support for new compatible for TI's am335x and am437x devices.

Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
---
 drivers/mmc/host/sdhci-omap.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
index 34df30edd450..4d7026daa8cd 100644
--- a/drivers/mmc/host/sdhci-omap.c
+++ b/drivers/mmc/host/sdhci-omap.c
@@ -919,6 +919,14 @@ static const struct sdhci_omap_data k2g_data = {
 	.offset = 0x200,
 };
 
+static const struct sdhci_omap_data am335_data = {
+	.offset = 0x200,
+};
+
+static const struct sdhci_omap_data am437_data = {
+	.offset = 0x200,
+};
+
 static const struct sdhci_omap_data dra7_data = {
 	.offset = 0x200,
 	.flags	= SDHCI_OMAP_REQUIRE_IODELAY,
@@ -927,6 +935,8 @@ static const struct sdhci_omap_data dra7_data = {
 static const struct of_device_id omap_sdhci_match[] = {
 	{ .compatible = "ti,dra7-sdhci", .data = &dra7_data },
 	{ .compatible = "ti,k2g-sdhci", .data = &k2g_data },
+	{ .compatible = "ti,am335-sdhci", .data = &am335_data },
+	{ .compatible = "ti,am437-sdhci", .data = &am437_data },
 	{},
 };
 MODULE_DEVICE_TABLE(of, omap_sdhci_match);
-- 
2.19.2


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property
  2020-01-06 11:01 ` [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property Faiz Abbas
@ 2020-01-06 22:03   ` Rob Herring
  2020-01-07 11:18     ` Faiz Abbas
  0 siblings, 1 reply; 30+ messages in thread
From: Rob Herring @ 2020-01-06 22:03 UTC (permalink / raw)
  To: Faiz Abbas
  Cc: linux-omap, linux-kernel, devicetree, linux-mmc, kishon,
	adrian.hunter, mark.rutland, ulf.hansson, tony

On Mon, Jan 06, 2020 at 04:31:30PM +0530, Faiz Abbas wrote:
> Some controllers need a special software reset sequence. Document the
> ti,needs-special-reset binding to indicate that a controller needs this.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  Documentation/devicetree/bindings/mmc/sdhci-omap.txt | 1 +
>  1 file changed, 1 insertion(+)
> 
> diff --git a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
> index 97efb01617dd..0f5389c72bda 100644
> --- a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
> +++ b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
> @@ -21,6 +21,7 @@ Optional properties:
>  - dma-names:	List of DMA request names. These strings correspond 1:1 with the
>  		DMA specifiers listed in dmas. The string naming is to be "tx"
>  		and "rx" for TX and RX DMA requests, respectively.
> +- ti,needs-special-reset: Requires a special softreset sequence

Why can't this be implied by the compatible string?

Rob

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions
  2020-01-06 11:01 ` [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions Faiz Abbas
@ 2020-01-07  6:34   ` Baolin Wang
  2020-01-07  7:22     ` Faiz Abbas
  2020-01-15 10:55   ` Adrian Hunter
  1 sibling, 1 reply; 30+ messages in thread
From: Baolin Wang @ 2020-01-07  6:34 UTC (permalink / raw)
  To: Faiz Abbas
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Faiz,

On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>
> In preparation for adding external dma support, factor out data initialization,
> block info and mrq_done to their own functions.
>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  drivers/mmc/host/sdhci.c | 96 +++++++++++++++++++++++-----------------
>  1 file changed, 55 insertions(+), 41 deletions(-)
>
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index 1b1c26da3fe0..f6999054abcf 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -1025,18 +1025,9 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
>         }
>  }
>
> -static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> +static void sdhci_initialize_data(struct sdhci_host *host,
> +                                 struct mmc_data *data)
>  {
> -       struct mmc_data *data = cmd->data;
> -
> -       host->data_timeout = 0;
> -
> -       if (sdhci_data_line_cmd(cmd))
> -               sdhci_set_timeout(host, cmd);
> -
> -       if (!data)
> -               return;
> -
>         WARN_ON(host->data);
>
>         /* Sanity checks */
> @@ -1048,6 +1039,36 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>         host->data_early = 0;
>         host->data->bytes_xfered = 0;
>

Can you remove above redundant blank line?

> +}
> +
> +static inline void sdhci_set_block_info(struct sdhci_host *host,
> +                                       struct mmc_data *data)
> +{
> +

Ditto.

Otherwise, please add my tested tag if feel free.

Tested-by: Baolin Wang <baolin.wang7@gmail.com>

> +       /* Set the DMA boundary value and block size */
> +       sdhci_writew(host,
> +                    SDHCI_MAKE_BLKSZ(host->sdma_boundary, host->data->blksz),
> +                    SDHCI_BLOCK_SIZE);
> +       /*
> +        * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
> +        * can be supported, in that case 16-bit block count register must be 0.
> +        */
> +       if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
> +           (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
> +               if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
> +                       sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
> +               sdhci_writew(host, host->data->blocks, SDHCI_32BIT_BLK_CNT);
> +       } else {
> +               sdhci_writew(host, host->data->blocks, SDHCI_BLOCK_COUNT);
> +       }
> +}
> +
> +static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> +{
> +       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;
> @@ -1133,22 +1154,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>
>         sdhci_set_transfer_irqs(host);
>
> -       /* Set the DMA boundary value and block size */
> -       sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz),
> -                    SDHCI_BLOCK_SIZE);
> -
> -       /*
> -        * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
> -        * can be supported, in that case 16-bit block count register must be 0.
> -        */
> -       if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
> -           (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
> -               if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
> -                       sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
> -               sdhci_writew(host, data->blocks, SDHCI_32BIT_BLK_CNT);
> -       } else {
> -               sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
> -       }
> +       sdhci_set_block_info(host, data);
>  }
>
>  static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
> @@ -1245,22 +1251,10 @@ static bool sdhci_needs_reset(struct sdhci_host *host, struct mmc_request *mrq)
>                  (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST)));
>  }
>
> -static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
> +static void sdhci_set_mrq_done(struct sdhci_host *host, struct mmc_request *mrq)
>  {
>         int i;
>
> -       if (host->cmd && host->cmd->mrq == mrq)
> -               host->cmd = NULL;
> -
> -       if (host->data_cmd && host->data_cmd->mrq == mrq)
> -               host->data_cmd = NULL;
> -
> -       if (host->data && host->data->mrq == mrq)
> -               host->data = NULL;
> -
> -       if (sdhci_needs_reset(host, mrq))
> -               host->pending_reset = true;
> -
>         for (i = 0; i < SDHCI_MAX_MRQS; i++) {
>                 if (host->mrqs_done[i] == mrq) {
>                         WARN_ON(1);
> @@ -1276,6 +1270,23 @@ static void __sdhci_finish_mrq(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)
> +{
> +       if (host->cmd && host->cmd->mrq == mrq)
> +               host->cmd = NULL;
> +
> +       if (host->data_cmd && host->data_cmd->mrq == mrq)
> +               host->data_cmd = NULL;
> +
> +       if (host->data && host->data->mrq == mrq)
> +               host->data = NULL;
> +
> +       if (sdhci_needs_reset(host, mrq))
> +               host->pending_reset = true;
> +
> +       sdhci_set_mrq_done(host, mrq);
>
>         sdhci_del_timer(host, mrq);
>
> @@ -1390,12 +1401,15 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
>         }
>
>         host->cmd = cmd;
> +       host->data_timeout = 0;
>         if (sdhci_data_line_cmd(cmd)) {
>                 WARN_ON(host->data_cmd);
>                 host->data_cmd = cmd;
> +               sdhci_set_timeout(host, cmd);
>         }
>
> -       sdhci_prepare_data(host, cmd);
> +       if (cmd->data)
> +               sdhci_prepare_data(host, cmd);
>
>         sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
>
> --
> 2.19.2
>

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions
  2020-01-07  6:34   ` Baolin Wang
@ 2020-01-07  7:22     ` Faiz Abbas
  2020-01-08  1:32       ` Baolin Wang
  0 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-07  7:22 UTC (permalink / raw)
  To: Baolin Wang
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Baolin,

On 07/01/20 12:04 pm, Baolin Wang wrote:
> Hi Faiz,
> 
> On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>
>> In preparation for adding external dma support, factor out data initialization,
>> block info and mrq_done to their own functions.
>>
>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>> ---
>>  drivers/mmc/host/sdhci.c | 96 +++++++++++++++++++++++-----------------
>>  1 file changed, 55 insertions(+), 41 deletions(-)
>>
>> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
>> index 1b1c26da3fe0..f6999054abcf 100644
>> --- a/drivers/mmc/host/sdhci.c
>> +++ b/drivers/mmc/host/sdhci.c
>> @@ -1025,18 +1025,9 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
>>         }
>>  }
>>
>> -static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>> +static void sdhci_initialize_data(struct sdhci_host *host,
>> +                                 struct mmc_data *data)
>>  {
>> -       struct mmc_data *data = cmd->data;
>> -
>> -       host->data_timeout = 0;
>> -
>> -       if (sdhci_data_line_cmd(cmd))
>> -               sdhci_set_timeout(host, cmd);
>> -
>> -       if (!data)
>> -               return;
>> -
>>         WARN_ON(host->data);
>>
>>         /* Sanity checks */
>> @@ -1048,6 +1039,36 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>>         host->data_early = 0;
>>         host->data->bytes_xfered = 0;
>>
> 
> Can you remove above redundant blank line?
Ok.
> 
>> +}
>> +
>> +static inline void sdhci_set_block_info(struct sdhci_host *host,
>> +                                       struct mmc_data *data)
>> +{
>> +
> 
> Ditto.
Ok.
> 
> Otherwise, please add my tested tag if feel free.
> 
> Tested-by: Baolin Wang <baolin.wang7@gmail.com>

Which platform did you test this on?

Thanks,
Faiz

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property
  2020-01-06 22:03   ` Rob Herring
@ 2020-01-07 11:18     ` Faiz Abbas
  0 siblings, 0 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-07 11:18 UTC (permalink / raw)
  To: Rob Herring
  Cc: linux-omap, linux-kernel, devicetree, linux-mmc, kishon,
	adrian.hunter, mark.rutland, ulf.hansson, tony

Hi Rob,

On 07/01/20 3:33 am, Rob Herring wrote:
> On Mon, Jan 06, 2020 at 04:31:30PM +0530, Faiz Abbas wrote:
>> Some controllers need a special software reset sequence. Document the
>> ti,needs-special-reset binding to indicate that a controller needs this.
>>
>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>> ---
>>  Documentation/devicetree/bindings/mmc/sdhci-omap.txt | 1 +
>>  1 file changed, 1 insertion(+)
>>
>> diff --git a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
>> index 97efb01617dd..0f5389c72bda 100644
>> --- a/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
>> +++ b/Documentation/devicetree/bindings/mmc/sdhci-omap.txt
>> @@ -21,6 +21,7 @@ Optional properties:
>>  - dma-names:	List of DMA request names. These strings correspond 1:1 with the
>>  		DMA specifiers listed in dmas. The string naming is to be "tx"
>>  		and "rx" for TX and RX DMA requests, respectively.
>> +- ti,needs-special-reset: Requires a special softreset sequence
> 
> Why can't this be implied by the compatible string?
> 

You are right. We can assign the special_reset flag in the next patch
using compatible as well. Will drop this patch in next version.

Thanks,
Faiz

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-06 11:01 ` [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices Faiz Abbas
@ 2020-01-08  1:28   ` Baolin Wang
  2020-01-08  9:20     ` Faiz Abbas
  2020-01-15 12:01   ` Adrian Hunter
  1 sibling, 1 reply; 30+ messages in thread
From: Baolin Wang @ 2020-01-08  1:28 UTC (permalink / raw)
  To: Faiz Abbas
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Faiz,

On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>
> From: Chunyan Zhang <zhang.chunyan@linaro.org>
>
> Some standard SD host controllers can support both external dma
> controllers as well as ADMA/SDMA in which the SD host controller
> acts as DMA master. TI's omap controller is the case as an example.
>
> Currently the generic SDHCI code supports ADMA/SDMA integrated in
> the host controller but does not have any support for external DMA
> controllers implemented using dmaengine, meaning that custom code is
> needed for any systems that use an external DMA controller with SDHCI.
>
> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
> 1. Map scatterlists before dmaengine_prep_slave_sg()
> 2. Use dma_async() functions inside of the send_command() path and call
> terminate_sync() in non-atomic context in case of an error.
>
> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> ---
>  drivers/mmc/host/Kconfig |   3 +
>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
>  drivers/mmc/host/sdhci.h |   8 ++
>  3 files changed, 237 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> index d06b2dfe3c95..adef971582a1 100644
> --- a/drivers/mmc/host/Kconfig
> +++ b/drivers/mmc/host/Kconfig
> @@ -1040,3 +1040,6 @@ config MMC_OWL
>         help
>           This selects support for the SD/MMC Host Controller on
>           Actions Semi Owl SoCs.
> +
> +config MMC_SDHCI_EXTERNAL_DMA
> +       bool
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index f6999054abcf..8cc78c76bc3d 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -10,6 +10,7 @@
>   */
>
>  #include <linux/delay.h>
> +#include <linux/dmaengine.h>
>  #include <linux/ktime.h>
>  #include <linux/highmem.h>
>  #include <linux/io.h>
> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>         sdhci_set_block_info(host, data);
>  }
>
> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
> +
> +static int sdhci_external_dma_init(struct sdhci_host *host)
> +{
> +       int ret = 0;
> +       struct mmc_host *mmc = host->mmc;
> +
> +       host->tx_chan = dma_request_chan(mmc->parent, "tx");
> +       if (IS_ERR(host->tx_chan)) {
> +               ret = PTR_ERR(host->tx_chan);
> +               if (ret != -EPROBE_DEFER)
> +                       pr_warn("Failed to request TX DMA channel.\n");
> +               host->tx_chan = NULL;
> +               return ret;
> +       }
> +
> +       host->rx_chan = dma_request_chan(mmc->parent, "rx");
> +       if (IS_ERR(host->rx_chan)) {
> +               if (host->tx_chan) {
> +                       dma_release_channel(host->tx_chan);
> +                       host->tx_chan = NULL;
> +               }
> +
> +               ret = PTR_ERR(host->rx_chan);
> +               if (ret != -EPROBE_DEFER)
> +                       pr_warn("Failed to request RX DMA channel.\n");
> +               host->rx_chan = NULL;
> +       }
> +
> +       return ret;
> +}
> +
> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
> +                                                  struct mmc_data *data)
> +{
> +       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 ret, i;
> +       struct dma_async_tx_descriptor *desc;
> +       struct mmc_data *data = cmd->data;
> +       struct dma_chan *chan;
> +       struct dma_slave_config cfg;
> +       dma_cookie_t cookie;
> +       int sg_cnt;
> +
> +       if (!host->mapbase)
> +               return -EINVAL;
> +
> +       cfg.src_addr = host->mapbase + SDHCI_BUFFER;
> +       cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
> +       cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> +       cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> +       cfg.src_maxburst = data->blksz / 4;
> +       cfg.dst_maxburst = data->blksz / 4;
> +
> +       /* Sanity check: all the SG entries must be aligned by block size. */
> +       for (i = 0; i < data->sg_len; i++) {
> +               if ((data->sg + i)->length % data->blksz)
> +                       return -EINVAL;
> +       }
> +
> +       chan = sdhci_external_dma_channel(host, data);
> +
> +       ret = dmaengine_slave_config(chan, &cfg);
> +       if (ret)
> +               return ret;
> +
> +       sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
> +       if (sg_cnt <= 0)
> +               return -EINVAL;
> +
> +       desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
> +                                      mmc_get_dma_dir(data),
> +                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
> +       if (!desc)
> +               return -EINVAL;
> +
> +       desc->callback = NULL;
> +       desc->callback_param = NULL;
> +
> +       cookie = dmaengine_submit(desc);
> +       if (cookie < 0)

We usually use the DMA engine standard API: dma_submit_error() to
validate the cookie.

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions
  2020-01-07  7:22     ` Faiz Abbas
@ 2020-01-08  1:32       ` Baolin Wang
  0 siblings, 0 replies; 30+ messages in thread
From: Baolin Wang @ 2020-01-08  1:32 UTC (permalink / raw)
  To: Faiz Abbas
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Faiz,

On Tue, Jan 7, 2020 at 3:20 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>
> Hi Baolin,
>
> On 07/01/20 12:04 pm, Baolin Wang wrote:
> > Hi Faiz,
> >
> > On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
> >>
> >> In preparation for adding external dma support, factor out data initialization,
> >> block info and mrq_done to their own functions.
> >>
> >> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> >> ---
> >>  drivers/mmc/host/sdhci.c | 96 +++++++++++++++++++++++-----------------
> >>  1 file changed, 55 insertions(+), 41 deletions(-)
> >>
> >> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> >> index 1b1c26da3fe0..f6999054abcf 100644
> >> --- a/drivers/mmc/host/sdhci.c
> >> +++ b/drivers/mmc/host/sdhci.c
> >> @@ -1025,18 +1025,9 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
> >>         }
> >>  }
> >>
> >> -static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> >> +static void sdhci_initialize_data(struct sdhci_host *host,
> >> +                                 struct mmc_data *data)
> >>  {
> >> -       struct mmc_data *data = cmd->data;
> >> -
> >> -       host->data_timeout = 0;
> >> -
> >> -       if (sdhci_data_line_cmd(cmd))
> >> -               sdhci_set_timeout(host, cmd);
> >> -
> >> -       if (!data)
> >> -               return;
> >> -
> >>         WARN_ON(host->data);
> >>
> >>         /* Sanity checks */
> >> @@ -1048,6 +1039,36 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> >>         host->data_early = 0;
> >>         host->data->bytes_xfered = 0;
> >>
> >
> > Can you remove above redundant blank line?
> Ok.
> >
> >> +}
> >> +
> >> +static inline void sdhci_set_block_info(struct sdhci_host *host,
> >> +                                       struct mmc_data *data)
> >> +{
> >> +
> >
> > Ditto.
> Ok.
> >
> > Otherwise, please add my tested tag if feel free.
> >
> > Tested-by: Baolin Wang <baolin.wang7@gmail.com>
>
> Which platform did you test this on?

I tested on our Spreadtrum platform for the common sdhci driver
modification, but our host controller can not support external DMA, so
I can not help to test the external DMA.

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-08  1:28   ` Baolin Wang
@ 2020-01-08  9:20     ` Faiz Abbas
  2020-01-08  9:29       ` Baolin Wang
  0 siblings, 1 reply; 30+ messages in thread
From: Faiz Abbas @ 2020-01-08  9:20 UTC (permalink / raw)
  To: Baolin Wang
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Baolin,

On 08/01/20 6:58 am, Baolin Wang wrote:
> Hi Faiz,
> 
> On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>
>> From: Chunyan Zhang <zhang.chunyan@linaro.org>
>>
>> Some standard SD host controllers can support both external dma
>> controllers as well as ADMA/SDMA in which the SD host controller
>> acts as DMA master. TI's omap controller is the case as an example.
>>
>> Currently the generic SDHCI code supports ADMA/SDMA integrated in
>> the host controller but does not have any support for external DMA
>> controllers implemented using dmaengine, meaning that custom code is
>> needed for any systems that use an external DMA controller with SDHCI.
>>
>> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
>> 1. Map scatterlists before dmaengine_prep_slave_sg()
>> 2. Use dma_async() functions inside of the send_command() path and call
>> terminate_sync() in non-atomic context in case of an error.
>>
>> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>> ---
>>  drivers/mmc/host/Kconfig |   3 +
>>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
>>  drivers/mmc/host/sdhci.h |   8 ++
>>  3 files changed, 237 insertions(+), 2 deletions(-)
>>
>> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
>> index d06b2dfe3c95..adef971582a1 100644
>> --- a/drivers/mmc/host/Kconfig
>> +++ b/drivers/mmc/host/Kconfig
>> @@ -1040,3 +1040,6 @@ config MMC_OWL
>>         help
>>           This selects support for the SD/MMC Host Controller on
>>           Actions Semi Owl SoCs.
>> +
>> +config MMC_SDHCI_EXTERNAL_DMA
>> +       bool
>> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
>> index f6999054abcf..8cc78c76bc3d 100644
>> --- a/drivers/mmc/host/sdhci.c
>> +++ b/drivers/mmc/host/sdhci.c
>> @@ -10,6 +10,7 @@
>>   */
>>
>>  #include <linux/delay.h>
>> +#include <linux/dmaengine.h>
>>  #include <linux/ktime.h>
>>  #include <linux/highmem.h>
>>  #include <linux/io.h>
>> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>>         sdhci_set_block_info(host, data);
>>  }
>>
>> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
>> +
>> +static int sdhci_external_dma_init(struct sdhci_host *host)
>> +{
>> +       int ret = 0;
>> +       struct mmc_host *mmc = host->mmc;
>> +
>> +       host->tx_chan = dma_request_chan(mmc->parent, "tx");
>> +       if (IS_ERR(host->tx_chan)) {
>> +               ret = PTR_ERR(host->tx_chan);
>> +               if (ret != -EPROBE_DEFER)
>> +                       pr_warn("Failed to request TX DMA channel.\n");
>> +               host->tx_chan = NULL;
>> +               return ret;
>> +       }
>> +
>> +       host->rx_chan = dma_request_chan(mmc->parent, "rx");
>> +       if (IS_ERR(host->rx_chan)) {
>> +               if (host->tx_chan) {
>> +                       dma_release_channel(host->tx_chan);
>> +                       host->tx_chan = NULL;
>> +               }
>> +
>> +               ret = PTR_ERR(host->rx_chan);
>> +               if (ret != -EPROBE_DEFER)
>> +                       pr_warn("Failed to request RX DMA channel.\n");
>> +               host->rx_chan = NULL;
>> +       }
>> +
>> +       return ret;
>> +}
>> +
>> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
>> +                                                  struct mmc_data *data)
>> +{
>> +       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 ret, i;
>> +       struct dma_async_tx_descriptor *desc;
>> +       struct mmc_data *data = cmd->data;
>> +       struct dma_chan *chan;
>> +       struct dma_slave_config cfg;
>> +       dma_cookie_t cookie;
>> +       int sg_cnt;
>> +
>> +       if (!host->mapbase)
>> +               return -EINVAL;
>> +
>> +       cfg.src_addr = host->mapbase + SDHCI_BUFFER;
>> +       cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
>> +       cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>> +       cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>> +       cfg.src_maxburst = data->blksz / 4;
>> +       cfg.dst_maxburst = data->blksz / 4;
>> +
>> +       /* Sanity check: all the SG entries must be aligned by block size. */
>> +       for (i = 0; i < data->sg_len; i++) {
>> +               if ((data->sg + i)->length % data->blksz)
>> +                       return -EINVAL;
>> +       }
>> +
>> +       chan = sdhci_external_dma_channel(host, data);
>> +
>> +       ret = dmaengine_slave_config(chan, &cfg);
>> +       if (ret)
>> +               return ret;
>> +
>> +       sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
>> +       if (sg_cnt <= 0)
>> +               return -EINVAL;
>> +
>> +       desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
>> +                                      mmc_get_dma_dir(data),
>> +                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
>> +       if (!desc)
>> +               return -EINVAL;
>> +
>> +       desc->callback = NULL;
>> +       desc->callback_param = NULL;
>> +
>> +       cookie = dmaengine_submit(desc);
>> +       if (cookie < 0)
> 
> We usually use the DMA engine standard API: dma_submit_error() to
> validate the cookie.
> 

The if condition is doing the same thing as the API. Do we really
require it?

Thanks,
Faiz

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-08  9:20     ` Faiz Abbas
@ 2020-01-08  9:29       ` Baolin Wang
  2020-01-08 13:35         ` Peter Ujfalusi
  0 siblings, 1 reply; 30+ messages in thread
From: Baolin Wang @ 2020-01-08  9:29 UTC (permalink / raw)
  To: Faiz Abbas
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Faiz,

On Wed, Jan 8, 2020 at 5:19 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>
> Hi Baolin,
>
> On 08/01/20 6:58 am, Baolin Wang wrote:
> > Hi Faiz,
> >
> > On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
> >>
> >> From: Chunyan Zhang <zhang.chunyan@linaro.org>
> >>
> >> Some standard SD host controllers can support both external dma
> >> controllers as well as ADMA/SDMA in which the SD host controller
> >> acts as DMA master. TI's omap controller is the case as an example.
> >>
> >> Currently the generic SDHCI code supports ADMA/SDMA integrated in
> >> the host controller but does not have any support for external DMA
> >> controllers implemented using dmaengine, meaning that custom code is
> >> needed for any systems that use an external DMA controller with SDHCI.
> >>
> >> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
> >> 1. Map scatterlists before dmaengine_prep_slave_sg()
> >> 2. Use dma_async() functions inside of the send_command() path and call
> >> terminate_sync() in non-atomic context in case of an error.
> >>
> >> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
> >> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
> >> ---
> >>  drivers/mmc/host/Kconfig |   3 +
> >>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
> >>  drivers/mmc/host/sdhci.h |   8 ++
> >>  3 files changed, 237 insertions(+), 2 deletions(-)
> >>
> >> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> >> index d06b2dfe3c95..adef971582a1 100644
> >> --- a/drivers/mmc/host/Kconfig
> >> +++ b/drivers/mmc/host/Kconfig
> >> @@ -1040,3 +1040,6 @@ config MMC_OWL
> >>         help
> >>           This selects support for the SD/MMC Host Controller on
> >>           Actions Semi Owl SoCs.
> >> +
> >> +config MMC_SDHCI_EXTERNAL_DMA
> >> +       bool
> >> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> >> index f6999054abcf..8cc78c76bc3d 100644
> >> --- a/drivers/mmc/host/sdhci.c
> >> +++ b/drivers/mmc/host/sdhci.c
> >> @@ -10,6 +10,7 @@
> >>   */
> >>
> >>  #include <linux/delay.h>
> >> +#include <linux/dmaengine.h>
> >>  #include <linux/ktime.h>
> >>  #include <linux/highmem.h>
> >>  #include <linux/io.h>
> >> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> >>         sdhci_set_block_info(host, data);
> >>  }
> >>
> >> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
> >> +
> >> +static int sdhci_external_dma_init(struct sdhci_host *host)
> >> +{
> >> +       int ret = 0;
> >> +       struct mmc_host *mmc = host->mmc;
> >> +
> >> +       host->tx_chan = dma_request_chan(mmc->parent, "tx");
> >> +       if (IS_ERR(host->tx_chan)) {
> >> +               ret = PTR_ERR(host->tx_chan);
> >> +               if (ret != -EPROBE_DEFER)
> >> +                       pr_warn("Failed to request TX DMA channel.\n");
> >> +               host->tx_chan = NULL;
> >> +               return ret;
> >> +       }
> >> +
> >> +       host->rx_chan = dma_request_chan(mmc->parent, "rx");
> >> +       if (IS_ERR(host->rx_chan)) {
> >> +               if (host->tx_chan) {
> >> +                       dma_release_channel(host->tx_chan);
> >> +                       host->tx_chan = NULL;
> >> +               }
> >> +
> >> +               ret = PTR_ERR(host->rx_chan);
> >> +               if (ret != -EPROBE_DEFER)
> >> +                       pr_warn("Failed to request RX DMA channel.\n");
> >> +               host->rx_chan = NULL;
> >> +       }
> >> +
> >> +       return ret;
> >> +}
> >> +
> >> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
> >> +                                                  struct mmc_data *data)
> >> +{
> >> +       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 ret, i;
> >> +       struct dma_async_tx_descriptor *desc;
> >> +       struct mmc_data *data = cmd->data;
> >> +       struct dma_chan *chan;
> >> +       struct dma_slave_config cfg;
> >> +       dma_cookie_t cookie;
> >> +       int sg_cnt;
> >> +
> >> +       if (!host->mapbase)
> >> +               return -EINVAL;
> >> +
> >> +       cfg.src_addr = host->mapbase + SDHCI_BUFFER;
> >> +       cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
> >> +       cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> >> +       cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> >> +       cfg.src_maxburst = data->blksz / 4;
> >> +       cfg.dst_maxburst = data->blksz / 4;
> >> +
> >> +       /* Sanity check: all the SG entries must be aligned by block size. */
> >> +       for (i = 0; i < data->sg_len; i++) {
> >> +               if ((data->sg + i)->length % data->blksz)
> >> +                       return -EINVAL;
> >> +       }
> >> +
> >> +       chan = sdhci_external_dma_channel(host, data);
> >> +
> >> +       ret = dmaengine_slave_config(chan, &cfg);
> >> +       if (ret)
> >> +               return ret;
> >> +
> >> +       sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
> >> +       if (sg_cnt <= 0)
> >> +               return -EINVAL;
> >> +
> >> +       desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
> >> +                                      mmc_get_dma_dir(data),
> >> +                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
> >> +       if (!desc)
> >> +               return -EINVAL;
> >> +
> >> +       desc->callback = NULL;
> >> +       desc->callback_param = NULL;
> >> +
> >> +       cookie = dmaengine_submit(desc);
> >> +       if (cookie < 0)
> >
> > We usually use the DMA engine standard API: dma_submit_error() to
> > validate the cookie.
> >
>
> The if condition is doing the same thing as the API. Do we really
> require it?

Yes, now it did the same thing. But in future if the DMA engine expand
the cookie indication, which may break your current condition, but use
dma_submit_error() is more safe, that will help to cover the internal
cookie things. So I recommend to use the standard API as far as
possible.

But if Ulf does not care about this, it's Okay for me too :)

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-08  9:29       ` Baolin Wang
@ 2020-01-08 13:35         ` Peter Ujfalusi
  2020-01-10 13:16           ` Faiz Abbas
  0 siblings, 1 reply; 30+ messages in thread
From: Peter Ujfalusi @ 2020-01-08 13:35 UTC (permalink / raw)
  To: Baolin Wang, Faiz Abbas
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi,

On 08/01/2020 11.29, Baolin Wang wrote:
> Hi Faiz,
> 
> On Wed, Jan 8, 2020 at 5:19 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>
>> Hi Baolin,
>>
>> On 08/01/20 6:58 am, Baolin Wang wrote:
>>> Hi Faiz,
>>>
>>> On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>>>
>>>> From: Chunyan Zhang <zhang.chunyan@linaro.org>
>>>>
>>>> Some standard SD host controllers can support both external dma
>>>> controllers as well as ADMA/SDMA in which the SD host controller
>>>> acts as DMA master. TI's omap controller is the case as an example.
>>>>
>>>> Currently the generic SDHCI code supports ADMA/SDMA integrated in
>>>> the host controller but does not have any support for external DMA
>>>> controllers implemented using dmaengine, meaning that custom code is
>>>> needed for any systems that use an external DMA controller with SDHCI.
>>>>
>>>> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
>>>> 1. Map scatterlists before dmaengine_prep_slave_sg()
>>>> 2. Use dma_async() functions inside of the send_command() path and call
>>>> terminate_sync() in non-atomic context in case of an error.
>>>>
>>>> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
>>>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>>>> ---
>>>>  drivers/mmc/host/Kconfig |   3 +
>>>>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
>>>>  drivers/mmc/host/sdhci.h |   8 ++
>>>>  3 files changed, 237 insertions(+), 2 deletions(-)
>>>>
>>>> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
>>>> index d06b2dfe3c95..adef971582a1 100644
>>>> --- a/drivers/mmc/host/Kconfig
>>>> +++ b/drivers/mmc/host/Kconfig
>>>> @@ -1040,3 +1040,6 @@ config MMC_OWL
>>>>         help
>>>>           This selects support for the SD/MMC Host Controller on
>>>>           Actions Semi Owl SoCs.
>>>> +
>>>> +config MMC_SDHCI_EXTERNAL_DMA
>>>> +       bool
>>>> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
>>>> index f6999054abcf..8cc78c76bc3d 100644
>>>> --- a/drivers/mmc/host/sdhci.c
>>>> +++ b/drivers/mmc/host/sdhci.c
>>>> @@ -10,6 +10,7 @@
>>>>   */
>>>>
>>>>  #include <linux/delay.h>
>>>> +#include <linux/dmaengine.h>
>>>>  #include <linux/ktime.h>
>>>>  #include <linux/highmem.h>
>>>>  #include <linux/io.h>
>>>> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>>>>         sdhci_set_block_info(host, data);
>>>>  }
>>>>
>>>> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
>>>> +
>>>> +static int sdhci_external_dma_init(struct sdhci_host *host)
>>>> +{
>>>> +       int ret = 0;
>>>> +       struct mmc_host *mmc = host->mmc;
>>>> +
>>>> +       host->tx_chan = dma_request_chan(mmc->parent, "tx");
>>>> +       if (IS_ERR(host->tx_chan)) {
>>>> +               ret = PTR_ERR(host->tx_chan);
>>>> +               if (ret != -EPROBE_DEFER)
>>>> +                       pr_warn("Failed to request TX DMA channel.\n");
>>>> +               host->tx_chan = NULL;
>>>> +               return ret;
>>>> +       }
>>>> +
>>>> +       host->rx_chan = dma_request_chan(mmc->parent, "rx");
>>>> +       if (IS_ERR(host->rx_chan)) {
>>>> +               if (host->tx_chan) {
>>>> +                       dma_release_channel(host->tx_chan);
>>>> +                       host->tx_chan = NULL;
>>>> +               }
>>>> +
>>>> +               ret = PTR_ERR(host->rx_chan);
>>>> +               if (ret != -EPROBE_DEFER)
>>>> +                       pr_warn("Failed to request RX DMA channel.\n");
>>>> +               host->rx_chan = NULL;
>>>> +       }
>>>> +
>>>> +       return ret;
>>>> +}
>>>> +
>>>> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
>>>> +                                                  struct mmc_data *data)
>>>> +{
>>>> +       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 ret, i;
>>>> +       struct dma_async_tx_descriptor *desc;
>>>> +       struct mmc_data *data = cmd->data;
>>>> +       struct dma_chan *chan;
>>>> +       struct dma_slave_config cfg;
>>>> +       dma_cookie_t cookie;
>>>> +       int sg_cnt;
>>>> +
>>>> +       if (!host->mapbase)
>>>> +               return -EINVAL;
>>>> +
>>>> +       cfg.src_addr = host->mapbase + SDHCI_BUFFER;
>>>> +       cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
>>>> +       cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>>>> +       cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>>>> +       cfg.src_maxburst = data->blksz / 4;
>>>> +       cfg.dst_maxburst = data->blksz / 4;
>>>> +
>>>> +       /* Sanity check: all the SG entries must be aligned by block size. */
>>>> +       for (i = 0; i < data->sg_len; i++) {
>>>> +               if ((data->sg + i)->length % data->blksz)
>>>> +                       return -EINVAL;
>>>> +       }
>>>> +
>>>> +       chan = sdhci_external_dma_channel(host, data);
>>>> +
>>>> +       ret = dmaengine_slave_config(chan, &cfg);
>>>> +       if (ret)
>>>> +               return ret;
>>>> +
>>>> +       sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
>>>> +       if (sg_cnt <= 0)
>>>> +               return -EINVAL;
>>>> +
>>>> +       desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
>>>> +                                      mmc_get_dma_dir(data),
>>>> +                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
>>>> +       if (!desc)
>>>> +               return -EINVAL;
>>>> +
>>>> +       desc->callback = NULL;
>>>> +       desc->callback_param = NULL;
>>>> +
>>>> +       cookie = dmaengine_submit(desc);
>>>> +       if (cookie < 0)
>>>
>>> We usually use the DMA engine standard API: dma_submit_error() to
>>> validate the cookie.
>>>
>>
>> The if condition is doing the same thing as the API. Do we really
>> require it?
> 
> Yes, now it did the same thing. But in future if the DMA engine expand
> the cookie indication, which may break your current condition, but use
> dma_submit_error() is more safe, that will help to cover the internal
> cookie things. So I recommend to use the standard API as far as
> possible.

dma_cookie_t is typedefed to s32 currently, but it could change. The
cookie is for DMA engine internal tracking.
Clients should not use it directly for doing arithmetic on it.

> But if Ulf does not care about this, it's Okay for me too :)
> 

- Péter

Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-08 13:35         ` Peter Ujfalusi
@ 2020-01-10 13:16           ` Faiz Abbas
  0 siblings, 0 replies; 30+ messages in thread
From: Faiz Abbas @ 2020-01-10 13:16 UTC (permalink / raw)
  To: Peter Ujfalusi, Baolin Wang
  Cc: linux-omap, LKML, devicetree, linux-mmc, kishon, Adrian Hunter,
	mark.rutland, robh+dt, Ulf Hansson, tony

Hi Peter,

On 08/01/20 7:05 pm, Peter Ujfalusi wrote:
> Hi,
> 
> On 08/01/2020 11.29, Baolin Wang wrote:
>> Hi Faiz,
>>
>> On Wed, Jan 8, 2020 at 5:19 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>>
>>> Hi Baolin,
>>>
>>> On 08/01/20 6:58 am, Baolin Wang wrote:
>>>> Hi Faiz,
>>>>
>>>> On Mon, Jan 6, 2020 at 7:01 PM Faiz Abbas <faiz_abbas@ti.com> wrote:
>>>>>
>>>>> From: Chunyan Zhang <zhang.chunyan@linaro.org>
>>>>>
>>>>> Some standard SD host controllers can support both external dma
>>>>> controllers as well as ADMA/SDMA in which the SD host controller
>>>>> acts as DMA master. TI's omap controller is the case as an example.
>>>>>
>>>>> Currently the generic SDHCI code supports ADMA/SDMA integrated in
>>>>> the host controller but does not have any support for external DMA
>>>>> controllers implemented using dmaengine, meaning that custom code is
>>>>> needed for any systems that use an external DMA controller with SDHCI.
>>>>>
>>>>> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
>>>>> 1. Map scatterlists before dmaengine_prep_slave_sg()
>>>>> 2. Use dma_async() functions inside of the send_command() path and call
>>>>> terminate_sync() in non-atomic context in case of an error.
>>>>>
>>>>> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
>>>>> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>
>>>>> ---
>>>>>  drivers/mmc/host/Kconfig |   3 +
>>>>>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
>>>>>  drivers/mmc/host/sdhci.h |   8 ++
>>>>>  3 files changed, 237 insertions(+), 2 deletions(-)
>>>>>
>>>>> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
>>>>> index d06b2dfe3c95..adef971582a1 100644
>>>>> --- a/drivers/mmc/host/Kconfig
>>>>> +++ b/drivers/mmc/host/Kconfig
>>>>> @@ -1040,3 +1040,6 @@ config MMC_OWL
>>>>>         help
>>>>>           This selects support for the SD/MMC Host Controller on
>>>>>           Actions Semi Owl SoCs.
>>>>> +
>>>>> +config MMC_SDHCI_EXTERNAL_DMA
>>>>> +       bool
>>>>> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
>>>>> index f6999054abcf..8cc78c76bc3d 100644
>>>>> --- a/drivers/mmc/host/sdhci.c
>>>>> +++ b/drivers/mmc/host/sdhci.c
>>>>> @@ -10,6 +10,7 @@
>>>>>   */
>>>>>
>>>>>  #include <linux/delay.h>
>>>>> +#include <linux/dmaengine.h>
>>>>>  #include <linux/ktime.h>
>>>>>  #include <linux/highmem.h>
>>>>>  #include <linux/io.h>
>>>>> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>>>>>         sdhci_set_block_info(host, data);
>>>>>  }
>>>>>
>>>>> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
>>>>> +
>>>>> +static int sdhci_external_dma_init(struct sdhci_host *host)
>>>>> +{
>>>>> +       int ret = 0;
>>>>> +       struct mmc_host *mmc = host->mmc;
>>>>> +
>>>>> +       host->tx_chan = dma_request_chan(mmc->parent, "tx");
>>>>> +       if (IS_ERR(host->tx_chan)) {
>>>>> +               ret = PTR_ERR(host->tx_chan);
>>>>> +               if (ret != -EPROBE_DEFER)
>>>>> +                       pr_warn("Failed to request TX DMA channel.\n");
>>>>> +               host->tx_chan = NULL;
>>>>> +               return ret;
>>>>> +       }
>>>>> +
>>>>> +       host->rx_chan = dma_request_chan(mmc->parent, "rx");
>>>>> +       if (IS_ERR(host->rx_chan)) {
>>>>> +               if (host->tx_chan) {
>>>>> +                       dma_release_channel(host->tx_chan);
>>>>> +                       host->tx_chan = NULL;
>>>>> +               }
>>>>> +
>>>>> +               ret = PTR_ERR(host->rx_chan);
>>>>> +               if (ret != -EPROBE_DEFER)
>>>>> +                       pr_warn("Failed to request RX DMA channel.\n");
>>>>> +               host->rx_chan = NULL;
>>>>> +       }
>>>>> +
>>>>> +       return ret;
>>>>> +}
>>>>> +
>>>>> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
>>>>> +                                                  struct mmc_data *data)
>>>>> +{
>>>>> +       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 ret, i;
>>>>> +       struct dma_async_tx_descriptor *desc;
>>>>> +       struct mmc_data *data = cmd->data;
>>>>> +       struct dma_chan *chan;
>>>>> +       struct dma_slave_config cfg;
>>>>> +       dma_cookie_t cookie;
>>>>> +       int sg_cnt;
>>>>> +
>>>>> +       if (!host->mapbase)
>>>>> +               return -EINVAL;
>>>>> +
>>>>> +       cfg.src_addr = host->mapbase + SDHCI_BUFFER;
>>>>> +       cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
>>>>> +       cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>>>>> +       cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
>>>>> +       cfg.src_maxburst = data->blksz / 4;
>>>>> +       cfg.dst_maxburst = data->blksz / 4;
>>>>> +
>>>>> +       /* Sanity check: all the SG entries must be aligned by block size. */
>>>>> +       for (i = 0; i < data->sg_len; i++) {
>>>>> +               if ((data->sg + i)->length % data->blksz)
>>>>> +                       return -EINVAL;
>>>>> +       }
>>>>> +
>>>>> +       chan = sdhci_external_dma_channel(host, data);
>>>>> +
>>>>> +       ret = dmaengine_slave_config(chan, &cfg);
>>>>> +       if (ret)
>>>>> +               return ret;
>>>>> +
>>>>> +       sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
>>>>> +       if (sg_cnt <= 0)
>>>>> +               return -EINVAL;
>>>>> +
>>>>> +       desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
>>>>> +                                      mmc_get_dma_dir(data),
>>>>> +                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
>>>>> +       if (!desc)
>>>>> +               return -EINVAL;
>>>>> +
>>>>> +       desc->callback = NULL;
>>>>> +       desc->callback_param = NULL;
>>>>> +
>>>>> +       cookie = dmaengine_submit(desc);
>>>>> +       if (cookie < 0)
>>>>
>>>> We usually use the DMA engine standard API: dma_submit_error() to
>>>> validate the cookie.
>>>>
>>>
>>> The if condition is doing the same thing as the API. Do we really
>>> require it?
>>
>> Yes, now it did the same thing. But in future if the DMA engine expand
>> the cookie indication, which may break your current condition, but use
>> dma_submit_error() is more safe, that will help to cover the internal
>> cookie things. So I recommend to use the standard API as far as
>> possible.
> 
> dma_cookie_t is typedefed to s32 currently, but it could change. The
> cookie is for DMA engine internal tracking.
> Clients should not use it directly for doing arithmetic on it.
> 

In that case, I'll fix it with correct API.

Thanks,
Faiz

^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions
  2020-01-06 11:01 ` [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions Faiz Abbas
  2020-01-07  6:34   ` Baolin Wang
@ 2020-01-15 10:55   ` Adrian Hunter
  1 sibling, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 10:55 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> In preparation for adding external dma support, factor out data initialization,
> block info and mrq_done to their own functions.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Minor changes below, otherwise:

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci.c | 96 +++++++++++++++++++++++-----------------
>  1 file changed, 55 insertions(+), 41 deletions(-)
> 
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index 1b1c26da3fe0..f6999054abcf 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -1025,18 +1025,9 @@ static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
>  	}
>  }
>  
> -static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> +static void sdhci_initialize_data(struct sdhci_host *host,
> +				  struct mmc_data *data)
>  {
> -	struct mmc_data *data = cmd->data;
> -
> -	host->data_timeout = 0;
> -
> -	if (sdhci_data_line_cmd(cmd))
> -		sdhci_set_timeout(host, cmd);
> -
> -	if (!data)
> -		return;
> -
>  	WARN_ON(host->data);
>  
>  	/* Sanity checks */
> @@ -1048,6 +1039,36 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>  	host->data_early = 0;
>  	host->data->bytes_xfered = 0;
>  

Unnessary blank line

> +}
> +
> +static inline void sdhci_set_block_info(struct sdhci_host *host,
> +					struct mmc_data *data)
> +{
> +
> +	/* Set the DMA boundary value and block size */
> +	sdhci_writew(host,
> +		     SDHCI_MAKE_BLKSZ(host->sdma_boundary, host->data->blksz),

host->data -> data

> +		     SDHCI_BLOCK_SIZE);
> +	/*
> +	 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
> +	 * can be supported, in that case 16-bit block count register must be 0.
> +	 */
> +	if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
> +	    (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
> +		if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
> +			sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
> +		sdhci_writew(host, host->data->blocks, SDHCI_32BIT_BLK_CNT);

host->data -> data


> +	} else {
> +		sdhci_writew(host, host->data->blocks, SDHCI_BLOCK_COUNT);

host->data -> data

> +	}
> +}
> +
> +static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
> +{
> +	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;
> @@ -1133,22 +1154,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>  
>  	sdhci_set_transfer_irqs(host);
>  
> -	/* Set the DMA boundary value and block size */
> -	sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz),
> -		     SDHCI_BLOCK_SIZE);
> -
> -	/*
> -	 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
> -	 * can be supported, in that case 16-bit block count register must be 0.
> -	 */
> -	if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
> -	    (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
> -		if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
> -			sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
> -		sdhci_writew(host, data->blocks, SDHCI_32BIT_BLK_CNT);
> -	} else {
> -		sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
> -	}
> +	sdhci_set_block_info(host, data);
>  }
>  
>  static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
> @@ -1245,22 +1251,10 @@ static bool sdhci_needs_reset(struct sdhci_host *host, struct mmc_request *mrq)
>  		 (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST)));
>  }
>  
> -static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
> +static void sdhci_set_mrq_done(struct sdhci_host *host, struct mmc_request *mrq)
>  {
>  	int i;
>  
> -	if (host->cmd && host->cmd->mrq == mrq)
> -		host->cmd = NULL;
> -
> -	if (host->data_cmd && host->data_cmd->mrq == mrq)
> -		host->data_cmd = NULL;
> -
> -	if (host->data && host->data->mrq == mrq)
> -		host->data = NULL;
> -
> -	if (sdhci_needs_reset(host, mrq))
> -		host->pending_reset = true;
> -
>  	for (i = 0; i < SDHCI_MAX_MRQS; i++) {
>  		if (host->mrqs_done[i] == mrq) {
>  			WARN_ON(1);
> @@ -1276,6 +1270,23 @@ static void __sdhci_finish_mrq(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)
> +{
> +	if (host->cmd && host->cmd->mrq == mrq)
> +		host->cmd = NULL;
> +
> +	if (host->data_cmd && host->data_cmd->mrq == mrq)
> +		host->data_cmd = NULL;
> +
> +	if (host->data && host->data->mrq == mrq)
> +		host->data = NULL;
> +
> +	if (sdhci_needs_reset(host, mrq))
> +		host->pending_reset = true;
> +
> +	sdhci_set_mrq_done(host, mrq);
>  
>  	sdhci_del_timer(host, mrq);
>  
> @@ -1390,12 +1401,15 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
>  	}
>  
>  	host->cmd = cmd;
> +	host->data_timeout = 0;
>  	if (sdhci_data_line_cmd(cmd)) {
>  		WARN_ON(host->data_cmd);
>  		host->data_cmd = cmd;
> +		sdhci_set_timeout(host, cmd);
>  	}
>  
> -	sdhci_prepare_data(host, cmd);
> +	if (cmd->data)
> +		sdhci_prepare_data(host, cmd);
>  
>  	sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
>  
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices
  2020-01-06 11:01 ` [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices Faiz Abbas
  2020-01-08  1:28   ` Baolin Wang
@ 2020-01-15 12:01   ` Adrian Hunter
  1 sibling, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:01 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> From: Chunyan Zhang <zhang.chunyan@linaro.org>
> 
> Some standard SD host controllers can support both external dma
> controllers as well as ADMA/SDMA in which the SD host controller
> acts as DMA master. TI's omap controller is the case as an example.
> 
> Currently the generic SDHCI code supports ADMA/SDMA integrated in
> the host controller but does not have any support for external DMA
> controllers implemented using dmaengine, meaning that custom code is
> needed for any systems that use an external DMA controller with SDHCI.
> 
> Fixes by Faiz Abbas <faiz_abbas@ti.com>:
> 1. Map scatterlists before dmaengine_prep_slave_sg()
> 2. Use dma_async() functions inside of the send_command() path and call
> terminate_sync() in non-atomic context in case of an error.
> 
> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Notwithstanding comments from other people:

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/Kconfig |   3 +
>  drivers/mmc/host/sdhci.c | 228 ++++++++++++++++++++++++++++++++++++++-
>  drivers/mmc/host/sdhci.h |   8 ++
>  3 files changed, 237 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> index d06b2dfe3c95..adef971582a1 100644
> --- a/drivers/mmc/host/Kconfig
> +++ b/drivers/mmc/host/Kconfig
> @@ -1040,3 +1040,6 @@ config MMC_OWL
>  	help
>  	  This selects support for the SD/MMC Host Controller on
>  	  Actions Semi Owl SoCs.
> +
> +config MMC_SDHCI_EXTERNAL_DMA
> +	bool
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index f6999054abcf..8cc78c76bc3d 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -10,6 +10,7 @@
>   */
>  
>  #include <linux/delay.h>
> +#include <linux/dmaengine.h>
>  #include <linux/ktime.h>
>  #include <linux/highmem.h>
>  #include <linux/io.h>
> @@ -1157,6 +1158,188 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
>  	sdhci_set_block_info(host, data);
>  }
>  
> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
> +
> +static int sdhci_external_dma_init(struct sdhci_host *host)
> +{
> +	int ret = 0;
> +	struct mmc_host *mmc = host->mmc;
> +
> +	host->tx_chan = dma_request_chan(mmc->parent, "tx");
> +	if (IS_ERR(host->tx_chan)) {
> +		ret = PTR_ERR(host->tx_chan);
> +		if (ret != -EPROBE_DEFER)
> +			pr_warn("Failed to request TX DMA channel.\n");
> +		host->tx_chan = NULL;
> +		return ret;
> +	}
> +
> +	host->rx_chan = dma_request_chan(mmc->parent, "rx");
> +	if (IS_ERR(host->rx_chan)) {
> +		if (host->tx_chan) {
> +			dma_release_channel(host->tx_chan);
> +			host->tx_chan = NULL;
> +		}
> +
> +		ret = PTR_ERR(host->rx_chan);
> +		if (ret != -EPROBE_DEFER)
> +			pr_warn("Failed to request RX DMA channel.\n");
> +		host->rx_chan = NULL;
> +	}
> +
> +	return ret;
> +}
> +
> +static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
> +						   struct mmc_data *data)
> +{
> +	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 ret, i;
> +	struct dma_async_tx_descriptor *desc;
> +	struct mmc_data *data = cmd->data;
> +	struct dma_chan *chan;
> +	struct dma_slave_config cfg;
> +	dma_cookie_t cookie;
> +	int sg_cnt;
> +
> +	if (!host->mapbase)
> +		return -EINVAL;
> +
> +	cfg.src_addr = host->mapbase + SDHCI_BUFFER;
> +	cfg.dst_addr = host->mapbase + SDHCI_BUFFER;
> +	cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> +	cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
> +	cfg.src_maxburst = data->blksz / 4;
> +	cfg.dst_maxburst = data->blksz / 4;
> +
> +	/* Sanity check: all the SG entries must be aligned by block size. */
> +	for (i = 0; i < data->sg_len; i++) {
> +		if ((data->sg + i)->length % data->blksz)
> +			return -EINVAL;
> +	}
> +
> +	chan = sdhci_external_dma_channel(host, data);
> +
> +	ret = dmaengine_slave_config(chan, &cfg);
> +	if (ret)
> +		return ret;
> +
> +	sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
> +	if (sg_cnt <= 0)
> +		return -EINVAL;
> +
> +	desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
> +				       mmc_get_dma_dir(data),
> +				       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
> +	if (!desc)
> +		return -EINVAL;
> +
> +	desc->callback = NULL;
> +	desc->callback_param = NULL;
> +
> +	cookie = dmaengine_submit(desc);
> +	if (cookie < 0)
> +		ret = cookie;
> +
> +	return ret;
> +}
> +
> +static void sdhci_external_dma_release(struct sdhci_host *host)
> +{
> +	if (host->tx_chan) {
> +		dma_release_channel(host->tx_chan);
> +		host->tx_chan = NULL;
> +	}
> +
> +	if (host->rx_chan) {
> +		dma_release_channel(host->rx_chan);
> +		host->rx_chan = NULL;
> +	}
> +
> +	sdhci_switch_external_dma(host, false);
> +}
> +
> +static void __sdhci_external_dma_prepare_data(struct sdhci_host *host,
> +					      struct mmc_command *cmd)
> +{
> +	struct mmc_data *data = cmd->data;
> +
> +	sdhci_initialize_data(host, data);
> +
> +	host->flags |= SDHCI_REQ_USE_DMA;
> +	sdhci_set_transfer_irqs(host);
> +
> +	sdhci_set_block_info(host, data);
> +}
> +
> +static void sdhci_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_prepare_data(host, cmd);
> +	}
> +}
> +
> +static void sdhci_external_dma_pre_transfer(struct sdhci_host *host,
> +					    struct mmc_command *cmd)
> +{
> +	struct dma_chan *chan;
> +
> +	if (!cmd->data)
> +		return;
> +
> +	chan = sdhci_external_dma_channel(host, cmd->data);
> +	if (chan)
> +		dma_async_issue_pending(chan);
> +}
> +
> +#else
> +
> +static inline int sdhci_external_dma_init(struct sdhci_host *host)
> +{
> +	return -EOPNOTSUPP;
> +}
> +
> +static inline void sdhci_external_dma_release(struct sdhci_host *host)
> +{
> +}
> +
> +static inline void sdhci_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)
> +{
> +}
> +
> +static inline struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host,
> +							  struct mmc_data *data)
> +{
> +	return NULL;
> +}
> +
> +#endif
> +
> +void sdhci_switch_external_dma(struct sdhci_host *host, bool en)
> +{
> +	host->use_external_dma = en;
> +}
> +EXPORT_SYMBOL_GPL(sdhci_switch_external_dma);
> +
>  static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
>  				    struct mmc_request *mrq)
>  {
> @@ -1408,8 +1591,12 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
>  		sdhci_set_timeout(host, cmd);
>  	}
>  
> -	if (cmd->data)
> -		sdhci_prepare_data(host, cmd);
> +	if (cmd->data) {
> +		if (host->use_external_dma)
> +			sdhci_external_dma_prepare_data(host, cmd);
> +		else
> +			sdhci_prepare_data(host, cmd);
> +	}
>  
>  	sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
>  
> @@ -1451,6 +1638,9 @@ void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
>  		timeout += 10 * HZ;
>  	sdhci_mod_timer(host, cmd->mrq, timeout);
>  
> +	if (host->use_external_dma)
> +		sdhci_external_dma_pre_transfer(host, cmd);
> +
>  	sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
>  }
>  EXPORT_SYMBOL_GPL(sdhci_send_command);
> @@ -2675,6 +2865,17 @@ static bool sdhci_request_done(struct sdhci_host *host)
>  	if (host->flags & SDHCI_REQ_USE_DMA) {
>  		struct mmc_data *data = mrq->data;
>  
> +		if (host->use_external_dma && data &&
> +		    (mrq->cmd->error || data->error)) {
> +			struct dma_chan *chan = sdhci_external_dma_channel(host, data);
> +
> +			host->mrqs_done[i] = NULL;
> +			spin_unlock_irqrestore(&host->lock, flags);
> +			dmaengine_terminate_sync(chan);
> +			spin_lock_irqsave(&host->lock, flags);
> +			sdhci_set_mrq_done(host, mrq);
> +		}
> +
>  		if (data && data->host_cookie == COOKIE_MAPPED) {
>  			if (host->bounce_buffer) {
>  				/*
> @@ -3810,6 +4011,21 @@ int sdhci_setup_host(struct sdhci_host *host)
>  	if (sdhci_can_64bit_dma(host))
>  		host->flags |= SDHCI_USE_64_BIT_DMA;
>  
> +	if (host->use_external_dma) {
> +		ret = sdhci_external_dma_init(host);
> +		if (ret == -EPROBE_DEFER)
> +			goto unreg;
> +		/*
> +		 * Fall back to use the DMA/PIO integrated in standard SDHCI
> +		 * instead of external DMA devices.
> +		 */
> +		else if (ret)
> +			sdhci_switch_external_dma(host, false);
> +		/* Disable internal DMA sources */
> +		else
> +			host->flags &= ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA);
> +	}
> +
>  	if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
>  		if (host->ops->set_dma_mask)
>  			ret = host->ops->set_dma_mask(host);
> @@ -4290,6 +4506,10 @@ void sdhci_cleanup_host(struct sdhci_host *host)
>  		dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
>  				  host->adma_table_sz, host->align_buffer,
>  				  host->align_addr);
> +
> +	if (host->use_external_dma)
> +		sdhci_external_dma_release(host);
> +
>  	host->adma_table = NULL;
>  	host->align_buffer = NULL;
>  }
> @@ -4335,6 +4555,7 @@ int __sdhci_add_host(struct sdhci_host *host)
>  
>  	pr_info("%s: SDHCI controller on %s [%s] using %s\n",
>  		mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
> +		host->use_external_dma ? "External DMA" :
>  		(host->flags & SDHCI_USE_ADMA) ?
>  		(host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
>  		(host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
> @@ -4423,6 +4644,9 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
>  				  host->adma_table_sz, host->align_buffer,
>  				  host->align_addr);
>  
> +	if (host->use_external_dma)
> +		sdhci_external_dma_release(host);
> +
>  	host->adma_table = NULL;
>  	host->align_buffer = NULL;
>  }
> diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
> index fe83ece6965b..3166b3ecef89 100644
> --- a/drivers/mmc/host/sdhci.h
> +++ b/drivers/mmc/host/sdhci.h
> @@ -487,6 +487,7 @@ struct sdhci_host {
>  
>  	int irq;		/* Device IRQ */
>  	void __iomem *ioaddr;	/* Mapped address */
> +	phys_addr_t mapbase;	/* physical address base */
>  	char *bounce_buffer;	/* For packing SDMA reads/writes */
>  	dma_addr_t bounce_addr;
>  	unsigned int bounce_buffer_size;
> @@ -535,6 +536,7 @@ struct sdhci_host {
>  	bool pending_reset;	/* Cmd/data reset is pending */
>  	bool irq_wake_enabled;	/* IRQ wakeup is enabled */
>  	bool v4_mode;		/* Host Version 4 Enable */
> +	bool use_external_dma;	/* Host selects to use external DMA */
>  
>  	struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];	/* Requests done */
>  	struct mmc_command *cmd;	/* Current command */
> @@ -564,6 +566,11 @@ struct sdhci_host {
>  	struct timer_list timer;	/* Timer for timeouts */
>  	struct timer_list data_timer;	/* Timer for data timeouts */
>  
> +#if IS_ENABLED(CONFIG_MMC_SDHCI_EXTERNAL_DMA)
> +	struct dma_chan *rx_chan;
> +	struct dma_chan *tx_chan;
> +#endif
> +
>  	u32 caps;		/* CAPABILITY_0 */
>  	u32 caps1;		/* CAPABILITY_1 */
>  	bool read_caps;		/* Capability flags have been read */
> @@ -795,5 +802,6 @@ void sdhci_end_tuning(struct sdhci_host *host);
>  void sdhci_reset_tuning(struct sdhci_host *host);
>  void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
>  void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
> +void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
>  
>  #endif /* __SDHCI_HW_H */
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma
  2020-01-06 11:01 ` [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma Faiz Abbas
@ 2020-01-15 12:02   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:02 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> From: Chunyan Zhang <zhang.chunyan@linaro.org>
> 
> sdhci-omap can support both external dma controller via dmaengine framework
> as well as ADMA which standard SD host controller provides.
> 
> Fixes by Faiz Abbas <fazi_abbas@ti.com>:
> 1. Switch to DMA slave mode when using external DMA
> 2. Add offset to mapbase
> 
> Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/Kconfig      |  1 +
>  drivers/mmc/host/sdhci-omap.c | 16 +++++++++++++++-
>  2 files changed, 16 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> index adef971582a1..2c0d90b9383e 100644
> --- a/drivers/mmc/host/Kconfig
> +++ b/drivers/mmc/host/Kconfig
> @@ -1010,6 +1010,7 @@ config MMC_SDHCI_OMAP
>  	depends on MMC_SDHCI_PLTFM && OF
>  	select THERMAL
>  	imply TI_SOC_THERMAL
> +	select MMC_SDHCI_EXTERNAL_DMA if DMA_ENGINE
>  	help
>  	  This selects the Secure Digital Host Controller Interface (SDHCI)
>  	  support present in TI's DRA7 SOCs. The controller supports
> diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
> index 083e7e053c95..84d85aa743da 100644
> --- a/drivers/mmc/host/sdhci-omap.c
> +++ b/drivers/mmc/host/sdhci-omap.c
> @@ -685,7 +685,11 @@ static int sdhci_omap_enable_dma(struct sdhci_host *host)
>  	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
>  
>  	reg = sdhci_omap_readl(omap_host, SDHCI_OMAP_CON);
> -	reg |= CON_DMA_MASTER;
> +	reg &= ~CON_DMA_MASTER;
> +	/* Switch to DMA slave mode when using external DMA */
> +	if (!host->use_external_dma)
> +		reg |= CON_DMA_MASTER;
> +
>  	sdhci_omap_writel(omap_host, SDHCI_OMAP_CON, reg);
>  
>  	return 0;
> @@ -1037,6 +1041,7 @@ static int sdhci_omap_probe(struct platform_device *pdev)
>  	const struct of_device_id *match;
>  	struct sdhci_omap_data *data;
>  	const struct soc_device_attribute *soc;
> +	struct resource *regs;
>  
>  	match = of_match_device(omap_sdhci_match, dev);
>  	if (!match)
> @@ -1049,6 +1054,10 @@ static int sdhci_omap_probe(struct platform_device *pdev)
>  	}
>  	offset = data->offset;
>  
> +	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	if (!regs)
> +		return -ENXIO;
> +
>  	host = sdhci_pltfm_init(pdev, &sdhci_omap_pdata,
>  				sizeof(*omap_host));
>  	if (IS_ERR(host)) {
> @@ -1065,6 +1074,7 @@ static int sdhci_omap_probe(struct platform_device *pdev)
>  	omap_host->timing = MMC_TIMING_LEGACY;
>  	omap_host->flags = data->flags;
>  	host->ioaddr += offset;
> +	host->mapbase = regs->start + offset;
>  
>  	mmc = host->mmc;
>  	sdhci_get_of_property(pdev);
> @@ -1134,6 +1144,10 @@ static int sdhci_omap_probe(struct platform_device *pdev)
>  	host->mmc_host_ops.execute_tuning = sdhci_omap_execute_tuning;
>  	host->mmc_host_ops.enable_sdio_irq = sdhci_omap_enable_sdio_irq;
>  
> +	/* Switch to external DMA only if there is the "dmas" property */
> +	if (of_find_property(dev->of_node, "dmas", NULL))
> +		sdhci_switch_external_dma(host, true);
> +
>  	ret = sdhci_setup_host(host);
>  	if (ret)
>  		goto err_put_sync;
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static
  2020-01-06 11:01 ` [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static Faiz Abbas
@ 2020-01-15 12:03   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:03 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> Export sdhci_set_timeout_irq() so that it is accessible from platform drivers.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci.c | 3 ++-
>  drivers/mmc/host/sdhci.h | 1 +
>  2 files changed, 3 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index 8cc78c76bc3d..56f46bd7cdad 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -993,7 +993,7 @@ static void sdhci_set_transfer_irqs(struct sdhci_host *host)
>  	sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
>  }
>  
> -static void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
> +void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
>  {
>  	if (enable)
>  		host->ier |= SDHCI_INT_DATA_TIMEOUT;
> @@ -1002,6 +1002,7 @@ static void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
>  	sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
>  	sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
>  }
> +EXPORT_SYMBOL_GPL(sdhci_set_data_timeout_irq);
>  
>  static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
>  {
> diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
> index 3166b3ecef89..928c6f35fcad 100644
> --- a/drivers/mmc/host/sdhci.h
> +++ b/drivers/mmc/host/sdhci.h
> @@ -803,5 +803,6 @@ void sdhci_reset_tuning(struct sdhci_host *host);
>  void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
>  void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
>  void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
> +void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable);
>  
>  #endif /* __SDHCI_HW_H */
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout()
  2020-01-06 11:01 ` [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout() Faiz Abbas
@ 2020-01-15 12:04   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:04 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> Refactor sdhci_set_timeout() such that platform drivers can do some
> functionality in a set_timeout() callback and then call
> __sdhci_set_timeout() to complete the operation.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci.c | 36 +++++++++++++++++++-----------------
>  drivers/mmc/host/sdhci.h |  1 +
>  2 files changed, 20 insertions(+), 17 deletions(-)
> 
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index 56f46bd7cdad..adb3e8ccefb8 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -1004,27 +1004,29 @@ void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
>  }
>  EXPORT_SYMBOL_GPL(sdhci_set_data_timeout_irq);
>  
> -static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
> +void __sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
>  {
> -	u8 count;
> +	bool too_big = false;
> +	u8 count = sdhci_calc_timeout(host, cmd, &too_big);
>  
> -	if (host->ops->set_timeout) {
> -		host->ops->set_timeout(host, cmd);
> -	} else {
> -		bool too_big = false;
> -
> -		count = sdhci_calc_timeout(host, cmd, &too_big);
> +	if (too_big &&
> +	    host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) {
> +		sdhci_calc_sw_timeout(host, cmd);
> +		sdhci_set_data_timeout_irq(host, false);
> +	} else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) {
> +		sdhci_set_data_timeout_irq(host, true);
> +	}
>  
> -		if (too_big &&
> -		    host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) {
> -			sdhci_calc_sw_timeout(host, cmd);
> -			sdhci_set_data_timeout_irq(host, false);
> -		} else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) {
> -			sdhci_set_data_timeout_irq(host, true);
> -		}
> +	sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
> +}
> +EXPORT_SYMBOL_GPL(__sdhci_set_timeout);
>  
> -		sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
> -	}
> +static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
> +{
> +	if (host->ops->set_timeout)
> +		host->ops->set_timeout(host, cmd);
> +	else
> +		__sdhci_set_timeout(host, cmd);
>  }
>  
>  static void sdhci_initialize_data(struct sdhci_host *host,
> diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
> index 928c6f35fcad..1fe230c2ed84 100644
> --- a/drivers/mmc/host/sdhci.h
> +++ b/drivers/mmc/host/sdhci.h
> @@ -804,5 +804,6 @@ void sdhci_send_tuning(struct sdhci_host *host, u32 opcode);
>  void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode);
>  void sdhci_switch_external_dma(struct sdhci_host *host, bool en);
>  void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable);
> +void __sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd);
>  
>  #endif /* __SDHCI_HW_H */
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase
  2020-01-06 11:01 ` [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase Faiz Abbas
@ 2020-01-15 12:05   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:05 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> Disable data timeout interrupt during an erase operation
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci-omap.c | 11 +++++++++++
>  1 file changed, 11 insertions(+)
> 
> diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
> index 84d85aa743da..1f05c8e98d62 100644
> --- a/drivers/mmc/host/sdhci-omap.c
> +++ b/drivers/mmc/host/sdhci-omap.c
> @@ -7,6 +7,7 @@
>   */
>  
>  #include <linux/delay.h>
> +#include <linux/mmc/mmc.h>
>  #include <linux/mmc/slot-gpio.h>
>  #include <linux/module.h>
>  #include <linux/of.h>
> @@ -827,6 +828,15 @@ static u32 sdhci_omap_irq(struct sdhci_host *host, u32 intmask)
>  	return intmask;
>  }
>  
> +static void sdhci_omap_set_timeout(struct sdhci_host *host,
> +				   struct mmc_command *cmd)
> +{
> +	if (cmd->opcode == MMC_ERASE)
> +		sdhci_set_data_timeout_irq(host, false);
> +
> +	__sdhci_set_timeout(host, cmd);
> +}
> +
>  static struct sdhci_ops sdhci_omap_ops = {
>  	.set_clock = sdhci_omap_set_clock,
>  	.set_power = sdhci_omap_set_power,
> @@ -838,6 +848,7 @@ static struct sdhci_ops sdhci_omap_ops = {
>  	.reset = sdhci_omap_reset,
>  	.set_uhs_signaling = sdhci_omap_set_uhs_signaling,
>  	.irq = sdhci_omap_irq,
> +	.set_timeout = sdhci_omap_set_timeout,
>  };
>  
>  static int sdhci_omap_set_capabilities(struct sdhci_omap_host *omap_host)
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 09/11] mmc: sdhci-omap: Add ti,needs-special-reset property
  2020-01-06 11:01 ` [PATCH v4 09/11] mmc: sdhci-omap: Add " Faiz Abbas
@ 2020-01-15 12:14   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:14 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> Some omap controllers need software to monitor a 0->1->0 for software
> reset. Add a ti,needs-special-reset property to indicate this and use
> the special_reset member to indicate when a controller needs this.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci-omap.c | 24 ++++++++++++++++++++++++
>  1 file changed, 24 insertions(+)
> 
> diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
> index 1f05c8e98d62..34df30edd450 100644
> --- a/drivers/mmc/host/sdhci-omap.c
> +++ b/drivers/mmc/host/sdhci-omap.c
> @@ -107,6 +107,7 @@ struct sdhci_omap_host {
>  	struct pinctrl		*pinctrl;
>  	struct pinctrl_state	**pinctrl_state;
>  	bool			is_tuning;
> +	bool			special_reset;
>  };
>  
>  static void sdhci_omap_start_clock(struct sdhci_omap_host *omap_host);
> @@ -779,15 +780,35 @@ static void sdhci_omap_set_uhs_signaling(struct sdhci_host *host,
>  	sdhci_omap_start_clock(omap_host);
>  }
>  
> +#define MMC_TIMEOUT_US		20000		/* 20000 micro Sec */
>  static void sdhci_omap_reset(struct sdhci_host *host, u8 mask)
>  {
>  	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
>  	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
> +	unsigned long limit = MMC_TIMEOUT_US;
> +	unsigned long i = 0;
>  
>  	/* Don't reset data lines during tuning operation */
>  	if (omap_host->is_tuning)
>  		mask &= ~SDHCI_RESET_DATA;
>  
> +	if (omap_host->special_reset) {
> +		sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
> +		while ((!(sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask)) &&
> +		       (i++ < limit))
> +			udelay(1);
> +		i = 0;
> +		while ((sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) &&
> +		       (i++ < limit))
> +			udelay(1);
> +
> +		if (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask)
> +			dev_err(mmc_dev(host->mmc),
> +				"Timeout waiting on controller reset in %s\n",
> +				__func__);
> +		return;
> +	}
> +
>  	sdhci_reset(host, mask);
>  }
>  
> @@ -1107,6 +1128,9 @@ static int sdhci_omap_probe(struct platform_device *pdev)
>  	if (!mmc_can_gpio_ro(mmc))
>  		mmc->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
>  
> +	if (of_find_property(dev->of_node, "ti,needs-special-reset", NULL))
> +		omap_host->special_reset = true;
> +
>  	pltfm_host->clk = devm_clk_get(dev, "fck");
>  	if (IS_ERR(pltfm_host->clk)) {
>  		ret = PTR_ERR(pltfm_host->clk);
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

* Re: [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles
  2020-01-06 11:01 ` [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles Faiz Abbas
@ 2020-01-15 12:14   ` Adrian Hunter
  0 siblings, 0 replies; 30+ messages in thread
From: Adrian Hunter @ 2020-01-15 12:14 UTC (permalink / raw)
  To: Faiz Abbas, linux-omap, linux-kernel, devicetree, linux-mmc
  Cc: kishon, mark.rutland, robh+dt, ulf.hansson, tony

On 6/01/20 1:01 pm, Faiz Abbas wrote:
> Add support for new compatible for TI's am335x and am437x devices.
> 
> Signed-off-by: Faiz Abbas <faiz_abbas@ti.com>

Acked-by: Adrian Hunter <adrian.hunter@intel.com>

> ---
>  drivers/mmc/host/sdhci-omap.c | 10 ++++++++++
>  1 file changed, 10 insertions(+)
> 
> diff --git a/drivers/mmc/host/sdhci-omap.c b/drivers/mmc/host/sdhci-omap.c
> index 34df30edd450..4d7026daa8cd 100644
> --- a/drivers/mmc/host/sdhci-omap.c
> +++ b/drivers/mmc/host/sdhci-omap.c
> @@ -919,6 +919,14 @@ static const struct sdhci_omap_data k2g_data = {
>  	.offset = 0x200,
>  };
>  
> +static const struct sdhci_omap_data am335_data = {
> +	.offset = 0x200,
> +};
> +
> +static const struct sdhci_omap_data am437_data = {
> +	.offset = 0x200,
> +};
> +
>  static const struct sdhci_omap_data dra7_data = {
>  	.offset = 0x200,
>  	.flags	= SDHCI_OMAP_REQUIRE_IODELAY,
> @@ -927,6 +935,8 @@ static const struct sdhci_omap_data dra7_data = {
>  static const struct of_device_id omap_sdhci_match[] = {
>  	{ .compatible = "ti,dra7-sdhci", .data = &dra7_data },
>  	{ .compatible = "ti,k2g-sdhci", .data = &k2g_data },
> +	{ .compatible = "ti,am335-sdhci", .data = &am335_data },
> +	{ .compatible = "ti,am437-sdhci", .data = &am437_data },
>  	{},
>  };
>  MODULE_DEVICE_TABLE(of, omap_sdhci_match);
> 


^ permalink raw reply	[flat|nested] 30+ messages in thread

end of thread, back to index

Thread overview: 30+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-01-06 11:01 [PATCH v4 00/11] Port am335x and am437x devices to sdhci-omap Faiz Abbas
2020-01-06 11:01 ` [PATCH v4 01/11] dt-bindings: sdhci-omap: Add properties for using external dma Faiz Abbas
2020-01-06 11:01 ` [PATCH v4 02/11] mmc: sdhci: Factor out some operations set to their own functions Faiz Abbas
2020-01-07  6:34   ` Baolin Wang
2020-01-07  7:22     ` Faiz Abbas
2020-01-08  1:32       ` Baolin Wang
2020-01-15 10:55   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 03/11] mmc: sdhci: add support for using external DMA devices Faiz Abbas
2020-01-08  1:28   ` Baolin Wang
2020-01-08  9:20     ` Faiz Abbas
2020-01-08  9:29       ` Baolin Wang
2020-01-08 13:35         ` Peter Ujfalusi
2020-01-10 13:16           ` Faiz Abbas
2020-01-15 12:01   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 04/11] mmc: sdhci-omap: Add using external dma Faiz Abbas
2020-01-15 12:02   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 05/11] mmc: sdhci: Convert sdhci_set_timeout_irq() to non-static Faiz Abbas
2020-01-15 12:03   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 06/11] mmc: sdhci: Refactor sdhci_set_timeout() Faiz Abbas
2020-01-15 12:04   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 07/11] mmc: sdhci-omap: Disable data timeout interrupt during erase Faiz Abbas
2020-01-15 12:05   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 08/11] dt-bindings: sdhci-omap: Add documentation for ti,needs-special-reset property Faiz Abbas
2020-01-06 22:03   ` Rob Herring
2020-01-07 11:18     ` Faiz Abbas
2020-01-06 11:01 ` [PATCH v4 09/11] mmc: sdhci-omap: Add " Faiz Abbas
2020-01-15 12:14   ` Adrian Hunter
2020-01-06 11:01 ` [PATCH v4 10/11] dt-bindings: sdhci-omap: Add am335x and am437x specific bindings Faiz Abbas
2020-01-06 11:01 ` [PATCH v4 11/11] mmc: sdhci-omap: Add am335x and am437x specific compatibles Faiz Abbas
2020-01-15 12:14   ` Adrian Hunter

Linux-mmc Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-mmc/0 linux-mmc/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-mmc linux-mmc/ https://lore.kernel.org/linux-mmc \
		linux-mmc@vger.kernel.org
	public-inbox-index linux-mmc

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-mmc


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git