Merge tag 'upstream-3.15-rc1' of git://git.infradead.org/linux-ubifs

Pull ubifs updates from Artem Bityutskiy:
 "This pull request includes the 'ubiblock' driver which provides R/O
  block access to UBI volumes.  It is useful for those who want to use
  squashfs on top of raw flash devices.  UBI will provide bit-flip
  handling and wear-levelling in this case (e.g., if there are other UBI
  volumes with R/W UBIFS too).

  The driver is actually pretty small and it is part of the UBI kernel
  subsystem.  Delivered by Ezequiel Garcia, along with a piece of
  documentation on the MTD web site and the user-space tool for creating
  and removing block devices"

* tag 'upstream-3.15-rc1' of git://git.infradead.org/linux-ubifs:
  UBI: block: Remove __initdata from ubiblock_param_ops
  UBI: make UBI_IOCVOLCRBLK take a parameter for future usage
  UBI: rename block device ioctls
  UBI: block: Use ENOSYS as return value when CONFIG_UBIBLOCK=n
  UBI: block: Add CONFIG_BLOCK dependency
  UBI: block: Use 'u64' for the 64-bit dividend
  UBI: block: Mark init-only symbol as __initdata
  UBI: block: do not use term "attach"
  UBI: R/O block driver on top of UBI volumes

7 files changed, 737 insertions, 0 deletions

diff --git a/drivers/mtd/ubi/Kconfig b/drivers/mtd/ubi/Kconfig
index 36663af56d89..f0855ce08ed9 100644
--- a/drivers/mtd/ubi/Kconfig
+++ b/drivers/mtd/ubi/Kconfig
@@ -87,4 +87,20 @@ config MTD_UBI_GLUEBI
            work on top of UBI. Do not enable this unless you use legacy
            software.
 
+config MTD_UBI_BLOCK
+        bool "Read-only block devices on top of UBI volumes"
+        default n
+        depends on BLOCK
+        help
+           This option enables read-only UBI block devices support. UBI block
+           devices will be layered on top of UBI volumes, which means that the
+           UBI driver will transparently handle things like bad eraseblocks and
+           bit-flips. You can put any block-oriented file system on top of UBI
+           volumes in read-only mode (e.g., ext4), but it is probably most
+           practical for read-only file systems, like squashfs.
+
+           When selected, this feature will be built in the UBI driver.
+
+           If in doubt, say "N".
+
 endif # MTD_UBI
diff --git a/drivers/mtd/ubi/Makefile b/drivers/mtd/ubi/Makefile
index b46b0c978581..4e3c3d70d8c3 100644
--- a/drivers/mtd/ubi/Makefile
+++ b/drivers/mtd/ubi/Makefile
@@ -3,5 +3,6 @@ obj-$(CONFIG_MTD_UBI) += ubi.o
 ubi-y += vtbl.o vmt.o upd.o build.o cdev.o kapi.o eba.o io.o wl.o attach.o
 ubi-y += misc.o debug.o
 ubi-$(CONFIG_MTD_UBI_FASTMAP) += fastmap.o
+ubi-$(CONFIG_MTD_UBI_BLOCK) += block.o
 
 obj-$(CONFIG_MTD_UBI_GLUEBI) += gluebi.o
