1 files changed, 94 insertions, 108 deletions

diff --git a/drivers/mtd/ubi/block.c b/drivers/mtd/ubi/block.c
index 6b6bce28bd63..00caf460337e 100644
--- a/drivers/mtd/ubi/block.c
+++ b/drivers/mtd/ubi/block.c
@@ -42,11 +42,12 @@
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
-#include <linux/vmalloc.h>
 #include <linux/mtd/ubi.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
+#include <linux/blk-mq.h>
 #include <linux/hdreg.h>
+#include <linux/scatterlist.h>
 #include <asm/div64.h>
 
 #include "ubi-media.h"
@@ -67,6 +68,11 @@ struct ubiblock_param {
         char name[UBIBLOCK_PARAM_LEN+1];
 };
 
+struct ubiblock_pdu {
+        struct work_struct work;
+        struct ubi_sgl usgl;
+};
+
 /* Numbers of elements set in the @ubiblock_param array */
 static int ubiblock_devs __initdata;
 
@@ -84,11 +90,10 @@ struct ubiblock {
         struct request_queue *rq;
 
         struct workqueue_struct *wq;
-        struct work_struct work;
 
         struct mutex dev_mutex;
-        spinlock_t queue_lock;
         struct list_head list;
+        struct blk_mq_tag_set tag_set;
 };
 
 /* Linked list of all ubiblock instances */
@@ -181,31 +186,20 @@ static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id)
         return NULL;
 }
 
-static int ubiblock_read_to_buf(struct ubiblock *dev, char *buffer,
-                                int leb, int offset, int len)
+static int ubiblock_read(struct ubiblock_pdu *pdu)
 {
-        int ret;
+        int ret, leb, offset, bytes_left, to_read;
+        u64 pos;
+        struct request *req = blk_mq_rq_from_pdu(pdu);
+        struct ubiblock *dev = req->q->queuedata;
 
-        ret = ubi_read(dev->desc, leb, buffer, offset, len);
-        if (ret) {
-                dev_err(disk_to_dev(dev->gd), "%d while reading from LEB %d (offset %d, length %d)",
-                        ret, leb, offset, len);
-                return ret;
-        }
-        return 0;
-}
-
-static int ubiblock_read(struct ubiblock *dev, char *buffer,
-                         sector_t sec, int len)
-{
-        int ret, leb, offset;
-        int bytes_left = len;
-        int to_read = len;
-        u64 pos = sec << 9;
+        to_read = blk_rq_bytes(req);
+        pos = blk_rq_pos(req) << 9;
 
         /* Get LEB:offset address to read from */
         offset = do_div(pos, dev->leb_size);
         leb = pos;
+        bytes_left = to_read;
 
         while (bytes_left) {
                 /*
@@ -215,11 +209,10 @@ static int ubiblock_read(struct ubiblock *dev, char *buffer,
                 if (offset + to_read > dev->leb_size)
                         to_read = dev->leb_size - offset;
 
-                ret = ubiblock_read_to_buf(dev, buffer, leb, offset, to_read);
-                if (ret)
+                ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
+                if (ret < 0)
                         return ret;
 
-                buffer += to_read;
                 bytes_left -= to_read;
                 to_read = bytes_left;
                 leb += 1;
@@ -228,79 +221,6 @@ static int ubiblock_read(struct ubiblock *dev, char *buffer,
         return 0;
 }
 
-static int do_ubiblock_request(struct ubiblock *dev, struct request *req)
-{
-        int len, ret;
-        sector_t sec;
-
-        if (req->cmd_type != REQ_TYPE_FS)
-                return -EIO;
-
-        if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
-            get_capacity(req->rq_disk))
-                return -EIO;
-
-        if (rq_data_dir(req) != READ)
-                return -ENOSYS; /* Write not implemented */
-
-        sec = blk_rq_pos(req);
-        len = blk_rq_cur_bytes(req);
-
-        /*
-         * Let's prevent the device from being removed while we're doing I/O
-         * work. Notice that this means we serialize all the I/O operations,
-         * but it's probably of no impact given the NAND core serializes
-         * flash access anyway.
-         */
-        mutex_lock(&dev->dev_mutex);
-        ret = ubiblock_read(dev, bio_data(req->bio), sec, len);
-        mutex_unlock(&dev->dev_mutex);
-
-        return ret;
-}
-
-static void ubiblock_do_work(struct work_struct *work)
-{
-        struct ubiblock *dev =
-                container_of(work, struct ubiblock, work);
-        struct request_queue *rq = dev->rq;
-        struct request *req;
-        int res;
-
-        spin_lock_irq(rq->queue_lock);
-
-        req = blk_fetch_request(rq);
-        while (req) {
-
-                spin_unlock_irq(rq->queue_lock);
-                res = do_ubiblock_request(dev, req);
-                spin_lock_irq(rq->queue_lock);
-
-                /*
-                 * If we're done with this request,
-                 * we need to fetch a new one
-                 */
-                if (!__blk_end_request_cur(req, res))
-                        req = blk_fetch_request(rq);
-        }
-
-        spin_unlock_irq(rq->queue_lock);
-}
-
-static void ubiblock_request(struct request_queue *rq)
-{
-        struct ubiblock *dev;
-        struct request *req;
-
-        dev = rq->queuedata;
-
-        if (!dev)
-                while ((req = blk_fetch_request(rq)) != NULL)
-                        __blk_end_request_all(req, -ENODEV);
-        else
-                queue_work(dev->wq, &dev->work);
-}
-
 static int ubiblock_open(struct block_device *bdev, fmode_t mode)
 {
         struct ubiblock *dev = bdev->bd_disk->private_data;
@@ -374,6 +294,57 @@ static const struct block_device_operations ubiblock_ops = {
         .getgeo = ubiblock_getgeo,
 };
 
+static void ubiblock_do_work(struct work_struct *work)
+{
+        int ret;
+        struct ubiblock_pdu *pdu = container_of(work, struct ubiblock_pdu, work);
+        struct request *req = blk_mq_rq_from_pdu(pdu);
+
+        blk_mq_start_request(req);
+        blk_rq_map_sg(req->q, req, pdu->usgl.sg);
+
+        ret = ubiblock_read(pdu);
+        blk_mq_end_request(req, ret);
+}
+
+static int ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
+                             const struct blk_mq_queue_data *bd)
+{
+        struct request *req = bd->rq;
+        struct ubiblock *dev = hctx->queue->queuedata;
+        struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
+
+        if (req->cmd_type != REQ_TYPE_FS)
+                return BLK_MQ_RQ_QUEUE_ERROR;
+
+        if (rq_data_dir(req) != READ)