Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4b7ebca9 authored by Veerabhadrarao Badiganti's avatar Veerabhadrarao Badiganti
Browse files

mmc: core: Update cmdq for making use of per-request data 



Update cmdq initialization path for making use of per-request data.
Also, update cmdq request processing paths per this new change.

Since we are making use of per-request data, no need to maintain
the statically allocated array of mmc_queue_req data structure.

Change-Id: I65fa9fbb45c97835115405d558db764e6189d5f3
Signed-off-by: default avatarVeerabhadrarao Badiganti <vbadigan@codeaurora.org>
parent 1eb51a0c

drivers/mmc/core/block.c

+10 −13
Original line number Diff line number Diff line
@@ -2225,7 +2225,7 @@ static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, 
	}



	mqrq->areq.mrq = &brq->mrq;

	mqrq->areq.mrq->req = mqrq->req;

	mqrq->areq.mrq->req = req;

	mqrq->areq.err_check = mmc_blk_err_check;

}
@@ -2388,14 +2388,14 @@ static int mmc_blk_cmdq_switch(struct mmc_card *card, 
static struct mmc_cmdq_req *mmc_cmdq_prep_dcmd(

		struct mmc_queue_req *mqrq, struct mmc_queue *mq)

{

	struct request *req = mqrq->req;

	struct request *req = mmc_queue_req_to_req(mqrq);

	struct mmc_cmdq_req *cmdq_req = &mqrq->cmdq_req;



	memset(&mqrq->cmdq_req, 0, sizeof(struct mmc_cmdq_req));



	cmdq_req->mrq.data = NULL;

	cmdq_req->cmd_flags = req->cmd_flags;

	cmdq_req->mrq.req = mqrq->req;

	cmdq_req->mrq.req = req;

	req->special = mqrq;

	cmdq_req->cmdq_req_flags |= DCMD;

	cmdq_req->mrq.cmdq_req = cmdq_req;
@@ -2418,8 +2418,7 @@ static struct mmc_cmdq_req *mmc_blk_cmdq_prep_discard_req(struct mmc_queue *mq, 


	set_bit(CMDQ_STATE_DCMD_ACTIVE, &ctx_info->curr_state);



	active_mqrq = &mq->mqrq_cmdq[req->tag];

	active_mqrq->req = req;

	active_mqrq = req_to_mmc_queue_req(req);



	cmdq_req = mmc_cmdq_prep_dcmd(active_mqrq, mq);

	cmdq_req->cmdq_req_flags |= QBR;
@@ -2553,7 +2552,7 @@ static struct mmc_cmdq_req *mmc_blk_cmdq_rw_prep( 
		struct mmc_queue_req *mqrq, struct mmc_queue *mq)

{

	struct mmc_card *card = mq->card;

	struct request *req = mqrq->req;

	struct request *req = mmc_queue_req_to_req(mqrq);

	struct mmc_blk_data *md = mq->blkdata;

	bool do_rel_wr = mmc_req_rel_wr(req) && (md->flags & MMC_BLK_REL_WR);

	bool do_data_tag;
@@ -2615,14 +2614,14 @@ static struct mmc_cmdq_req *mmc_blk_cmdq_rw_prep( 
	}



	mqrq->cmdq_req.cmd_flags = req->cmd_flags;

	mqrq->cmdq_req.mrq.req = mqrq->req;

	mqrq->cmdq_req.mrq.req = req;

	mqrq->cmdq_req.mrq.cmdq_req = &mqrq->cmdq_req;

	mqrq->cmdq_req.mrq.data = &mqrq->cmdq_req.data;

	mqrq->req->special = mqrq;

	req->special = mqrq;



	pr_debug("%s: %s: mrq: 0x%p req: 0x%p mqrq: 0x%p bytes to xf: %d\n",

		mmc_hostname(card->host), __func__, &mqrq->cmdq_req.mrq,

		mqrq->req, mqrq, (cmdq_rq->data.blocks * cmdq_rq->data.blksz));

		req, mqrq, (cmdq_rq->data.blocks * cmdq_rq->data.blksz));

	pr_debug("%s: %s: mmc_cmdq_req: 0x%p card-addr: 0x%08x dir(r-1/w-0): %d\n",

		mmc_hostname(card->host), __func__,

		cmdq_rq, cmdq_rq->blk_addr,
@@ -2658,8 +2657,7 @@ static int mmc_blk_cmdq_issue_rw_rq(struct mmc_queue *mq, struct request *req) 
	BUG_ON(test_and_set_bit(req->tag, &host->cmdq_ctx.data_active_reqs));

	BUG_ON(test_and_set_bit(req->tag, &host->cmdq_ctx.active_reqs));



	active_mqrq = &mq->mqrq_cmdq[req->tag];

	active_mqrq->req = req;

	active_mqrq = req_to_mmc_queue_req(req);



	mc_rq = mmc_blk_cmdq_rw_prep(active_mqrq, mq);
@@ -2722,8 +2720,7 @@ int mmc_blk_cmdq_issue_flush_rq(struct mmc_queue *mq, struct request *req) 


	set_bit(CMDQ_STATE_DCMD_ACTIVE, &ctx_info->curr_state);



	active_mqrq = &mq->mqrq_cmdq[req->tag];

	active_mqrq->req = req;

	active_mqrq = req_to_mmc_queue_req(req);



	cmdq_req = mmc_cmdq_prep_dcmd(active_mqrq, mq);

	cmdq_req->cmdq_req_flags |= QBR;

drivers/mmc/core/queue.c

+16 −41
Original line number Diff line number Diff line
@@ -220,43 +220,23 @@ static struct scatterlist *mmc_alloc_sg(int sg_len, gfp_t gfp) 


int mmc_cmdq_init(struct mmc_queue *mq, struct mmc_card *card)

{

	int i, ret = 0;

	int ret = 0;

	/* one slot is reserved for dcmd requests */

	int q_depth = card->ext_csd.cmdq_depth - 1;



	card->cmdq_init = false;

	if (!(card->host->caps2 & MMC_CAP2_CMD_QUEUE)) {

		ret = -ENOTSUPP;

		goto out;

		return -ENOTSUPP;

	}



	init_waitqueue_head(&card->host->cmdq_ctx.queue_empty_wq);

	init_waitqueue_head(&card->host->cmdq_ctx.wait);



	mq->mqrq_cmdq = kcalloc(q_depth,

				sizeof(struct mmc_queue_req), GFP_KERNEL);

	if (!mq->mqrq_cmdq) {

		ret = -ENOMEM;

		goto out;

	}



	/* sg is allocated for data request slots only */

	for (i = 0; i < q_depth; i++) {

		mq->mqrq_cmdq[i].sg =

			mmc_alloc_sg(card->host->max_segs, GFP_KERNEL);

		if (ret) {

			pr_warn("%s: unable to allocate cmdq sg of size %d\n",

				mmc_card_name(card),

				card->host->max_segs);

			goto free_mqrq_sg;

		}

	}



	ret = blk_queue_init_tags(mq->queue, q_depth, NULL, BLK_TAG_ALLOC_FIFO);

	if (ret) {

		pr_warn("%s: unable to allocate cmdq tags %d\n",

				mmc_card_name(card), q_depth);

		goto free_mqrq_sg;

		return ret;

	}



	blk_queue_softirq_done(mq->queue, mmc_cmdq_softirq_done);
@@ -268,30 +248,14 @@ int mmc_cmdq_init(struct mmc_queue *mq, struct mmc_card *card) 
	blk_queue_rq_timeout(mq->queue, 120 * HZ);

	card->cmdq_init = true;



	goto out;



free_mqrq_sg:

	for (i = 0; i < q_depth; i++)

		kfree(mq->mqrq_cmdq[i].sg);

	kfree(mq->mqrq_cmdq);

	mq->mqrq_cmdq = NULL;

out:

	return ret;

}



void mmc_cmdq_clean(struct mmc_queue *mq, struct mmc_card *card)

{

	int i;

	int q_depth = card->ext_csd.cmdq_depth - 1;



	blk_free_tags(mq->queue->queue_tags);

	mq->queue->queue_tags = NULL;

	blk_queue_free_tags(mq->queue);



	for (i = 0; i < q_depth; i++)

		kfree(mq->mqrq_cmdq[i].sg);

	kfree(mq->mqrq_cmdq);

	mq->mqrq_cmdq = NULL;

}



static int mmc_queue_thread(void *d)
@@ -430,9 +394,21 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, 
	mq->card = card;

	if (card->ext_csd.cmdq_support &&

	    (area_type == MMC_BLK_DATA_AREA_MAIN)) {

		mq->queue = blk_init_queue(mmc_cmdq_dispatch_req, lock);

		mq->queue = blk_alloc_queue(GFP_KERNEL);

		if (!mq->queue)

			return -ENOMEM;

		mq->queue->queue_lock = lock;

		mq->queue->request_fn = mmc_cmdq_dispatch_req;

		mq->queue->init_rq_fn = mmc_init_request;

		mq->queue->exit_rq_fn = mmc_exit_request;

		mq->queue->cmd_size = sizeof(struct mmc_queue_req);

		mq->queue->queuedata = mq;

		ret = blk_init_allocated_queue(mq->queue);

		if (ret) {

			blk_cleanup_queue(mq->queue);

			return ret;

		}



		mmc_cmdq_setup_queue(mq, card);

		ret = mmc_cmdq_init(mq, card);

		if (ret) {
@@ -444,7 +420,6 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, 
			/* hook for pm qos cmdq init */

			if (card->host->cmdq_ops->init)

				card->host->cmdq_ops->init(card->host);

			mq->queue->queuedata = mq;

			mq->thread = kthread_run(mmc_cmdq_thread, mq,

						 "mmc-cmdqd/%d%s",

						 host->index,

drivers/mmc/core/queue.h

+0 −2
Original line number Diff line number Diff line
@@ -48,7 +48,6 @@ enum mmc_drv_op { 
};



struct mmc_queue_req {

	struct request		*req;

	struct mmc_blk_request	brq;

	struct scatterlist	*sg;

	struct mmc_async_req	areq;
@@ -78,7 +77,6 @@ struct mmc_queue { 
	struct mmc_queue_req	mqrq[2];

	struct mmc_queue_req	*mqrq_cur;

	struct mmc_queue_req	*mqrq_prev;

	struct mmc_queue_req	*mqrq_cmdq;

	struct work_struct	cmdq_err_work;



	struct completion	cmdq_pending_req_done;