Skip to contentSkip to conversation

Add MMC virtual command queue support

PATCH Superseded Baolin Wang 2 participants 11 messages Sep 6, 2019 – Sep 10, 2019

Subsystems (4)

v1 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

cover Add MMC virtual command 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 virtual command queue support, and set the queue depth as 2, that means we do not need wait for previous request is completed and can queue 2 requests in flight. It is enough to let the irq handler always trigger the next request without a context switch and then ask the blk_mq layer for the next one to get queued, as well as avoiding a long latency.

Moreover we can expand the virtual command 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=512M --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 virtual command queue
I tested 3 times for each case and output a average speed.

1) Sequential read:
Speed: 28.9MiB/s, 26.4MiB/s, 30.9MiB/s
Average speed: 28.7MiB/s

2) Random read:
Speed: 18.2MiB/s, 8.9MiB/s, 15.8MiB/s
Average speed: 14.3MiB/s

3) Sequential write:
Speed: 21.1MiB/s, 27.9MiB/s, 25MiB/s
Average speed: 24.7MiB/s

4) Random write:
Speed: 21.5MiB/s, 18.1MiB/s, 18.1MiB/s
Average speed: 19.2MiB/s

2. With virtual command queue
I tested 3 times for each case and output a average speed.

1) Sequential read:
Speed: 44.1MiB/s, 42.3MiB/s, 44.4MiB/s
Average speed: 43.6MiB/s

2) Random read:
Speed: 30.6MiB/s, 30.9MiB/s, 30.5MiB/s
Average speed: 30.6MiB/s

3) Sequential write:
Speed: 44.1MiB/s, 45.9MiB/s, 44.2MiB/s
Average speed: 44.7MiB/s

4) Random write:
Speed: 45.1MiB/s, 43.3MiB/s, 42.4MiB/s
Average speed: 43.6MiB/s

Form above data, we can see the virtual command queue can help to improve the performance obviously.

Any comments are welcome. Thanks a lot.

Baolin Wang (4):
mmc: host: cqhci: Move the struct cqhci_slot into header file
mmc: Add virtual command queue support
mmc: host: sdhci-sprd: Add virtual command queue support
mmc: host: sdhci: Add virtual command queue support

 drivers/mmc/core/block.c      |   62 ++++++++
 drivers/mmc/core/mmc.c        |   13 +-
 drivers/mmc/core/queue.c      |   25 ++-
 drivers/mmc/host/Kconfig      |    9 ++
 drivers/mmc/host/Makefile     |    1 +
 drivers/mmc/host/cqhci-virt.c |  346 +++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/host/cqhci.c      |   10 --
 drivers/mmc/host/cqhci.h      |   45 +++++-
 drivers/mmc/host/sdhci-sprd.c |   16 ++
 drivers/mmc/host/sdhci.c      |    7 +-
 include/linux/mmc/host.h      |    1 +
 11 files changed, 512 insertions(+), 23 deletions(-)
 create mode 100644 drivers/mmc/host/cqhci-virt.c
Signature · 1 line
1.7.9.5
#1 lore raw

PATCH 1/4 mmc: host: cqhci: Move the struct cqhci_slot into header file

The struct cqhci_slot will be used by virtual command queue introducing by following patches, thus move it to the header file.

---
 drivers/mmc/host/cqhci.c |   10 ----------
 drivers/mmc/host/cqhci.h |   11 ++++++++++-
 2 files changed, 10 insertions(+), 11 deletions(-)
drivers/mmc/host/cqhci.c +0 -10
index f7bdae5..57ff1cc 100644
@@ -21,16 +21,6 @@
 #define DCMD_SLOT 31
 #define NUM_SLOTS 32
 
