Commit 511ce378 authored by Baolin Wang's avatar Baolin Wang Committed by Ulf Hansson
Browse files

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 and spend some extra time to poll the card for busy completion
for I/O writes via sending CMD13, 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 64 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.

Moreover the host controller should support HW busy detection for I/O
operations when enabling the host software queue. That means, the host
controller must not complete a data transfer request, until after the
card stops signals busy.

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.

Reviewed-by: default avatarArnd Bergmann <arnd@arndb.de>
Signed-off-by: default avatarBaolin Wang <baolin.wang@linaro.org>
Signed-off-by: default avatarBaolin Wang <baolin.wang7@gmail.com>
Link: https://lore.kernel.org/r/4409c1586a9b3ed20d57ad2faf6c262fc3ccb6e2.1581478568.git.baolin.wang7@gmail.com


Signed-off-by: default avatarUlf Hansson <ulf.hansson@linaro.org>
parent 219c02ca

drivers/mmc/core/block.c

+61 −0
Original line number Diff line number Diff line
@@ -168,6 +168,11 @@ MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device"); 


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_hsq_req_done(struct mmc_request *mrq);



static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)

{
@@ -1532,9 +1537,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_hsq_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_hsq_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->hsq_enabled)

		return mmc_blk_hsq_issue_rw_rq(mq, req);



	mmc_blk_data_prep(mq, mqrq, 0, NULL, NULL);
@@ -1920,6 +1946,41 @@ static void mmc_blk_urgent_bkops(struct mmc_queue *mq, 
		mmc_run_bkops(mq->card);

}



static void mmc_blk_hsq_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

+11 −7
Original line number Diff line number Diff line
@@ -1851,15 +1851,19 @@ 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 {

		if (!err) {

			host->cqe_enabled = true;



			if (card->ext_csd.cmdq_en) {

				pr_info("%s: Command Queue Engine enabled\n",

					mmc_hostname(host));

			} else {

				host->hsq_enabled = true;

				pr_info("%s: Host Software Queue enabled\n",

					mmc_hostname(host));

			}

		}

	}

drivers/mmc/core/queue.c

+18 −4
Original line number Diff line number Diff line
@@ -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->hsq_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->hsq_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->hsq_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->hsq_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->hsq_enabled && mq->in_flight[issue_type] > 2) {

			spin_unlock_irq(&mq->lock);

			return BLK_STS_RESOURCE;

		}

		break;

	default:

		/*
@@ -430,7 +444,7 @@ 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)

	if (mq->use_cqe && !host->hsq_enabled)

		mq->tag_set.queue_depth =

			min_t(int, card->ext_csd.cmdq_depth, host->cqe_qdepth);

	else

drivers/mmc/host/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -949,6 +949,17 @@ config MMC_CQHCI 


	  If unsure, say N.



config MMC_HSQ

	tristate "MMC Host Software Queue support"

	help

	  This selects the MMC Host Software Queue support. This may increase

	  performance, if the host controller and its driver supports it.



	  If you have a controller/driver supporting this interface, say Y or M

	  here.



	  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
Original line number Diff line number Diff line
@@ -100,6 +100,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

CRA Git | Maintained and supported by SUSTech CRA and CCSE