Skip to contentSkip to conversation

Add MMC software queue support

PATCH Superseded Baolin Wang 2 participants 13 messages Oct 29, 2019 – Nov 8, 2019

Subsystems (3)

v5 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

v5 cover Add MMC software queue support

Hi All,

Now the MMC read/write stack will always wait for previous request is completed by mmc_blk_rw_wait(), before sending a new request to hardware, or queue a work to complete request, that will bring context switching overhead, especially for high I/O per second rates, to affect the IO performance.

Thus this patch set will introduce the MMC software command queue support based on command queue engine's interfaces, and set the queue depth as 32 to allow more requests can be be prepared, merged and inserted into IO scheduler, but we only allow 2 requests in flight, that is enough to let the irq handler always trigger the next request without a context switch, as well as avoiding a long latency.

Moreover we can expand the MMC software queue interface to support MMC packed request or packed command instead of adding new interfaces, according to previosus discussion.

Below are some comparison data with fio tool. The fio command I used is like below with changing the '--rw' parameter and enabling the direct IO flag to measure the actual hardware transfer speed in 4K block size.

./fio --filename=/dev/mmcblk0p30 --direct=1 --iodepth=20 --rw=read --bs=4K --size=1G --group_reporting --numjobs=20 --name=test_read

My eMMC card working at HS400 Enhanced strobe mode:

[    2.229856] mmc0: new HS400 Enhanced strobe MMC card at address 0001
[    2.237566] mmcblk0: mmc0:0001 HBG4a2 29.1 GiB 
[    2.242621] mmcblk0boot0: mmc0:0001 HBG4a2 partition 1 4.00 MiB
[    2.249110] mmcblk0boot1: mmc0:0001 HBG4a2 partition 2 4.00 MiB
[    2.255307] mmcblk0rpmb: mmc0:0001 HBG4a2 partition 3 4.00 MiB, chardev (248:0)

1. Without MMC software queue
I tested 5 times for each case and output a average speed.

1) Sequential read:
Speed: 59.4MiB/s, 63.4MiB/s, 57.5MiB/s, 57.2MiB/s, 60.8MiB/s Average speed: 59.66MiB/s

2) Random read:
Speed: 26.9MiB/s, 26.9MiB/s, 27.1MiB/s, 27.1MiB/s, 27.2MiB/s Average speed: 27.04MiB/s

3) Sequential write:
Speed: 71.6MiB/s, 72.5MiB/s, 72.2MiB/s, 64.6MiB/s, 67.5MiB/s Average speed: 69.68MiB/s

4) Random write:
Speed: 36.3MiB/s, 35.4MiB/s, 38.6MiB/s, 34MiB/s, 35.5MiB/s Average speed: 35.96MiB/s

2. With MMC software queue
I tested 5 times for each case and output a average speed.

1) Sequential read:
Speed: 59.2MiB/s, 60.4MiB/s, 63.6MiB/s, 60.3MiB/s, 59.9MiB/s Average speed: 60.68MiB/s

2) Random read:
Speed: 31.3MiB/s, 31.4MiB/s, 31.5MiB/s, 31.3MiB/s, 31.3MiB/s Average speed: 31.36MiB/s

3) Sequential write:
Speed: 71MiB/s, 71.8MiB/s, 72.3MiB/s, 72.2MiB/s, 71MiB/s Average speed: 71.66MiB/s

4) Random write:
Speed: 68.9MiB/s, 68.7MiB/s, 68.8MiB/s, 68.6MiB/s, 68.8MiB/s Average speed: 68.76MiB/s

Form above data, we can see the MMC software queue can help to improve some performance obviously for random read and write, though no obvious improvement for sequential read and write.

Any comments are welcome. Thanks a lot.

Changes from v4:
- Add a seperate patch to introduce a variable to defer to complete data requests for some host drivers, when using host software queue.

Changes from v3:
- Use host software queue instead of sqhci.
- Fix random config building issue.
- Change queue depth to 32, but still only allow 2 requests in flight.
- Update the testing data.

Changes from v2:
- Remove reference to 'struct cqhci_host' and 'struct cqhci_slot', instead adding 'struct sqhci_host', which is only used by software queue.

Changes from v1:
- Add request_done ops for sdhci_ops.
- Replace virtual command queue with software queue for functions and variables.
- Rename the software queue file and add sqhci.h header file.

Baolin Wang (4):
mmc: Add MMC host software queue support
mmc: host: sdhci: Add request_done ops for struct sdhci_ops
mmc: host: sdhci-sprd: Add software queue support
mmc: host: sdhci: Add a variable to defer to complete data requests
if needed

 drivers/mmc/core/block.c      |   61 ++++++++
 drivers/mmc/core/mmc.c        |   13 +-
 drivers/mmc/core/queue.c      |   33 +++-
 drivers/mmc/host/Kconfig      |    8 +
 drivers/mmc/host/Makefile     |    1 +
 drivers/mmc/host/mmc_hsq.c    |  344 +++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/host/mmc_hsq.h    |   30 ++++
 drivers/mmc/host/sdhci-sprd.c |   26 ++++
 drivers/mmc/host/sdhci.c      |   14 +-
 drivers/mmc/host/sdhci.h      |    3 +
 include/linux/mmc/host.h      |    3 +
 11 files changed, 523 insertions(+), 13 deletions(-)
 create mode 100644 drivers/mmc/host/mmc_hsq.c
 create mode 100644 drivers/mmc/host/mmc_hsq.h
Signature · 1 line
1.7.9.5
#1 lore raw

PATCH v5 1/4 mmc: Add MMC host software queue support