-struct cqhci_slot {
-	struct mmc_request *mrq;
-	unsigned int flags;
-#define CQHCI_EXTERNAL_TIMEOUT	BIT(0)
-#define CQHCI_COMPLETED		BIT(1)
-#define CQHCI_HOST_CRC		BIT(2)
-#define CQHCI_HOST_TIMEOUT	BIT(3)
-#define CQHCI_HOST_OTHER	BIT(4)
-};
-
 static inline u8 *get_desc(struct cqhci_host *cq_host, u8 tag)
 {
 	return cq_host->desc_base + (tag * cq_host->slot_sz);
drivers/mmc/host/cqhci.h +10 -1
index def76e9..7b07bf24f 100644
@@ -141,7 +141,16 @@
 struct cqhci_host_ops;
 struct mmc_host;
 struct mmc_request;
-struct cqhci_slot;
+
+struct cqhci_slot {
+	struct mmc_request *mrq;
+	unsigned int flags;
+#define CQHCI_EXTERNAL_TIMEOUT	BIT(0)
+#define CQHCI_COMPLETED		BIT(1)
+#define CQHCI_HOST_CRC		BIT(2)
+#define CQHCI_HOST_TIMEOUT	BIT(3)
+#define CQHCI_HOST_OTHER	BIT(4)
+};
 
 struct cqhci_host {
 	const struct cqhci_host_ops *ops;
Signature · 1 line
1.7.9.5
#2 lore raw

PATCH 2/4 mmc: Add virtual command queue support

In reply to Baolin Wang

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 virtual command queue interface, which is similar with the hardware command queue engine's idea, that can remove the context switching. Moreover we set the queue depth as 2 for virtual command queue, that is enough to let the irq handler always trigger the next request without a context switch and then ask the blk_mq layer for the next one to get queued, as well as avoiding a long latency.

Quoted 1 line

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

command queue can improve performance obviously with 4K block size, increasing about 52% for sequential read, increasing about 114% for random read, increasing about 81% for sequential write, and increasing about 127% for random write.

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

---
 drivers/mmc/core/block.c      |   62 ++++++++
 drivers/mmc/core/mmc.c        |   13 +-
 drivers/mmc/core/queue.c      |   25 ++-
 drivers/mmc/host/Kconfig      |    8 +
 drivers/mmc/host/Makefile     |    1 +
 drivers/mmc/host/cqhci-virt.c |  346 +++++++++++++++++++++++++++++++++++++++++
 drivers/mmc/host/cqhci.h      |   34 ++++
 include/linux/mmc/host.h      |    1 +
 8 files changed, 480 insertions(+), 10 deletions(-)
 create mode 100644 drivers/mmc/host/cqhci-virt.c
drivers/mmc/core/block.c +62 -0
index 2c71a43..63d487f 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_virt_cqe_req_done(struct mmc_request *mrq);
 
 static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
 {
@@ -1569,9 +1574,31 @@ 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_virt_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;
+	int err;
+
+	mmc_blk_rw_rq_prep(mqrq, mq->card, 0, mq);
+	mqrq->brq.mrq.done = mmc_blk_virt_cqe_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->virt_cqe)
+		return mmc_blk_virt_cqe_issue_rw_rq(mq, req);
 
 	mmc_blk_data_prep(mq, mqrq, 0, NULL, NULL);
 
@@ -1957,6 +1984,41 @@ static void mmc_blk_urgent_bkops(struct mmc_queue *mq,
 		mmc_run_bkops(mq->card);
 }
 
+static void mmc_blk_virt_cqe_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..316b0a6 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->virt_cqe = true;
+				pr_info("%s: Virtual Command Queue Engine enabled\n",
+					mmc_hostname(host));
+			}
 		}
 	}
 
drivers/mmc/core/queue.c +18 -7
index e327f80..50d7fad 100644
@@ -59,7 +59,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->virt_cqe)
 		return mmc_cqe_issue_type(host, req);
 
 	if (req_op(req) == REQ_OP_READ || req_op(req) == REQ_OP_WRITE)
@@ -121,12 +121,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->virt_cqe)
 		ret = BLK_EH_RESET_TIMER;
 	else
 		ret = mmc_cqe_timed_out(req);
@@ -141,12 +143,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->virt_cqe)
 		mmc_blk_cqe_recovery(mq);
 	else
 		mmc_blk_mq_recovery(mq);
@@ -157,6 +160,9 @@ static void mmc_mq_recovery_handler(struct work_struct *work)
 	mq->recovery_needed = false;
 	spin_unlock_irq(&mq->lock);
 
+	if (host->virt_cqe)
+		host->cqe_ops->cqe_recovery_finish(host);
+
 	mmc_put_card(mq->card, &mq->ctx);
 
 	blk_mq_run_hw_queues(q, true);
@@ -406,11 +412,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->virt_cqe)
+			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 +8 -0
index 14d89a1..e2a12c3 100644
@@ -923,6 +923,14 @@ config MMC_CQHCI
 
 	  If unsure, say N.
 
+config MMC_VIRTUAL_CQHCI
+	bool "Virtual Command Queue Host Controller Interface support"
+	help
+	  This selects the Virtual Command Queue Host Controller Interface (VCQHCI)
+	  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 7357871..3611c96 100644
@@ -97,6 +97,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_VIRTUAL_CQHCI)		+= cqhci-virt.o
 
 ifeq ($(CONFIG_CB710_DEBUG),y)
 	CFLAGS-cb710-mmc	+= -DDEBUG
