swim: convert to blk-mq (e3896d77) · Commits · 戴 / test

drivers/block/swim.c

+41 −52

Original line number	Diff line number	Diff line
		@@ -19,7 +19,7 @@
		#include <linux/module.h>
		#include <linux/fd.h>
		#include <linux/slab.h>
		#include <linux/blkdev.h>
		#include <linux/blk-mq.h>
		#include <linux/mutex.h>
		#include <linux/hdreg.h>
		#include <linux/kernel.h>
		@@ -190,6 +190,7 @@ struct floppy_state {
		int ref_count;

		struct gendisk *disk;
		struct blk_mq_tag_set tag_set;

		/* parent controller */

		@@ -211,7 +212,6 @@ enum head {
		struct swim_priv {
		struct swim __iomem *base;
		spinlock_t lock;
		int fdc_queue;
		int floppy_count;
		struct floppy_state unit[FD_MAX_UNIT];
		};
		@@ -525,58 +525,36 @@ static blk_status_t floppy_read_sectors(struct floppy_state *fs,
		return 0;
		}

		static struct request swim_next_request(struct swim_priv swd)
		static blk_status_t swim_queue_rq(struct blk_mq_hw_ctx *hctx,
		const struct blk_mq_queue_data *bd)
		{
		struct request_queue *q;
		struct request *rq;
		int old_pos = swd->fdc_queue;

		do {
		q = swd->unit[swd->fdc_queue].disk->queue;
		if (++swd->fdc_queue == swd->floppy_count)
		swd->fdc_queue = 0;
		if (q) {
		rq = blk_fetch_request(q);
		if (rq)
		return rq;
		}
		} while (swd->fdc_queue != old_pos);

		return NULL;
		}
		struct floppy_state *fs = hctx->queue->queuedata;
		struct swim_priv *swd = fs->swd;
		struct request *req = bd->rq;
		blk_status_t err;

		static void do_fd_request(struct request_queue *q)
		{
		struct swim_priv *swd = q->queuedata;
		struct request *req;
		struct floppy_state *fs;
		if (!spin_trylock_irq(&swd->lock))
		return BLK_STS_DEV_RESOURCE;

		req = swim_next_request(swd);
		while (req) {
		blk_status_t err = BLK_STS_IOERR;
		blk_mq_start_request(req);

		fs = req->rq_disk->private_data;
		if (blk_rq_pos(req) >= fs->total_secs)
		goto done;
		if (!fs->disk_in)
		goto done;
		if (rq_data_dir(req) == WRITE && fs->write_protected)
		goto done;
		if (!fs->disk_in \|\| rq_data_dir(req) == WRITE) {
		err = BLK_STS_IOERR;
		goto out;
		}

		switch (rq_data_dir(req)) {
		case WRITE:
		/* NOT IMPLEMENTED */
		break;
		case READ:
		do {
		err = floppy_read_sectors(fs, blk_rq_pos(req),
		blk_rq_cur_sectors(req),
		bio_data(req->bio));
		break;
		}
		done:
		if (!__blk_end_request_cur(req, err))
		req = swim_next_request(swd);
		}
		} while (blk_update_request(req, err, blk_rq_cur_bytes(req)));
		__blk_mq_end_request(req, err);

		err = BLK_STS_OK;
		out:
		spin_unlock_irq(&swd->lock);
		return err;

		}

		static struct floppy_struct floppy_type[4] = {
		@@ -823,6 +801,10 @@ static int swim_add_floppy(struct swim_priv *swd, enum drive_location location)
		return 0;
		}

		static const struct blk_mq_ops swim_mq_ops = {
		.queue_rq = swim_queue_rq,
		};

		static int swim_floppy_init(struct swim_priv *swd)
		{
		int err;
		@@ -852,20 +834,25 @@ static int swim_floppy_init(struct swim_priv *swd)
		spin_lock_init(&swd->lock);

		for (drive = 0; drive < swd->floppy_count; drive++) {
		struct request_queue *q;

		swd->unit[drive].disk = alloc_disk(1);
		if (swd->unit[drive].disk == NULL) {
		err = -ENOMEM;
		goto exit_put_disks;
		}
		swd->unit[drive].disk->queue = blk_init_queue(do_fd_request,
		&swd->lock);
		if (!swd->unit[drive].disk->queue) {
		err = -ENOMEM;

		q = blk_mq_init_sq_queue(&swd->unit[drive].tag_set, &swim_mq_ops,
		2, BLK_MQ_F_SHOULD_MERGE);
		if (IS_ERR(q)) {
		err = PTR_ERR(q);
		goto exit_put_disks;
		}

		swd->unit[drive].disk->queue = q;
		blk_queue_bounce_limit(swd->unit[drive].disk->queue,
		BLK_BOUNCE_HIGH);
		swd->unit[drive].disk->queue->queuedata = swd;
		swd->unit[drive].disk->queue->queuedata = &swd->unit[drive];
		swd->unit[drive].swd = swd;
		}

		@@ -895,6 +882,7 @@ exit_put_disks:
		blk_cleanup_queue(disk->queue);
		disk->queue = NULL;
		}
		blk_mq_free_tag_set(&swd->unit[drive].tag_set);
		put_disk(disk);
		}
		} while (drive--);
		@@ -970,6 +958,7 @@ static int swim_remove(struct platform_device *dev)
		for (drive = 0; drive < swd->floppy_count; drive++) {
		del_gendisk(swd->unit[drive].disk);
		blk_cleanup_queue(swd->unit[drive].disk->queue);
		blk_mq_free_tag_set(&swd->unit[drive].tag_set);
		put_disk(swd->unit[drive].disk);
		}

Admin message