Now the MMC read/write stack will always wait for previous request is completed by mmc_blk_rw_wait(), before sending a new request to hardware, or queue a work to complete request, that will bring context switching overhead, especially for high I/O per second rates, to affect the IO performance.

Thus this patch introduces MMC software queue interface based on the hardware command queue engine's interfaces, which is similar with the hardware command queue engine's idea, that can remove the context switching. Moreover we set the default queue depth as 32 for software queue, which allows more requests to be prepared, merged and inserted into IO scheduler to improve performance, but we only allow 2 requests in flight, that is enough to let the irq handler always trigger the next request without a context switch, as well as avoiding a long latency.

Quoted 1 line

From the fio testing data in cover letter, we can see the software

queue can improve some performance with 4K block size, increasing about 16% for random read, increasing about 90% for random write, though no obvious improvement for sequential read and write.

Moreover we can expand the software queue interface to support MMC packed request or packed command in future.

---
 drivers/mmc/core/block.c   |   61 ++++++++
 drivers/mmc/core/mmc.c     |   13 +-
 drivers/mmc/core/queue.c   |   33 ++++-
 drivers/mmc/host/Kconfig   |    7 +
 drivers/mmc/host/Makefile  |    1 +
 drivers/mmc/host/mmc_hsq.c |  344 ++++++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/host/mmc_hsq.h |   30 ++++
 include/linux/mmc/host.h   |    3 +
 8 files changed, 482 insertions(+), 10 deletions(-)
 create mode 100644 drivers/mmc/host/mmc_hsq.c
 create mode 100644 drivers/mmc/host/mmc_hsq.h
drivers/mmc/core/block.c +61 -0
index 2c71a43..870462c 100644
@@ -168,6 +168,11 @@ struct mmc_rpmb_data {
 
 static inline int mmc_blk_part_switch(struct mmc_card *card,
 				      unsigned int part_type);
+static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
+			       struct mmc_card *card,
+			       int disable_multi,
+			       struct mmc_queue *mq);
+static void mmc_blk_swq_req_done(struct mmc_request *mrq);
 
 static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
 {
@@ -1569,9 +1574,30 @@ static int mmc_blk_cqe_issue_flush(struct mmc_queue *mq, struct request *req)
 	return mmc_blk_cqe_start_req(mq->card->host, mrq);
 }
 
