paride: convert pcd to blk-mq (89c6b165) · Commits · 戴 / test

drivers/block/paride/pcd.c

+56 −32

Original line number	Original line	Diff line number	Diff line
	@@ -137,7 +137,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/cdrom.h>		#include <linux/cdrom.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
	#include <linux/blkdev.h>		#include <linux/blk-mq.h>
	#include <linux/mutex.h>		#include <linux/mutex.h>
	#include <linux/uaccess.h>		#include <linux/uaccess.h>

	@@ -186,7 +186,8 @@ static int pcd_packet(struct cdrom_device_info *cdi,
	static int pcd_detect(void);		static int pcd_detect(void);
	static void pcd_probe_capabilities(void);		static void pcd_probe_capabilities(void);
	static void do_pcd_read_drq(void);		static void do_pcd_read_drq(void);
	static void do_pcd_request(struct request_queue * q);		static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
			const struct blk_mq_queue_data *bd);
	static void do_pcd_read(void);		static void do_pcd_read(void);

	struct pcd_unit {		struct pcd_unit {
	@@ -199,6 +200,8 @@ struct pcd_unit {
	char name; / pcd0, pcd1, etc */		char name; / pcd0, pcd1, etc */
	struct cdrom_device_info info; /* uniform cdrom interface */		struct cdrom_device_info info; /* uniform cdrom interface */
	struct gendisk *disk;		struct gendisk *disk;
			struct blk_mq_tag_set tag_set;
			struct list_head rq_list;
	};		};

	static struct pcd_unit pcd[PCD_UNITS];		static struct pcd_unit pcd[PCD_UNITS];
	@@ -292,6 +295,10 @@ static const struct cdrom_device_ops pcd_dops = {
	CDC_CD_RW,		CDC_CD_RW,
	};		};

			static const struct blk_mq_ops pcd_mq_ops = {
			.queue_rq = pcd_queue_rq,
			};

	static void pcd_init_units(void)		static void pcd_init_units(void)
	{		{
	struct pcd_unit *cd;		struct pcd_unit *cd;
	@@ -300,13 +307,19 @@ static void pcd_init_units(void)
	pcd_drive_count = 0;		pcd_drive_count = 0;
	for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {		for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
	struct gendisk *disk = alloc_disk(1);		struct gendisk *disk = alloc_disk(1);

	if (!disk)		if (!disk)
	continue;		continue;
	disk->queue = blk_init_queue(do_pcd_request, &pcd_lock);
	if (!disk->queue) {		disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops,
	put_disk(disk);		1, BLK_MQ_F_SHOULD_MERGE);
			if (IS_ERR(disk->queue)) {
			disk->queue = NULL;
	continue;		continue;
	}		}

			INIT_LIST_HEAD(&cd->rq_list);
			disk->queue->queuedata = cd;
	blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);		blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
	cd->disk = disk;		cd->disk = disk;
	cd->pi = &cd->pia;		cd->pi = &cd->pia;
	@@ -748,17 +761,17 @@ static int pcd_queue;
	static int set_next_request(void)		static int set_next_request(void)
	{		{
	struct pcd_unit *cd;		struct pcd_unit *cd;
	struct request_queue *q;
	int old_pos = pcd_queue;		int old_pos = pcd_queue;

	do {		do {
	cd = &pcd[pcd_queue];		cd = &pcd[pcd_queue];
	q = cd->present ? cd->disk->queue : NULL;
	if (++pcd_queue == PCD_UNITS)		if (++pcd_queue == PCD_UNITS)
	pcd_queue = 0;		pcd_queue = 0;
	if (q) {		if (cd->present && !list_empty(&cd->rq_list)) {
	pcd_req = blk_fetch_request(q);		pcd_req = list_first_entry(&cd->rq_list, struct request,
	if (pcd_req)		queuelist);
			list_del_init(&pcd_req->queuelist);
			blk_mq_start_request(pcd_req);
	break;		break;
	}		}
	} while (pcd_queue != old_pos);		} while (pcd_queue != old_pos);
	@@ -768,14 +781,15 @@ static int set_next_request(void)

	static void pcd_request(void)		static void pcd_request(void)
	{		{
			struct pcd_unit *cd;

	if (pcd_busy)		if (pcd_busy)
	return;		return;
	while (1) {
	if (!pcd_req && !set_next_request())		if (!pcd_req && !set_next_request())
	return;		return;

	if (rq_data_dir(pcd_req) == READ) {		cd = pcd_req->rq_disk->private_data;
	struct pcd_unit *cd = pcd_req->rq_disk->private_data;
	if (cd != pcd_current)		if (cd != pcd_current)
	pcd_bufblk = -1;		pcd_bufblk = -1;
	pcd_current = cd;		pcd_current = cd;
	@@ -784,17 +798,24 @@ static void pcd_request(void)
	pcd_buf = bio_data(pcd_req->bio);		pcd_buf = bio_data(pcd_req->bio);
	pcd_busy = 1;		pcd_busy = 1;
	ps_set_intr(do_pcd_read, NULL, 0, nice);		ps_set_intr(do_pcd_read, NULL, 0, nice);
	return;
	} else {
	__blk_end_request_all(pcd_req, BLK_STS_IOERR);
	pcd_req = NULL;
	}
	}
	}		}

	static void do_pcd_request(struct request_queue *q)		static blk_status_t pcd_queue_rq(struct blk_mq_hw_ctx *hctx,
			const struct blk_mq_queue_data *bd)
	{		{
			struct pcd_unit *cd = hctx->queue->queuedata;

			if (rq_data_dir(bd->rq) != READ) {
			blk_mq_start_request(bd->rq);
			return BLK_STS_IOERR;
			}

			spin_lock_irq(&pcd_lock);
			list_add_tail(&bd->rq->queuelist, &cd->rq_list);
	pcd_request();		pcd_request();
			spin_unlock_irq(&pcd_lock);

			return BLK_STS_OK;
	}		}

	static inline void next_request(blk_status_t err)		static inline void next_request(blk_status_t err)
	@@ -802,8 +823,10 @@ static inline void next_request(blk_status_t err)
	unsigned long saved_flags;		unsigned long saved_flags;

	spin_lock_irqsave(&pcd_lock, saved_flags);		spin_lock_irqsave(&pcd_lock, saved_flags);
	if (!__blk_end_request_cur(pcd_req, err))		if (!blk_update_request(pcd_req, err, blk_rq_cur_bytes(pcd_req))) {
			__blk_mq_end_request(pcd_req, err);
	pcd_req = NULL;		pcd_req = NULL;
			}
	pcd_busy = 0;		pcd_busy = 0;
	pcd_request();		pcd_request();
	spin_unlock_irqrestore(&pcd_lock, saved_flags);		spin_unlock_irqrestore(&pcd_lock, saved_flags);
	@@ -1011,6 +1034,7 @@ static void __exit pcd_exit(void)
	unregister_cdrom(&cd->info);		unregister_cdrom(&cd->info);
	}		}
	blk_cleanup_queue(cd->disk->queue);		blk_cleanup_queue(cd->disk->queue);
			blk_mq_free_tag_set(&cd->tag_set);
	put_disk(cd->disk);		put_disk(cd->disk);
	}		}
	unregister_blkdev(major, name);		unregister_blkdev(major, name);

Admin message