Merge "mmc: core: Remove obsolete members from mmc_queue" (a1d18200) · Commits · e / devices / android_kernel_oneplus_sm8150

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 −7

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;
		@@ -75,17 +74,11 @@ struct mmc_queue {
		bool asleep;
		struct mmc_blk_data *blkdata;
		struct request_queue *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;
		struct completion cmdq_shutdown_complete;
		struct request *cmdq_req_peeked;
		enum mmc_blk_status (err_check_fn)(struct mmc_card ,
		struct mmc_async_req *);
		void (cmdq_shutdown)(struct mmc_queue );
		/*
		* FIXME: this counter is not a very reliable way of keeping