+static int mmc_blk_swq_issue_rw_rq(struct mmc_queue *mq, struct request *req)
+{
+	struct mmc_queue_req *mqrq = req_to_mmc_queue_req(req);
+	struct mmc_host *host = mq->card->host;
+	int err;
+
+	mmc_blk_rw_rq_prep(mqrq, mq->card, 0, mq);
+	mqrq->brq.mrq.done = mmc_blk_swq_req_done;
+	mmc_pre_req(host, &mqrq->brq.mrq);
+
+	err = mmc_cqe_start_req(host, &mqrq->brq.mrq);
+	if (err)
+		mmc_post_req(host, &mqrq->brq.mrq, err);
+
+	return err;
+}
+
 static int mmc_blk_cqe_issue_rw_rq(struct mmc_queue *mq, struct request *req)
 {
 	struct mmc_queue_req *mqrq = req_to_mmc_queue_req(req);
+	struct mmc_host *host = mq->card->host;
+
+	if (host->swq_enabled)
+		return mmc_blk_swq_issue_rw_rq(mq, req);
 
 	mmc_blk_data_prep(mq, mqrq, 0, NULL, NULL);
 
@@ -1957,6 +1983,41 @@ static void mmc_blk_urgent_bkops(struct mmc_queue *mq,
 		mmc_run_bkops(mq->card);
 }
 
+static void mmc_blk_swq_req_done(struct mmc_request *mrq)
+{
+	struct mmc_queue_req *mqrq =
+		container_of(mrq, struct mmc_queue_req, brq.mrq);
+	struct request *req = mmc_queue_req_to_req(mqrq);
+	struct request_queue *q = req->q;
+	struct mmc_queue *mq = q->queuedata;
+	struct mmc_host *host = mq->card->host;
+	unsigned long flags;
+
+	if (mmc_blk_rq_error(&mqrq->brq) ||
+	    mmc_blk_urgent_bkops_needed(mq, mqrq)) {
+		spin_lock_irqsave(&mq->lock, flags);
+		mq->recovery_needed = true;
+		mq->recovery_req = req;
+		spin_unlock_irqrestore(&mq->lock, flags);
+
+		host->cqe_ops->cqe_recovery_start(host);
+
+		schedule_work(&mq->recovery_work);
+		return;
+	}
+
+	mmc_blk_rw_reset_success(mq, req);
+
+	/*
+	 * Block layer timeouts race with completions which means the normal
+	 * completion path cannot be used during recovery.
+	 */
+	if (mq->in_recovery)
+		mmc_blk_cqe_complete_rq(mq, req);
+	else
+		blk_mq_complete_request(req);
+}
+
 void mmc_blk_mq_complete(struct request *req)
 {
 	struct mmc_queue *mq = req->q->queuedata;
drivers/mmc/core/mmc.c +10 -3
index c880489..8eac1a2 100644
@@ -1852,15 +1852,22 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
 	 */
 	card->reenable_cmdq = card->ext_csd.cmdq_en;
 
-	if (card->ext_csd.cmdq_en && !host->cqe_enabled) {
+	if (host->cqe_ops && !host->cqe_enabled) {
 		err = host->cqe_ops->cqe_enable(host, card);
 		if (err) {
 			pr_err("%s: Failed to enable CQE, error %d\n",
 				mmc_hostname(host), err);
 		} else {
 			host->cqe_enabled = true;
-			pr_info("%s: Command Queue Engine enabled\n",
-				mmc_hostname(host));
+
+			if (card->ext_csd.cmdq_en) {
+				pr_info("%s: Command Queue Engine enabled\n",
+					mmc_hostname(host));
+			} else {
+				host->swq_enabled = true;
+				pr_info("%s: Software Queue enabled\n",
+					mmc_hostname(host));
+			}
 		}
 	}
 
drivers/mmc/core/queue.c +26 -7
index 9edc086..d9086c1 100644
@@ -62,7 +62,7 @@ enum mmc_issue_type mmc_issue_type(struct mmc_queue *mq, struct request *req)
 {
 	struct mmc_host *host = mq->card->host;
 
-	if (mq->use_cqe)
+	if (mq->use_cqe && !host->swq_enabled)
 		return mmc_cqe_issue_type(host, req);
 
 	if (req_op(req) == REQ_OP_READ || req_op(req) == REQ_OP_WRITE)
@@ -124,12 +124,14 @@ static enum blk_eh_timer_return mmc_mq_timed_out(struct request *req,
 {
 	struct request_queue *q = req->q;
 	struct mmc_queue *mq = q->queuedata;
+	struct mmc_card *card = mq->card;
+	struct mmc_host *host = card->host;
 	unsigned long flags;
 	int ret;
 
 	spin_lock_irqsave(&mq->lock, flags);
 
-	if (mq->recovery_needed || !mq->use_cqe)
+	if (mq->recovery_needed || !mq->use_cqe || host->swq_enabled)
 		ret = BLK_EH_RESET_TIMER;
 	else
 		ret = mmc_cqe_timed_out(req);
@@ -144,12 +146,13 @@ static void mmc_mq_recovery_handler(struct work_struct *work)
 	struct mmc_queue *mq = container_of(work, struct mmc_queue,
 					    recovery_work);
 	struct request_queue *q = mq->queue;
+	struct mmc_host *host = mq->card->host;
 
 	mmc_get_card(mq->card, &mq->ctx);
 
 	mq->in_recovery = true;
 
-	if (mq->use_cqe)
+	if (mq->use_cqe && !host->swq_enabled)
 		mmc_blk_cqe_recovery(mq);
 	else
 		mmc_blk_mq_recovery(mq);
@@ -160,6 +163,9 @@ static void mmc_mq_recovery_handler(struct work_struct *work)
 	mq->recovery_needed = false;
 	spin_unlock_irq(&mq->lock);
 
+	if (host->swq_enabled)
+		host->cqe_ops->cqe_recovery_finish(host);
+
 	mmc_put_card(mq->card, &mq->ctx);
 
 	blk_mq_run_hw_queues(q, true);
@@ -279,6 +285,14 @@ static blk_status_t mmc_mq_queue_rq(struct blk_mq_hw_ctx *hctx,
 		}
 		break;
 	case MMC_ISSUE_ASYNC:
+		/*
+		 * For MMC host software queue, we only allow 2 requests in
+		 * flight to avoid a long latency.
+		 */
+		if (host->swq_enabled && mq->in_flight[issue_type] > 2) {
+			spin_unlock_irq(&mq->lock);
+			return BLK_STS_RESOURCE;
+		}
 		break;
 	default:
 		/*
@@ -430,11 +444,16 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card)
 	 * The queue depth for CQE must match the hardware because the request
 	 * tag is used to index the hardware queue.
 	 */
-	if (mq->use_cqe)
-		mq->tag_set.queue_depth =
-			min_t(int, card->ext_csd.cmdq_depth, host->cqe_qdepth);
-	else
+	if (mq->use_cqe) {
+		if (host->swq_enabled)
+			mq->tag_set.queue_depth = host->cqe_qdepth;
+		else
+			mq->tag_set.queue_depth =
+				min_t(int, card->ext_csd.cmdq_depth, host->cqe_qdepth);
+	} else {
 		mq->tag_set.queue_depth = MMC_QUEUE_DEPTH;
+	}
+
 	mq->tag_set.numa_node = NUMA_NO_NODE;
 	mq->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 	mq->tag_set.nr_hw_queues = 1;
drivers/mmc/host/Kconfig +7 -0
index 49ea02c..efa4019 100644
@@ -936,6 +936,13 @@ config MMC_CQHCI
 
 	  If unsure, say N.
 
+config MMC_HSQ
+	tristate "MMC Host Software Queue support"
+	help
+	  This selects the Software Queue support.
+
+	  If unsure, say N.
+
 config MMC_TOSHIBA_PCI
 	tristate "Toshiba Type A SD/MMC Card Interface Driver"
 	depends on PCI
drivers/mmc/host/Makefile +1 -0
index 11c4598..c14b439 100644
@@ -98,6 +98,7 @@ obj-$(CONFIG_MMC_SDHCI_BRCMSTB)		+= sdhci-brcmstb.o
 obj-$(CONFIG_MMC_SDHCI_OMAP)		+= sdhci-omap.o
 obj-$(CONFIG_MMC_SDHCI_SPRD)		+= sdhci-sprd.o
 obj-$(CONFIG_MMC_CQHCI)			+= cqhci.o
+obj-$(CONFIG_MMC_HSQ)			+= mmc_hsq.o
 
 ifeq ($(CONFIG_CB710_DEBUG),y)
 	CFLAGS-cb710-mmc	+= -DDEBUG
drivers/mmc/host/mmc_hsq.c new file +344 -0

344 lines not on this page · raw message

drivers/mmc/host/mmc_hsq.h new file +30 -0
new file mode 100644
index 0000000..d51beb7
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-2.0
+#ifndef LINUX_MMC_HSQ_H
+#define LINUX_MMC_HSQ_H
+
+struct hsq_slot {
+	struct mmc_request *mrq;
+};
+
+struct mmc_hsq {
+	struct mmc_host *mmc;
+	struct mmc_request *mrq;
+	wait_queue_head_t wait_queue;
+	struct hsq_slot *slot;
+	spinlock_t lock;
+
+	int next_tag;
+	int num_slots;
+	int qcnt;
+
+	bool enabled;
+	bool waiting_for_idle;
+	bool recovery_halt;
+};
+
+int mmc_hsq_init(struct mmc_hsq *hsq, struct mmc_host *mmc);
+void mmc_hsq_suspend(struct mmc_host *mmc);
+int mmc_hsq_resume(struct mmc_host *mmc);
+bool mmc_hsq_finalize_request(struct mmc_host *mmc, struct mmc_request *mrq);
+
+#endif
include/linux/mmc/host.h +3 -0
index ba70338..3931aa3 100644
@@ -462,6 +462,9 @@ struct mmc_host {
 	bool			cqe_enabled;
 	bool			cqe_on;
 
+	/* Software Queue support */
+	bool			swq_enabled;
+
 	unsigned long		private[0] ____cacheline_aligned;
 };
 
Signature · 1 line
1.7.9.5
#2 lore raw

PATCH v5 2/4 mmc: host: sdhci: Add request_done ops for struct sdhci_ops

In reply to Baolin Wang

Add request_done ops for struct sdhci_ops as a preparation in case some host controllers have different method to complete one request, such as supporting request completion of MMC software queue.

---
 drivers/mmc/host/sdhci.c |   12 ++++++++++--
 drivers/mmc/host/sdhci.h |    2 ++
 2 files changed, 12 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci.c +10 -2
index b056400..850241f 100644
@@ -2729,7 +2729,10 @@ static bool sdhci_request_done(struct sdhci_host *host)
 
 	spin_unlock_irqrestore(&host->lock, flags);
 
-	mmc_request_done(host->mmc, mrq);
+	if (host->ops->request_done)
+		host->ops->request_done(host, mrq);
+	else
+		mmc_request_done(host->mmc, mrq);
 
 	return false;
 }
@@ -3157,7 +3160,12 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
 
 	/* Process mrqs ready for immediate completion */
 	for (i = 0; i < SDHCI_MAX_MRQS; i++) {
-		if (mrqs_done[i])
+		if (!mrqs_done[i])
+			continue;
+
+		if (host->ops->request_done)
+			host->ops->request_done(host, mrqs_done[i]);
+		else
 			mmc_request_done(host->mmc, mrqs_done[i]);
 	}
 
drivers/mmc/host/sdhci.h +2 -0
index 0ed3e0e..d89cdb9 100644
@@ -644,6 +644,8 @@ struct sdhci_ops {
 	void	(*voltage_switch)(struct sdhci_host *host);
 	void	(*adma_write_desc)(struct sdhci_host *host, void **desc,
 				   dma_addr_t addr, int len, unsigned int cmd);
+	void	(*request_done)(struct sdhci_host *host,
+				struct mmc_request *mrq);
 };
 
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
Signature · 1 line
1.7.9.5
#3 lore raw

PATCH v5 3/4 mmc: host: sdhci-sprd: Add software queue support

In reply to Baolin Wang

Add software queue support to improve the performance.

---
 drivers/mmc/host/Kconfig      |    1 +
 drivers/mmc/host/sdhci-sprd.c |   26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
drivers/mmc/host/Kconfig +1 -0
index efa4019..54b86f6 100644
@@ -632,6 +632,7 @@ config MMC_SDHCI_SPRD
 	depends on ARCH_SPRD
 	depends on MMC_SDHCI_PLTFM
 	select MMC_SDHCI_IO_ACCESSORS
+	select MMC_HSQ
 	help
 	  This selects the SDIO Host Controller in Spreadtrum
 	  SoCs, this driver supports R11(IP version: R11P0).
drivers/mmc/host/sdhci-sprd.c +26 -0
index d07b979..3cc1277 100644
@@ -19,6 +19,7 @@
 #include <linux/slab.h>
 
 #include "sdhci-pltfm.h"
+#include "mmc_hsq.h"
 
 /* SDHCI_ARGUMENT2 register high 16bit */
 #define SDHCI_SPRD_ARG2_STUFF		GENMASK(31, 16)
@@ -379,6 +380,16 @@ static unsigned int sdhci_sprd_get_ro(struct sdhci_host *host)
 	return 0;
 }
 
+static void sdhci_sprd_request_done(struct sdhci_host *host,
+				    struct mmc_request *mrq)
+{
+	/* Validate if the request was from software queue firstly. */
+	if (mmc_hsq_finalize_request(host->mmc, mrq))
+		return;
+
+	 mmc_request_done(host->mmc, mrq);
+}
+
 static struct sdhci_ops sdhci_sprd_ops = {
 	.read_l = sdhci_sprd_readl,
 	.write_l = sdhci_sprd_writel,
@@ -392,6 +403,7 @@ static unsigned int sdhci_sprd_get_ro(struct sdhci_host *host)
 	.hw_reset = sdhci_sprd_hw_reset,
 	.get_max_timeout_count = sdhci_sprd_get_max_timeout_count,
 	.get_ro = sdhci_sprd_get_ro,
+	.request_done = sdhci_sprd_request_done,
 };
 
 static void sdhci_sprd_request(struct mmc_host *mmc, struct mmc_request *mrq)
@@ -521,6 +533,7 @@ static int sdhci_sprd_probe(struct platform_device *pdev)
 {
 	struct sdhci_host *host;
 	struct sdhci_sprd_host *sprd_host;
+	struct mmc_hsq *hsq;
 	struct clk *clk;
 	int ret = 0;
 
@@ -631,6 +644,16 @@ static int sdhci_sprd_probe(struct platform_device *pdev)
 
 	sprd_host->flags = host->flags;
 
+	hsq = devm_kzalloc(&pdev->dev, sizeof(*hsq), GFP_KERNEL);
+	if (!hsq) {
+		ret = -ENOMEM;
+		goto err_cleanup_host;
+	}
+
+	ret = mmc_hsq_init(hsq, host->mmc);
+	if (ret)
+		goto err_cleanup_host;
+
 	ret = __sdhci_add_host(host);
 	if (ret)
 		goto err_cleanup_host;
@@ -689,6 +712,7 @@ static int sdhci_sprd_runtime_suspend(struct device *dev)
 	struct sdhci_host *host = dev_get_drvdata(dev);
 	struct sdhci_sprd_host *sprd_host = TO_SPRD_HOST(host);
 
+	mmc_hsq_suspend(host->mmc);
 	sdhci_runtime_suspend_host(host);
 
 	clk_disable_unprepare(sprd_host->clk_sdio);
@@ -717,6 +741,8 @@ static int sdhci_sprd_runtime_resume(struct device *dev)
 		goto clk_disable;
 
 	sdhci_runtime_resume_host(host, 1);
+	mmc_hsq_resume(host->mmc);
+
 	return 0;
 
 clk_disable:
Signature · 1 line
1.7.9.5
#4 lore raw

PATCH v5 4/4 mmc: host: sdhci: Add a variable to defer to complete data requests if needed

In reply to Baolin Wang

When using the host software queue, it will trigger the next request in irq handler without a context switch. But the sdhci_request() can not be called in interrupt context when using host software queue for some host drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is nonremovable, so the get_cd() ops is not sleepable, which means we can complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate that we will always to defer to complete data requests if the sdhci_request() can not be called in interrupt context for some host drivers, when using the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +1 -1
index 850241f..9cf2130 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
 {
 	struct mmc_data *data = mrq->data;
 
-	return host->pending_reset ||
+	return host->pending_reset || (host->always_defer_done && data) ||
 	       ((host->flags & SDHCI_REQ_USE_DMA) && data &&
 		data->host_cookie == COOKIE_MAPPED);
 }
drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done;	/* Always defer to complete data requests */
 
 	struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];	/* Requests done */
 	struct mmc_command *cmd;	/* Current command */
Signature · 1 line
1.7.9.5
#12 lore raw
In reply to Baolin Wang

Hi Ulf,

Quoted 91 lines · Baolin Wang

Hi All,

Now the MMC read/write stack will always wait for previous request is completed by mmc_blk_rw_wait(), before sending a new request to hardware, or queue a work to complete request, that will bring context switching overhead, especially for high I/O per second rates, to affect the IO performance.

Thus this patch set will introduce the MMC software command queue support based on command queue engine's interfaces, and set the queue depth as 32 to allow more requests can be be prepared, merged and inserted into IO scheduler, but we only allow 2 requests in flight, that is enough to let the irq handler always trigger the next request without a context switch, as well as avoiding a long latency.

Moreover we can expand the MMC software queue interface to support MMC packed request or packed command instead of adding new interfaces, according to previosus discussion.

Below are some comparison data with fio tool. The fio command I used is like below with changing the '--rw' parameter and enabling the direct IO flag to measure the actual hardware transfer speed in 4K block size.

./fio --filename=/dev/mmcblk0p30 --direct=1 --iodepth=20 --rw=read --bs=4K --size=1G --group_reporting --numjobs=20 --name=test_read

My eMMC card working at HS400 Enhanced strobe mode:

[    2.229856] mmc0: new HS400 Enhanced strobe MMC card at address 0001
[    2.237566] mmcblk0: mmc0:0001 HBG4a2 29.1 GiB
[    2.242621] mmcblk0boot0: mmc0:0001 HBG4a2 partition 1 4.00 MiB
[    2.249110] mmcblk0boot1: mmc0:0001 HBG4a2 partition 2 4.00 MiB
[    2.255307] mmcblk0rpmb: mmc0:0001 HBG4a2 partition 3 4.00 MiB, chardev (248:0)

1. Without MMC software queue
I tested 5 times for each case and output a average speed.

1) Sequential read:
Speed: 59.4MiB/s, 63.4MiB/s, 57.5MiB/s, 57.2MiB/s, 60.8MiB/s Average speed: 59.66MiB/s

2) Random read:
Speed: 26.9MiB/s, 26.9MiB/s, 27.1MiB/s, 27.1MiB/s, 27.2MiB/s Average speed: 27.04MiB/s

3) Sequential write:
Speed: 71.6MiB/s, 72.5MiB/s, 72.2MiB/s, 64.6MiB/s, 67.5MiB/s Average speed: 69.68MiB/s

4) Random write:
Speed: 36.3MiB/s, 35.4MiB/s, 38.6MiB/s, 34MiB/s, 35.5MiB/s Average speed: 35.96MiB/s