drivers/mmc/host/cqhci-virt.c new file +346 -0

346 lines not on this page · raw message

drivers/mmc/host/cqhci.h +34 -0
index 7b07bf24f..cd8e1a8 100644
@@ -205,6 +205,10 @@ struct cqhci_host {
 	struct completion halt_comp;
 	wait_queue_head_t wait_queue;
 	struct cqhci_slot *slot;
+
+	/* virtual command queue support */
+	int next_tag;
+	struct mmc_request *mrq;
 };
 
 struct cqhci_host_ops {
@@ -242,4 +246,34 @@ irqreturn_t cqhci_irq(struct mmc_host *mmc, u32 intmask, int cmd_error,
 int cqhci_suspend(struct mmc_host *mmc);
 int cqhci_resume(struct mmc_host *mmc);
 
+#ifdef CONFIG_MMC_VIRTUAL_CQHCI
+int cqhci_virt_init(struct cqhci_host *cqv_host, struct mmc_host *mmc);
+void cqhci_virt_suspend(struct mmc_host *mmc);
+int cqhci_virt_resume(struct mmc_host *mmc);
+bool cqhci_virt_finalize_request(struct mmc_host *mmc, struct mmc_request *mrq);
+#else
+static inline int cqhci_virt_init(struct cqhci_host *cqv_host,
+				  struct mmc_host *mmc)
+{
+	return 0;
+}
+
+static inline void cqhci_virt_suspend(struct mmc_host *mmc)
+{
+
+}
+
+static inline int cqhci_virt_resume(struct mmc_host *mmc)
+{
+	return 0;
+}
+
+static inline bool cqhci_virt_finalize_request(struct mmc_host *mmc,
+					       struct mmc_request *mrq)
+{
+	return false;
+}
+
+#endif
+
 #endif
include/linux/mmc/host.h +1 -0
index d8115db7..26213fd 100644
@@ -458,6 +458,7 @@ struct mmc_host {
 	int			cqe_qdepth;
 	bool			cqe_enabled;
 	bool			cqe_on;
+	bool			virt_cqe;
 
 	unsigned long		private[0] ____cacheline_aligned;
 };
Signature · 1 line
1.7.9.5
maintainer
#3 lore raw

Re: [PATCH 2/4] mmc: Add virtual command queue support

Quoted 9 lines · Baolin Wang

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 virtual command queue interface, which is similar with the hardware command queue engine's idea, that can remove the context switching.

CQHCI is a hardware interface for eMMC's that support command queuing. What you are doing is a software issue queue, unrelated to CQHCI. I think you should avoid all reference to CQHCI i.e. call it something else.

#4 lore raw

Re: [PATCH 2/4] mmc: Add virtual command queue support

Hi Adrian,

Quoted 8 lines · Adrian Hunter
Quoted 6 lines · Baolin Wang

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.

Quoted 6 lines
Quoted 3 lines

Thus this patch introduces virtual command queue interface, which is similar with the hardware command queue engine's idea, that can remove the context switching.

CQHCI is a hardware interface for eMMC's that support command queuing. What you are doing is a software issue queue, unrelated to CQHCI. I think you

Yes.

Quoted 1 line

should avoid all reference to CQHCI i.e. call it something else.

Since its process is similar with CQHCI and re-use the CQHCI's interfaces, I called it virtual command queue. I am not sure what else name is better, any thoughts? VCQHCI? Thanks.

--
Baolin Wang
Best Regards

maintainer
#5 lore raw

Re: [PATCH 2/4] mmc: Add virtual command queue support

Quoted 18 lines · Baolin Wang

Hi Adrian,

Quoted 8 lines · Adrian Hunter
Quoted 6 lines · Baolin Wang

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.

Quoted 6 lines
Quoted 3 lines

Thus this patch introduces virtual command queue interface, which is similar with the hardware command queue engine's idea, that can remove the context switching.

CQHCI is a hardware interface for eMMC's that support command queuing. What you are doing is a software issue queue, unrelated to CQHCI. I think you

Quoted 7 lines

Yes.

Quoted 1 line

should avoid all reference to CQHCI i.e. call it something else.

Since its process is similar with CQHCI and re-use the CQHCI's interfaces, I called it virtual command queue. I am not sure what else name is better, any thoughts? VCQHCI? Thanks.

What about swq for software queue. Maybe Ulf can suggest something?

#6 lore raw

Re: [PATCH 2/4] mmc: Add virtual command queue support

Quoted 22 lines · Adrian Hunter
Quoted 20 lines · Baolin Wang

Hi Adrian,

Quoted 8 lines · Adrian Hunter
Quoted 6 lines · Baolin Wang

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.

Quoted 6 lines
Quoted 3 lines

Thus this patch introduces virtual command queue interface, which is similar with the hardware command queue engine's idea, that can remove the context switching.

CQHCI is a hardware interface for eMMC's that support command queuing. What you are doing is a software issue queue, unrelated to CQHCI. I think you

Yes.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

should avoid all reference to CQHCI i.e. call it something else.

Since its process is similar with CQHCI and re-use the CQHCI's interfaces, I called it virtual command queue. I am not sure what else name is better, any thoughts? VCQHCI? Thanks.

What about swq for software queue. Maybe Ulf can suggest something?

Um, though changing to use swq, still need reuse command queue's interfaces, like 'mq->use-cqe', 'host->cqe_depth' and cqe ops and so on, looks a little weird for me. But if you all agree with this name, then I am okay. Ulf, what do you suggest?

Signature · 2 lines
Baolin Wang
Best Regards
#7 lore raw

PATCH 3/4 mmc: host: sdhci-sprd: Add virtual command queue support

In reply to Baolin Wang

Add virtual command queue support.

---
 drivers/mmc/host/Kconfig      |    1 +
 drivers/mmc/host/sdhci-sprd.c |   16 ++++++++++++++++
 2 files changed, 17 insertions(+)
drivers/mmc/host/Kconfig +1 -0
index e2a12c3..851e947 100644
@@ -619,6 +619,7 @@ config MMC_SDHCI_SPRD
 	depends on ARCH_SPRD
 	depends on MMC_SDHCI_PLTFM
 	select MMC_SDHCI_IO_ACCESSORS
+	select MMC_VIRTUAL_CQHCI
 	help
 	  This selects the SDIO Host Controller in Spreadtrum
 	  SoCs, this driver supports R11(IP version: R11P0).
drivers/mmc/host/sdhci-sprd.c +16 -0
index 19a2104..ff4886a3 100644
@@ -19,6 +19,7 @@
 #include <linux/slab.h>
 
 #include "sdhci-pltfm.h"
+#include "cqhci.h"
 
 /* SDHCI_ARGUMENT2 register high 16bit */
 #define SDHCI_SPRD_ARG2_STUFF		GENMASK(31, 16)
@@ -515,6 +516,7 @@ static int sdhci_sprd_probe(struct platform_device *pdev)
 {
 	struct sdhci_host *host;
 	struct sdhci_sprd_host *sprd_host;
+	struct cqhci_host *cqv_host;
 	struct clk *clk;
 	int ret = 0;
 
@@ -625,6 +627,17 @@ static int sdhci_sprd_probe(struct platform_device *pdev)
 
 	sprd_host->flags = host->flags;
 
+	cqv_host = devm_kzalloc(&pdev->dev,
+				sizeof(*cqv_host), GFP_KERNEL);
+	if (!cqv_host) {
+		ret = -ENOMEM;
+		goto err_cleanup_host;
+	}
+
+	ret = cqhci_virt_init(cqv_host, host->mmc);
+	if (ret)
+		goto err_cleanup_host;
+
 	ret = __sdhci_add_host(host);
 	if (ret)
 		goto err_cleanup_host;
@@ -685,6 +698,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);
 
+	cqhci_virt_suspend(host->mmc);
 	sdhci_runtime_suspend_host(host);
 
 	clk_disable_unprepare(sprd_host->clk_sdio);
@@ -713,6 +727,8 @@ static int sdhci_sprd_runtime_resume(struct device *dev)
 		goto clk_disable;
 
 	sdhci_runtime_resume_host(host, 1);
+	cqhci_virt_resume(host->mmc);
+
 	return 0;
 
 clk_disable:
Signature · 1 line
1.7.9.5
#8 lore raw

PATCH 4/4 mmc: host: sdhci: Add virtual command queue support

In reply to Baolin Wang

Add cqhci_virt_finalize_request() to help to complete a request from virtual command queue.

---
 drivers/mmc/host/sdhci.c |    7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci.c +5 -2
index 4e9ebc8..fb5983e 100644
@@ -32,6 +32,7 @@
 #include <linux/mmc/slot-gpio.h>
 
 #include "sdhci.h"
+#include "cqhci.h"
 
 #define DRIVER_NAME "sdhci"
 
@@ -2710,7 +2711,8 @@ static bool sdhci_request_done(struct sdhci_host *host)
 
 	spin_unlock_irqrestore(&host->lock, flags);
 
-	mmc_request_done(host->mmc, mrq);
+	if (!cqhci_virt_finalize_request(host->mmc, mrq))
+		mmc_request_done(host->mmc, mrq);
 
 	return false;
 }
@@ -3133,7 +3135,8 @@ 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] &&
+		    !cqhci_virt_finalize_request(host->mmc, mrqs_done[i]))
 			mmc_request_done(host->mmc, mrqs_done[i]);
 	}
 