diff --git a/drivers/mtd/ubi/block.c b/drivers/mtd/ubi/block.c
new file mode 100644
index 000000000000..7ff473c871a9
--- /dev/null
+++ b/drivers/mtd/ubi/block.c
@@ -0,0 +1,647 @@
+/*
+ * Copyright (c) 2014 Ezequiel Garcia
+ * Copyright (c) 2011 Free Electrons
+ *
+ * Driver parameter handling strongly based on drivers/mtd/ubi/build.c
+ *   Copyright (c) International Business Machines Corp., 2006
+ *   Copyright (c) Nokia Corporation, 2007
+ *   Authors: Artem Bityutskiy, Frank Haverkamp
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ */
+
+/*
+ * Read-only block devices on top of UBI volumes
+ *
+ * A simple implementation to allow a block device to be layered on top of a
+ * UBI volume. The implementation is provided by creating a static 1-to-1
+ * mapping between the block device and the UBI volume.
+ *
+ * The addressed byte is obtained from the addressed block sector, which is
+ * mapped linearly into the corresponding LEB:
+ *
+ *   LEB number = addressed byte / LEB size
+ *
+ * This feature is compiled in the UBI core, and adds a 'block' parameter
+ * to allow early creation of block devices on top of UBI volumes. Runtime
+ * block creation/removal for UBI volumes is provided through two UBI ioctls:
+ * UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#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/hdreg.h>
+#include <asm/div64.h>
+
+#include "ubi-media.h"
+#include "ubi.h"
+
+/* Maximum number of supported devices */
+#define UBIBLOCK_MAX_DEVICES 32
+
+/* Maximum length of the 'block=' parameter */
+#define UBIBLOCK_PARAM_LEN 63
+
+/* Maximum number of comma-separated items in the 'block=' parameter */
+#define UBIBLOCK_PARAM_COUNT 2
+
+struct ubiblock_param {
+        int ubi_num;
+        int vol_id;
+        char name[UBIBLOCK_PARAM_LEN+1];
+};
+
+/* Numbers of elements set in the @ubiblock_param array */
+static int ubiblock_devs __initdata;
+
+/* MTD devices specification parameters */
+static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES] __initdata;
+
+struct ubiblock {
+        struct ubi_volume_desc *desc;
+        int ubi_num;
+        int vol_id;
+        int refcnt;
+        int leb_size;
+
+        struct gendisk *gd;
+        struct request_queue *rq;
+
+        struct workqueue_struct *wq;
+        struct work_struct work;
+
+        struct mutex dev_mutex;
+        spinlock_t queue_lock;
+        struct list_head list;
+};
+
+/* Linked list of all ubiblock instances */
+static LIST_HEAD(ubiblock_devices);
+static DEFINE_MUTEX(devices_mutex);
+static int ubiblock_major;
+
+static int __init ubiblock_set_param(const char *val,
+                                     const struct kernel_param *kp)
+{
+        int i, ret;
+        size_t len;
+        struct ubiblock_param *param;
+        char buf[UBIBLOCK_PARAM_LEN];
+        char *pbuf = &buf[0];
+        char *tokens[UBIBLOCK_PARAM_COUNT];
+
+        if (!val)
+                return -EINVAL;
+
+        len = strnlen(val, UBIBLOCK_PARAM_LEN);
+        if (len == 0) {
+                ubi_warn("block: empty 'block=' parameter - ignored\n");
+                return 0;
+        }
+
+        if (len == UBIBLOCK_PARAM_LEN) {
+                ubi_err("block: parameter \"%s\" is too long, max. is %d\n",
+                        val, UBIBLOCK_PARAM_LEN);
+                return -EINVAL;
+        }
+
+        strcpy(buf, val);
+
+        /* Get rid of the final newline */
+        if (buf[len - 1] == '\n')
+                buf[len - 1] = '\0';
+
+        for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++)
+                tokens[i] = strsep(&pbuf, ",");
+
+        param = &ubiblock_param[ubiblock_devs];
+        if (tokens[1]) {
+                /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
+                ret = kstrtoint(tokens[0], 10, &param->ubi_num);
+                if (ret < 0)
+                        return -EINVAL;
+
+                /* Second param can be a number or a name */
+                ret = kstrtoint(tokens[1], 10, &param->vol_id);
+                if (ret < 0) {
+                        param->vol_id = -1;
+                        strcpy(param->name, tokens[1]);
+                }
+
+        } else {
+                /* One parameter: must be device path */
+                strcpy(param->name, tokens[0]);
+                param->ubi_num = -1;
+                param->vol_id = -1;