2. With MMC software queue
I tested 5 times for each case and output a average speed.

1) Sequential read:
Speed: 59.2MiB/s, 60.4MiB/s, 63.6MiB/s, 60.3MiB/s, 59.9MiB/s Average speed: 60.68MiB/s

2) Random read:
Speed: 31.3MiB/s, 31.4MiB/s, 31.5MiB/s, 31.3MiB/s, 31.3MiB/s Average speed: 31.36MiB/s

3) Sequential write:
Speed: 71MiB/s, 71.8MiB/s, 72.3MiB/s, 72.2MiB/s, 71MiB/s Average speed: 71.66MiB/s

4) Random write:
Speed: 68.9MiB/s, 68.7MiB/s, 68.8MiB/s, 68.6MiB/s, 68.8MiB/s Average speed: 68.76MiB/s

Form above data, we can see the MMC software queue can help to improve some performance obviously for random read and write, though no obvious improvement for sequential read and write.

Any comments are welcome. Thanks a lot.

Changes from v4:
- Add a seperate patch to introduce a variable to defer to complete data requests for some host drivers, when using host software queue.

Changes from v3:
- Use host software queue instead of sqhci.
- Fix random config building issue.
- Change queue depth to 32, but still only allow 2 requests in flight.
- Update the testing data.