Signature · 1 line
1.7.9.5
maintainer
#9 lore raw

Re: [PATCH 4/4] mmc: host: sdhci: Add virtual command queue support

Quoted 21 lines · Baolin Wang

Add cqhci_virt_finalize_request() to help to complete a request from virtual command queue.

---
 drivers/mmc/host/sdhci.c |    7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci.c +1 -0
index 4e9ebc8..fb5983e 100644
@@ -32,6 +32,7 @@
 #include <linux/mmc/slot-gpio.h>
 
 #include "sdhci.h"
+#include "cqhci.h"
 
 #define DRIVER_NAME "sdhci"
 

drivers/mmc/host/sdhci.c static bool sdhci_request_done(struct sdhci_host *host) · line 2715

Quoted 6 lines
drivers/mmc/host/sdhci.c +2 -1
@@ -2710,7 +2711,8 @@ static bool sdhci_request_done(struct sdhci_host *host)
 
 	spin_unlock_irqrestore(&host->lock, flags);
 
-	mmc_request_done(host->mmc, mrq);
+	if (!cqhci_virt_finalize_request(host->mmc, mrq))
+		mmc_request_done(host->mmc, mrq);

Please add a sdhci_ops callback for request->done then:

	if (host->ops->request_done)
		host->ops->request_done(host, mrq);
	else
		mmc_request_done(host->mmc, mrq);