Changes from v2:
- Remove reference to 'struct cqhci_host' and 'struct cqhci_slot', instead adding 'struct sqhci_host', which is only used by software queue.

Quoted 5 lines

Changes from v1:
- Add request_done ops for sdhci_ops.
- Replace virtual command queue with software queue for functions and variables.
- Rename the software queue file and add sqhci.h header file.

Do you have any comments for this patch set? Since the merge window is approaching, is it possible to apply this patch set into V5.5? Thanks.

Quoted 26 lines

Baolin Wang (4):
mmc: Add MMC host software queue support
mmc: host: sdhci: Add request_done ops for struct sdhci_ops
mmc: host: sdhci-sprd: Add software queue support
mmc: host: sdhci: Add a variable to defer to complete data requests
if needed

 drivers/mmc/core/block.c      |   61 ++++++++
 drivers/mmc/core/mmc.c        |   13 +-
 drivers/mmc/core/queue.c      |   33 +++-
 drivers/mmc/host/Kconfig      |    8 +
 drivers/mmc/host/Makefile     |    1 +
 drivers/mmc/host/mmc_hsq.c    |  344 +++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/host/mmc_hsq.h    |   30 ++++
 drivers/mmc/host/sdhci-sprd.c |   26 ++++
 drivers/mmc/host/sdhci.c      |   14 +-
 drivers/mmc/host/sdhci.h      |    3 +
 include/linux/mmc/host.h      |    3 +
 11 files changed, 523 insertions(+), 13 deletions(-)
 create mode 100644 drivers/mmc/host/mmc_hsq.c
 create mode 100644 drivers/mmc/host/mmc_hsq.h

--
1.7.9.5

Signature · 2 lines
Baolin Wang
Best Regards
maintainer
#5 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

In reply to Baolin Wang
Quoted 27 lines · Baolin Wang

When using the host software queue, it will trigger the next request in irq handler without a context switch. But the sdhci_request() can not be called in interrupt context when using host software queue for some host drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is nonremovable, so the get_cd() ops is not sleepable, which means we can complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate that we will always to defer to complete data requests if the sdhci_request() can not be called in interrupt context for some host drivers, when using the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +0 -0
index 850241f..9cf2130 100644

drivers/mmc/host/sdhci.c static inline bool sdhci_defer_done(struct sdhci_host *host, · line 3038

Quoted 5 lines
drivers/mmc/host/sdhci.c +1 -1
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
 {
 	struct mmc_data *data = mrq->data;
 
-	return host->pending_reset ||
+	return host->pending_reset || (host->always_defer_done && data) ||

I didn't realize you still wanted to call the request function in interrupt context. In my view that needs a new host API
i.e. int (*request_atomic)(struct mmc_host *mmc, struct mmc_request *mrq)

Quoted 16 lines
drivers/mmc/host/sdhci.c +0 -0
 	       ((host->flags & SDHCI_REQ_USE_DMA) && data &&
 		data->host_cookie == COOKIE_MAPPED);
 }
drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done;	/* Always defer to complete data requests */
 
 	struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];	/* Requests done */
 	struct mmc_command *cmd;	/* Current command */
#6 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Quoted 32 lines · Adrian Hunter
Quoted 30 lines · Baolin Wang