drivers/mmc/host/sdhci.c static irqreturn_t sdhci_irq(int irq, void *dev_id) · line 3139

Quoted 10 lines
drivers/mmc/host/sdhci.c +2 -1
 	return false;
 }
@@ -3133,7 +3135,8 @@ 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] &&
+		    !cqhci_virt_finalize_request(host->mmc, mrqs_done[i]))

sdhci does not support calling mmc->ops->request in interrupt context. So probably, you should avoid immediate completion.

Quoted 4 lines
drivers/mmc/host/sdhci.c +0 -0
 			mmc_request_done(host->mmc, mrqs_done[i]);
 	}
 
#10 lore raw

Re: [PATCH 4/4] mmc: host: sdhci: Add virtual command queue support

Hi Adrian,

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

Add cqhci_virt_finalize_request() to help to complete a request from virtual command queue.

---
 drivers/mmc/host/sdhci.c |    7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/mmc/host/sdhci.c +1 -0
index 4e9ebc8..fb5983e 100644
@@ -32,6 +32,7 @@
 #include <linux/mmc/slot-gpio.h>
 
 #include "sdhci.h"
+#include "cqhci.h"
 
 #define DRIVER_NAME "sdhci"
 

drivers/mmc/host/sdhci.c static bool sdhci_request_done(struct sdhci_host *host) · line 2715

Quoted 6 lines
drivers/mmc/host/sdhci.c +2 -1
@@ -2710,7 +2711,8 @@ static bool sdhci_request_done(struct sdhci_host *host)
 
      spin_unlock_irqrestore(&host->lock, flags);
 
-     mmc_request_done(host->mmc, mrq);
+     if (!cqhci_virt_finalize_request(host->mmc, mrq))
+             mmc_request_done(host->mmc, mrq);

Please add a sdhci_ops callback for request->done then:

Quoted 4 lines
        if (host->ops->request_done)
                host->ops->request_done(host, mrq);
        else
                mmc_request_done(host->mmc, mrq);

Sure, will do.

Quoted 6 lines
Quoted 6 lines
drivers/mmc/host/sdhci.c +0 -0
      return false;
 }
@@ -3133,7 +3135,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
 
Quoted 8 lines

drivers/mmc/host/sdhci.c static irqreturn_t sdhci_irq(int irq, void *dev_id) · line 3139

Quoted 5 lines
drivers/mmc/host/sdhci.c +2 -1
      /* Process mrqs ready for immediate completion */
      for (i = 0; i < SDHCI_MAX_MRQS; i++) {
-             if (mrqs_done[i])
+             if (mrqs_done[i] &&
+                 !cqhci_virt_finalize_request(host->mmc, mrqs_done[i]))

sdhci does not support calling mmc->ops->request in interrupt context. So probably, you should avoid immediate completion.

Yes, I missed this, will remove. Thanks.

Signature · 2 lines
Baolin Wang
Best Regards