When using the host software queue, it will trigger the next request in irq handler without a context switch. But the sdhci_request() can not be called in interrupt context when using host software queue for some host drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is nonremovable, so the get_cd() ops is not sleepable, which means we can complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate that we will always to defer to complete data requests if the sdhci_request() can not be called in interrupt context for some host drivers, when using the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +0 -0
index 850241f..9cf2130 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
 {
      struct mmc_data *data = mrq->data;
 
Quoted 6 lines

drivers/mmc/host/sdhci.c static inline bool sdhci_defer_done(struct sdhci_host *host, · line 3038

Quoted 2 lines
drivers/mmc/host/sdhci.c +1 -1
-     return host->pending_reset ||
+     return host->pending_reset || (host->always_defer_done && data) ||

I didn't realize you still wanted to call the request function in interrupt context. In my view that needs a new host API
i.e. int (*request_atomic)(struct mmc_host *mmc, struct mmc_request *mrq)

Actually there are no documentation said that the mmc_host_ops->request() is a sleepable API, so I introduce a host->always_defer_done flag to decide if the request can be called in interrupt context or not, since for some host drivers, the request() implementation can be called in interrupt context.

Yes, I agree a new host API is more reasonable, if you do not like the current approach, I can add new patches to introduce the new request_atomic() API. But can I create another separate patch set to do this? since in this patch set, the Spreadtrum host driver's request() implementation can be called in interrupt context. Or you still want these changes introducing new request_atomic() can be done in this patch set? Thanks.

Quoted 18 lines
Quoted 17 lines
drivers/mmc/host/sdhci.c +0 -0
             ((host->flags & SDHCI_REQ_USE_DMA) && data &&
              data->host_cookie == COOKIE_MAPPED);
 }
drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete data requests */
 
      struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
      struct mmc_command *cmd;        /* Current command */
Signature · 2 lines
Baolin Wang
Best Regards
maintainer
#7 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Quoted 33 lines · Baolin Wang
Quoted 32 lines · Adrian Hunter
Quoted 30 lines · Baolin Wang

When using the host software queue, it will trigger the next request in irq handler without a context switch. But the sdhci_request() can not be called in interrupt context when using host software queue for some host drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is nonremovable, so the get_cd() ops is not sleepable, which means we can complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate that we will always to defer to complete data requests if the sdhci_request() can not be called in interrupt context for some host drivers, when using the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +0 -0
index 850241f..9cf2130 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
 {
      struct mmc_data *data = mrq->data;
 
Quoted 2 lines
Quoted 2 lines

drivers/mmc/host/sdhci.c static inline bool sdhci_defer_done(struct sdhci_host *host, · line 3038

Quoted 2 lines
drivers/mmc/host/sdhci.c +1 -1
-     return host->pending_reset ||
+     return host->pending_reset || (host->always_defer_done && data) ||

To move ahead in the meantime without a new host API, just defer always i.e.

+ return host->pending_reset || host->always_defer_done ||

Quoted 39 lines
Quoted 4 lines

I didn't realize you still wanted to call the request function in interrupt context. In my view that needs a new host API
i.e. int (*request_atomic)(struct mmc_host *mmc, struct mmc_request *mrq)

Actually there are no documentation said that the mmc_host_ops->request() is a sleepable API, so I introduce a host->always_defer_done flag to decide if the request can be called in interrupt context or not, since for some host drivers, the request() implementation can be called in interrupt context.

Yes, I agree a new host API is more reasonable, if you do not like the current approach, I can add new patches to introduce the new request_atomic() API. But can I create another separate patch set to do this? since in this patch set, the Spreadtrum host driver's request() implementation can be called in interrupt context. Or you still want these changes introducing new request_atomic() can be done in this patch set? Thanks.

Quoted 18 lines
Quoted 17 lines
drivers/mmc/host/sdhci.c +0 -0
             ((host->flags & SDHCI_REQ_USE_DMA) && data &&
              data->host_cookie == COOKIE_MAPPED);
 }
drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete data requests */
 
      struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
      struct mmc_command *cmd;        /* Current command */
#8 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Quoted 35 lines · Adrian Hunter
Quoted 33 lines · Baolin Wang
Quoted 32 lines · Adrian Hunter
Quoted 30 lines · Baolin Wang

When using the host software queue, it will trigger the next request in irq handler without a context switch. But the sdhci_request() can not be called in interrupt context when using host software queue for some host drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is nonremovable, so the get_cd() ops is not sleepable, which means we can complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate that we will always to defer to complete data requests if the sdhci_request() can not be called in interrupt context for some host drivers, when using the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +0 -0
index 850241f..9cf2130 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
 {
      struct mmc_data *data = mrq->data;
 
Quoted 4 lines
Quoted 2 lines
Quoted 2 lines

drivers/mmc/host/sdhci.c static inline bool sdhci_defer_done(struct sdhci_host *host, · line 3038

Quoted 2 lines
drivers/mmc/host/sdhci.c +1 -1
-     return host->pending_reset ||
+     return host->pending_reset || (host->always_defer_done && data) ||

To move ahead in the meantime without a new host API, just defer always i.e.

OK.

And I'll wait for a while to see if Ulf will post some comments for this patch set before new version. Thanks.

Quoted 43 lines

+ return host->pending_reset || host->always_defer_done ||

Quoted 39 lines
Quoted 4 lines

I didn't realize you still wanted to call the request function in interrupt context. In my view that needs a new host API
i.e. int (*request_atomic)(struct mmc_host *mmc, struct mmc_request *mrq)

Actually there are no documentation said that the mmc_host_ops->request() is a sleepable API, so I introduce a host->always_defer_done flag to decide if the request can be called in interrupt context or not, since for some host drivers, the request() implementation can be called in interrupt context.

Yes, I agree a new host API is more reasonable, if you do not like the current approach, I can add new patches to introduce the new request_atomic() API. But can I create another separate patch set to do this? since in this patch set, the Spreadtrum host driver's request() implementation can be called in interrupt context. Or you still want these changes introducing new request_atomic() can be done in this patch set? Thanks.

Quoted 18 lines
Quoted 17 lines
drivers/mmc/host/sdhci.c +0 -0
             ((host->flags & SDHCI_REQ_USE_DMA) && data &&
              data->host_cookie == COOKIE_MAPPED);
 }
drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete data requests */
 
      struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
      struct mmc_command *cmd;        /* Current command */
Signature · 2 lines
Baolin Wang
Best Regards
#9 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Hi Adrian,

Quoted 46 lines · Baolin Wang
Quoted 45 lines · Adrian Hunter
Quoted 43 lines · Baolin Wang
Quoted 41 lines · Adrian Hunter
Quoted 39 lines · Baolin Wang

When using the host software queue, it will trigger the next request in
irq handler without a context switch. But the sdhci_request() can not be
called in interrupt context when using host software queue for some host
drivers, due to the get_cd() ops can be sleepable.

But for some host drivers, such as Spreadtrum host driver, the card is
nonremovable, so the get_cd() ops is not sleepable, which means we can
complete the data request and trigger the next request in irq handler to remove the context switch for the Spreadtrum host driver.

Thus we still need introduce a variable in struct sdhci_host to indicate
that we will always to defer to complete data requests if the sdhci_request()
can not be called in interrupt context for some host drivers, when using
the host software queue.

---
 drivers/mmc/host/sdhci.c |    2 +-
 drivers/mmc/host/sdhci.h |    1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +0 -0
index 850241f..9cf2130 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct
 sdhci_host *host,
 {
      struct mmc_data *data = mrq->data;
 
Quoted 6 lines
Quoted 6 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
drivers/mmc/host/sdhci.c +1 -1
-     return host->pending_reset ||
+     return host->pending_reset || (host->always_defer_done && data)

||

To move ahead in the meantime without a new host API, just defer always i.e.

Before new version, I want to make things clear in case I misunderstood your points, so you mean I should set always_defer_done = true for our Spreadtrum host driver in this patch? Or just like below patch? Thanks.

drivers/mmc/host/sdhci.c +0 -0
index 850241f..4bef066 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct

sdhci_host *host,

 {
        struct mmc_data *data = mrq->data;
-       return host->pending_reset ||
+       return host->pending_reset || host->always_defer_done ||
               ((host->flags & SDHCI_REQ_USE_DMA) && data &&
                data->host_cookie == COOKIE_MAPPED);

}

drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..a73ce89 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete requests */
 
        struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
        struct mmc_command *cmd;        /* Current command */
Quoted 56 lines

And I'll wait for a while to see if Ulf will post some comments for this patch set before new version. Thanks.

Quoted 47 lines

+ return host->pending_reset || host->always_defer_done ||

Quoted 43 lines
Quoted 6 lines

I didn't realize you still wanted to call the request function in interrupt
context. In my view that needs a new host API
i.e. int (*request_atomic)(struct mmc_host *mmc, struct mmc_request *mrq)

Actually there are no documentation said that the mmc_host_ops->request() is a sleepable API, so I introduce a host->always_defer_done flag to decide if the request can be called in interrupt context or not, since for some host drivers, the request() implementation can be called in interrupt context.

Yes, I agree a new host API is more reasonable, if you do not like the current approach, I can add new patches to introduce the new request_atomic() API. But can I create another separate patch set to do this? since in this patch set, the Spreadtrum host driver's request() implementation can be called in interrupt context. Or you still want these changes introducing new request_atomic() can be done in this patch set? Thanks.

Quoted 20 lines
Quoted 19 lines
             ((host->flags & SDHCI_REQ_USE_DMA) && data &&
              data->host_cookie == COOKIE_MAPPED);

}

drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..38fbd18 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete data

requests */

struct mmc_request *mrqs_done[SDHCI_MAX_MRQS]; /* Requests done
*/
struct mmc_command *cmd; /* Current command */

--
Baolin Wang
Best Regards

Signature · 2 lines
Baolin Wang
Best Regards
maintainer
#10 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Quoted 30 lines · Baolin Wang
Quoted 3 lines · Baolin Wang
Quoted 2 lines · Adrian Hunter

To move ahead in the meantime without a new host API, just defer always

Before new version, I want to make things clear in case I misunderstood your points, so you mean I should set always_defer_done = true for our Spreadtrum host driver in this patch? Or just like below patch? Thanks.

drivers/mmc/host/sdhci.c +1 -1
index 850241f..4bef066 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct
 sdhci_host *host,
 {
        struct mmc_data *data = mrq->data;
 
-       return host->pending_reset ||
+       return host->pending_reset || host->always_defer_done ||
               ((host->flags & SDHCI_REQ_USE_DMA) && data &&
                data->host_cookie == COOKIE_MAPPED);

}

drivers/mmc/host/sdhci.h +0 -0
index d89cdb9..a73ce89 100644

drivers/mmc/host/sdhci.h struct sdhci_host { · line 539

Quoted 7 lines
drivers/mmc/host/sdhci.h +1 -0
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete requests */
 
        struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
        struct mmc_command *cmd;        /* Current command */

Yes

#11 lore raw

Re: [PATCH v5 4/4] mmc: host: sdhci: Add a variable to defer to complete data requests if needed

Quoted 36 lines · Adrian Hunter
Quoted 34 lines · Baolin Wang
Quoted 3 lines · Baolin Wang
Quoted 2 lines · Adrian Hunter

To move ahead in the meantime without a new host API, just defer always

Before new version, I want to make things clear in case I misunderstood your points, so you mean I should set always_defer_done = true for our Spreadtrum host driver in this patch? Or just like below patch? Thanks.

drivers/mmc/host/sdhci.c +1 -1
index 850241f..4bef066 100644
@@ -3035,7 +3035,7 @@ static inline bool sdhci_defer_done(struct
 sdhci_host *host,
 {
        struct mmc_data *data = mrq->data;
 
-       return host->pending_reset ||
+       return host->pending_reset || host->always_defer_done ||
               ((host->flags & SDHCI_REQ_USE_DMA) && data &&
                data->host_cookie == COOKIE_MAPPED);

}

drivers/mmc/host/sdhci.h +1 -0
index d89cdb9..a73ce89 100644
@@ -533,6 +533,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 always_defer_done; /* Always defer to complete requests */
 
Quoted 5 lines

drivers/mmc/host/sdhci.h struct sdhci_host { · line 539

Quoted 3 lines
drivers/mmc/host/sdhci.h +0 -0
        struct mmc_request *mrqs_done[SDHCI_MAX_MRQS];  /* Requests done */
        struct mmc_command *cmd;        /* Current command */

Yes

Got it. Thanks for your confirming.

Signature · 2 lines
Baolin Wang
Best Regards