Merge commit 'v2.6.29-rc7' into next

21 files changed, 233 insertions, 148 deletions

diff --git a/drivers/mtd/chips/map_rom.c b/drivers/mtd/chips/map_rom.c
index 821d0ed6bae3..c76d6e5f47ee 100644
--- a/drivers/mtd/chips/map_rom.c
+++ b/drivers/mtd/chips/map_rom.c
@@ -19,6 +19,7 @@ static int maprom_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
 static int maprom_write (struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
 static void maprom_nop (struct mtd_info *);
 static struct mtd_info *map_rom_probe(struct map_info *map);
+static int maprom_erase (struct mtd_info *mtd, struct erase_info *info);
 
 static struct mtd_chip_driver maprom_chipdrv = {
         .probe  = map_rom_probe,
@@ -42,6 +43,7 @@ static struct mtd_info *map_rom_probe(struct map_info *map)
         mtd->read = maprom_read;
         mtd->write = maprom_write;
         mtd->sync = maprom_nop;
+        mtd->erase = maprom_erase;
         mtd->flags = MTD_CAP_ROM;
         mtd->erasesize = map->size;
         mtd->writesize = 1;
@@ -71,6 +73,12 @@ static int maprom_write (struct mtd_info *mtd, loff_t to, size_t len, size_t *re
         return -EIO;
 }
 
+static int maprom_erase (struct mtd_info *mtd, struct erase_info *info)
+{
+        /* We do our best 8) */
+        return -EROFS;
+}
+
 static int __init map_rom_init(void)
 {
         register_mtd_chip_driver(&maprom_chipdrv);
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index a425d09f35a0..00248e81ecd5 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -267,22 +267,28 @@ static int parse_cmdline(char *devname, char *szstart, char *szlength)
         if (*(szlength) != '+') {
                 devlength = simple_strtoul(szlength, &buffer, 0);
                 devlength = handle_unit(devlength, buffer) - devstart;
+                if (devlength < devstart)
+                        goto err_out;
+
+                devlength -= devstart;
         } else {
                 devlength = simple_strtoul(szlength + 1, &buffer, 0);
                 devlength = handle_unit(devlength, buffer);
         }
         T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
                         devname, devstart, devlength);
-        if ((devstart < 0) || (devlength < 0) || (devlength % SLRAM_BLK_SZ != 0)) {
-                E("slram: Illegal start / length parameter.\n");
-                return(-EINVAL);
-        }
+        if (devlength % SLRAM_BLK_SZ != 0)
+                goto err_out;
 
         if ((devstart = register_device(devname, devstart, devlength))){
                 unregister_devices();
                 return((int)devstart);
         }
         return(0);
+
+err_out:
+        E("slram: Illegal length parameter.\n");
+        return(-EINVAL);
 }
 
 #ifndef MODULE
diff --git a/drivers/mtd/lpddr/Kconfig b/drivers/mtd/lpddr/Kconfig
index acd4ea9b2278..5a401d8047ab 100644
--- a/drivers/mtd/lpddr/Kconfig
+++ b/drivers/mtd/lpddr/Kconfig
@@ -12,6 +12,7 @@ config MTD_LPDDR
           DDR memories, intended for battery-operated systems.
 
 config MTD_QINFO_PROBE
+        depends on MTD_LPDDR
         tristate "Detect flash chips by QINFO probe"
         help
             Device Information for LPDDR chips is offered through the Overlay
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 0225cbbf22de..043d50fb6ef6 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -491,7 +491,7 @@ config MTD_PCMCIA_ANONYMOUS
 
 config MTD_BFIN_ASYNC
         tristate "Blackfin BF533-STAMP Flash Chip Support"
-        depends on BFIN533_STAMP && MTD_CFI
+        depends on BFIN533_STAMP && MTD_CFI && MTD_COMPLEX_MAPPINGS
         select MTD_PARTITIONS
         default y
         help
diff --git a/drivers/mtd/maps/bfin-async-flash.c b/drivers/mtd/maps/bfin-async-flash.c
index 6fec86aaed7e..576611f605db 100644
--- a/drivers/mtd/maps/bfin-async-flash.c
+++ b/drivers/mtd/maps/bfin-async-flash.c
@@ -152,14 +152,18 @@ static int __devinit bfin_flash_probe(struct platform_device *pdev)
 
         if (gpio_request(state->enet_flash_pin, DRIVER_NAME)) {
                 pr_devinit(KERN_ERR DRIVER_NAME ": Failed to request gpio %d\n", state->enet_flash_pin);
+                kfree(state);
                 return -EBUSY;
         }
         gpio_direction_output(state->enet_flash_pin, 1);
 
         pr_devinit(KERN_NOTICE DRIVER_NAME ": probing %d-bit flash bus\n", state->map.bankwidth * 8);
         state->mtd = do_map_probe(memory->name, &state->map);
-        if (!state->mtd)
+        if (!state->mtd) {
+                gpio_free(state->enet_flash_pin);
+                kfree(state);
                 return -ENXIO;
+        }
 
 #ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(state->mtd, part_probe_types, &pdata->parts, 0);
diff --git a/drivers/mtd/maps/ck804xrom.c b/drivers/mtd/maps/ck804xrom.c
index 5f7a245ed132..424f17d6ffd1 100644
--- a/drivers/mtd/maps/ck804xrom.c
+++ b/drivers/mtd/maps/ck804xrom.c
@@ -342,9 +342,9 @@ static struct pci_device_id ck804xrom_pci_tbl[] = {
         { 0, }
 };
 
+#if 0
 MODULE_DEVICE_TABLE(pci, ck804xrom_pci_tbl);
 
-#if 0
 static struct pci_driver ck804xrom_driver = {
         .name =         MOD_NAME,
         .id_table =     ck804xrom_pci_tbl,
diff --git a/drivers/mtd/maps/physmap.c b/drivers/mtd/maps/physmap.c
index 87743661d48e..4b122e7ab4b3 100644
--- a/drivers/mtd/maps/physmap.c
+++ b/drivers/mtd/maps/physmap.c
@@ -29,6 +29,7 @@ struct physmap_flash_info {
         struct map_info         map[MAX_RESOURCES];
 #ifdef CONFIG_MTD_PARTITIONS
         int                     nr_parts;
+        struct mtd_partition    *parts;
 #endif
 };
 
@@ -45,25 +46,26 @@ static int physmap_flash_remove(struct platform_device *dev)
 
         physmap_data = dev->dev.platform_data;
 
-#ifdef CONFIG_MTD_CONCAT
-        if (info->cmtd != info->mtd[0]) {
+#ifdef CONFIG_MTD_PARTITIONS
+        if (info->nr_parts) {
+                del_mtd_partitions(info->cmtd);
+                kfree(info->parts);
+        } else if (physmap_data->nr_parts)
+                del_mtd_partitions(info->cmtd);
+        else
                 del_mtd_device(info->cmtd);
+#else
+        del_mtd_device(info->cmtd);
+#endif
+
+#ifdef CONFIG_MTD_CONCAT
+        if (info->cmtd != info->mtd[0])
                 mtd_concat_destroy(info->cmtd);
-        }
 #endif
 
         for (i = 0; i < MAX_RESOURCES; i++) {
-                if (info->mtd[i] != NULL) {
-#ifdef CONFIG_MTD_PARTITIONS
-                        if (info->nr_parts || physmap_data->nr_parts)
-                                del_mtd_partitions(info->mtd[i]);
-                        else
-                                del_mtd_device(info->mtd[i]);
-#else
-                        del_mtd_device(info->mtd[i]);
-#endif
+                if (info->mtd[i] != NULL)
                         map_destroy(info->mtd[i]);
-                }
         }
         return 0;
 }
@@ -86,9 +88,6 @@ static int physmap_flash_probe(struct platform_device *dev)
         int err = 0;
         int i;
         int devices_found = 0;
-#ifdef CONFIG_MTD_PARTITIONS
-        struct mtd_partition *parts;
-#endif
 
         physmap_data = dev->dev.platform_data;
         if (physmap_data == NULL)
@@ -167,10 +166,11 @@ static int physmap_flash_probe(struct platform_device *dev)
                 goto err_out;
 
 #ifdef CONFIG_MTD_PARTITIONS
-        err = parse_mtd_partitions(info->cmtd, part_probe_types, &parts, 0);
+        err = parse_mtd_partitions(info->cmtd, part_probe_types,
+                                &info->parts, 0);
         if (err > 0) {
-                add_mtd_partitions(info->cmtd, parts, err);
-                kfree(parts);
+                add_mtd_partitions(info->cmtd, info->parts, err);
+                info->nr_parts = err;
                 return 0;
         }
 
diff --git a/drivers/mtd/maps/sa1100-flash.c b/drivers/mtd/maps/sa1100-flash.c
index 7df6bbf0e4d9..6f6a0f6dafd6 100644
--- a/drivers/mtd/maps/sa1100-flash.c
+++ b/drivers/mtd/maps/sa1100-flash.c
@@ -453,7 +453,7 @@ static struct platform_driver sa1100_mtd_driver = {
         .resume         = sa1100_mtd_resume,
         .shutdown       = sa1100_mtd_shutdown,
         .driver         = {
-                .name   = "flash",
+                .name   = "sa1100-mtd",
                 .owner  = THIS_MODULE,
         },
 };
@@ -474,4 +474,4 @@ module_exit(sa1100_mtd_exit);
 MODULE_AUTHOR("Nicolas Pitre");
 MODULE_DESCRIPTION("SA1100 CFI map driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:flash");
+MODULE_ALIAS("platform:sa1100-mtd");
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index c98c1570a40b..47a33cec3793 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -139,7 +139,8 @@ static int atmel_nand_device_ready(struct mtd_info *mtd)
         struct nand_chip *nand_chip = mtd->priv;
         struct atmel_nand_host *host = nand_chip->priv;
 
-        return gpio_get_value(host->board->rdy_pin);
+        return gpio_get_value(host->board->rdy_pin) ^
+                !!host->board->rdy_pin_active_low;
 }
 
 /*
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 65929db29446..1f6eb2578717 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -676,7 +676,7 @@ static int fsl_elbc_chip_init_tail(struct mtd_info *mtd)
 
         dev_dbg(ctrl->dev, "fsl_elbc_init: nand->numchips = %d\n",
                 chip->numchips);
-        dev_dbg(ctrl->dev, "fsl_elbc_init: nand->chipsize = %ld\n",
+        dev_dbg(ctrl->dev, "fsl_elbc_init: nand->chipsize = %lld\n",
                 chip->chipsize);
         dev_dbg(ctrl->dev, "fsl_elbc_init: nand->pagemask = %8x\n",
                 chip->pagemask);
@@ -703,7 +703,7 @@ static int fsl_elbc_chip_init_tail(struct mtd_info *mtd)
         dev_dbg(ctrl->dev, "fsl_elbc_init: nand->ecc.layout = %p\n",
                 chip->ecc.layout);
         dev_dbg(ctrl->dev, "fsl_elbc_init: mtd->flags = %08x\n", mtd->flags);
-        dev_dbg(ctrl->dev, "fsl_elbc_init: mtd->size = %d\n", mtd->size);
+        dev_dbg(ctrl->dev, "fsl_elbc_init: mtd->size = %lld\n", mtd->size);
         dev_dbg(ctrl->dev, "fsl_elbc_init: mtd->erasesize = %d\n",
                 mtd->erasesize);
         dev_dbg(ctrl->dev, "fsl_elbc_init: mtd->writesize = %d\n",
@@ -932,8 +932,8 @@ static int __devinit fsl_elbc_chip_probe(struct fsl_elbc_ctrl *ctrl,
 #endif
                 add_mtd_device(&priv->mtd);
 
-        printk(KERN_INFO "eLBC NAND device at 0x%zx, bank %d\n",
-               res.start, priv->bank);
+        printk(KERN_INFO "eLBC NAND device at 0x%llx, bank %d\n",
+               (unsigned long long)res.start, priv->bank);
         return 0;
 
 err:
diff --git a/drivers/mtd/nand/orion_nand.c b/drivers/mtd/nand/orion_nand.c
index 917cf8d3ae95..c2dfd3ea353d 100644
--- a/drivers/mtd/nand/orion_nand.c
+++ b/drivers/mtd/nand/orion_nand.c
@@ -149,7 +149,7 @@ static int __devexit orion_nand_remove(struct platform_device *pdev)
 
 static struct platform_driver orion_nand_driver = {
         .probe          = orion_nand_probe,
-        .remove         = orion_nand_remove,
+        .remove         = __devexit_p(orion_nand_remove),
         .driver         = {
                 .name   = "orion_nand",
                 .owner  = THIS_MODULE,
diff --git a/drivers/mtd/nand/pasemi_nand.c b/drivers/mtd/nand/pasemi_nand.c
index 9bd6c9ac8443..a8b9376cf324 100644
--- a/drivers/mtd/nand/pasemi_nand.c
+++ b/drivers/mtd/nand/pasemi_nand.c
@@ -107,7 +107,7 @@ static int __devinit pasemi_nand_probe(struct of_device *ofdev,
         if (pasemi_nand_mtd)
                 return -ENODEV;
 
-        pr_debug("pasemi_nand at %lx-%lx\n", res.start, res.end);
+        pr_debug("pasemi_nand at %llx-%llx\n", res.start, res.end);
 
         /* Allocate memory for MTD device structure and private data */
         pasemi_nand_mtd = kzalloc(sizeof(struct mtd_info) +
@@ -170,7 +170,7 @@ static int __devinit pasemi_nand_probe(struct of_device *ofdev,
                 goto out_lpc;
         }
 
-        printk(KERN_INFO "PA Semi NAND flash at %08lx, control at I/O %x\n",
+        printk(KERN_INFO "PA Semi NAND flash at %08llx, control at I/O %x\n",
                res.start, lpcctl);
 
         return 0;
diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c
index 96ecc1766fa8..77a4f1446156 100644
--- a/drivers/mtd/onenand/omap2.c
+++ b/drivers/mtd/onenand/omap2.c
@@ -629,7 +629,7 @@ static int __devinit omap2_onenand_probe(struct platform_device *pdev)
         }
 
         if (c->gpio_irq) {
-                if ((r = omap_request_gpio(c->gpio_irq)) < 0) {
+                if ((r = gpio_request(c->gpio_irq, "OneNAND irq")) < 0) {
                         dev_err(&pdev->dev,  "Failed to request GPIO%d for "
                                 "OneNAND\n", c->gpio_irq);
                         goto err_iounmap;
@@ -726,7 +726,7 @@ err_release_dma:
                 free_irq(gpio_to_irq(c->gpio_irq), c);
 err_release_gpio:
         if (c->gpio_irq)
-                omap_free_gpio(c->gpio_irq);
+                gpio_free(c->gpio_irq);
 err_iounmap:
         iounmap(c->onenand.base);
 err_release_mem_region:
@@ -761,7 +761,7 @@ static int __devexit omap2_onenand_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
         if (c->gpio_irq) {
                 free_irq(gpio_to_irq(c->gpio_irq), c);
-                omap_free_gpio(c->gpio_irq);
+                gpio_free(c->gpio_irq);
         }
         iounmap(c->onenand.base);
         release_mem_region(c->phys_base, ONENAND_IO_SIZE);
diff --git a/drivers/mtd/ubi/Kconfig.debug b/drivers/mtd/ubi/Kconfig.debug
index 1e2ee22edeff..2246f154e2f7 100644
--- a/drivers/mtd/ubi/Kconfig.debug
+++ b/drivers/mtd/ubi/Kconfig.debug
@@ -33,16 +33,6 @@ config MTD_UBI_DEBUG_DISABLE_BGT
           This option switches the background thread off by default. The thread
           may be also be enabled/disabled via UBI sysfs.
 
-config MTD_UBI_DEBUG_USERSPACE_IO
-        bool "Direct user-space write/erase support"
-        default n
-        depends on MTD_UBI_DEBUG
-        help
-          By default, users cannot directly write and erase individual
-          eraseblocks of dynamic volumes, and have to use update operation
-          instead. This option enables this capability - it is very useful for
-          debugging and testing.
-
 config MTD_UBI_DEBUG_EMULATE_BITFLIPS
         bool "Emulate flash bit-flips"
         depends on MTD_UBI_DEBUG
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 9082768cc6c3..4048db83aef6 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -263,8 +263,12 @@ static ssize_t dev_attribute_show(struct device *dev,
         return ret;
 }
 
-/* Fake "release" method for UBI devices */
-static void dev_release(struct device *dev) { }
+static void dev_release(struct device *dev)
+{
+        struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
+
+        kfree(ubi);
+}
 
 /**
  * ubi_sysfs_init - initialize sysfs for an UBI device.
@@ -380,7 +384,7 @@ static void free_user_volumes(struct ubi_device *ubi)
  */
 static int uif_init(struct ubi_device *ubi)
 {
-        int i, err, do_free = 0;
+        int i, err;
         dev_t dev;
 
         sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
@@ -427,13 +431,10 @@ static int uif_init(struct ubi_device *ubi)
 
 out_volumes:
         kill_volumes(ubi);
-        do_free = 0;
 out_sysfs:
         ubi_sysfs_close(ubi);
         cdev_del(&ubi->cdev);
 out_unreg:
-        if (do_free)
-                free_user_volumes(ubi);
         unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
         ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
         return err;
@@ -947,6 +948,12 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
         if (ubi->bgt_thread)
                 kthread_stop(ubi->bgt_thread);
 
+        /*
+         * Get a reference to the device in order to prevent 'dev_release()'
+         * from freeing @ubi object.
+         */
+        get_device(&ubi->dev);
+
         uif_close(ubi);
         ubi_wl_close(ubi);
         free_internal_volumes(ubi);
@@ -958,7 +965,7 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
         vfree(ubi->dbg_peb_buf);
 #endif
         ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
-        kfree(ubi);
+        put_device(&ubi->dev);
         return 0;
 }
 
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 98cf31ed0814..e63c8fc3df3a 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -40,9 +40,9 @@
 #include <linux/ioctl.h>
 #include <linux/capability.h>
 #include <linux/uaccess.h>
-#include <linux/smp_lock.h>
+#include <linux/compat.h>
+#include <linux/math64.h>
 #include <mtd/ubi-user.h>
-#include <asm/div64.h>
 #include "ubi.h"
 
 /**
@@ -195,7 +195,6 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count,
         int err, lnum, off, len,  tbuf_size;
         size_t count_save = count;
         void *tbuf;
-        uint64_t tmp;
 
         dbg_gen("read %zd bytes from offset %lld of volume %d",
                 count, *offp, vol->vol_id);
@@ -225,10 +224,7 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count,
                 return -ENOMEM;
 
         len = count > tbuf_size ? tbuf_size : count;
-
-        tmp = *offp;
-        off = do_div(tmp, vol->usable_leb_size);
-        lnum = tmp;
+        lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);
 
         do {
                 cond_resched();
@@ -263,12 +259,9 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count,
         return err ? err : count_save - count;
 }
 
-#ifdef CONFIG_MTD_UBI_DEBUG_USERSPACE_IO
-
 /*
  * This function allows to directly write to dynamic UBI volumes, without
- * issuing the volume update operation. Available only as a debugging feature.
- * Very useful for testing UBI.
+ * issuing the volume update operation.
  */
 static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
                                      size_t count, loff_t *offp)
@@ -279,7 +272,9 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
         int lnum, off, len, tbuf_size, err = 0;
         size_t count_save = count;
         char *tbuf;
-        uint64_t tmp;
+
+        if (!vol->direct_writes)
+                return -EPERM;
 
         dbg_gen("requested: write %zd bytes to offset %lld of volume %u",
                 count, *offp, vol->vol_id);
@@ -287,10 +282,7 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
         if (vol->vol_type == UBI_STATIC_VOLUME)
                 return -EROFS;
 
-        tmp = *offp;
-        off = do_div(tmp, vol->usable_leb_size);
-        lnum = tmp;
-
+        lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);
         if (off & (ubi->min_io_size - 1)) {
                 dbg_err("unaligned position");
                 return -EINVAL;
@@ -347,10 +339,6 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
         return err ? err : count_save - count;
 }
 
-#else
-#define vol_cdev_direct_write(file, buf, count, offp) (-EPERM)
-#endif /* CONFIG_MTD_UBI_DEBUG_USERSPACE_IO */
-
 static ssize_t vol_cdev_write(struct file *file, const char __user *buf,
                               size_t count, loff_t *offp)
 {
@@ -402,8 +390,8 @@ static ssize_t vol_cdev_write(struct file *file, const char __user *buf,
         return count;
 }
 
-static int vol_cdev_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long vol_cdev_ioctl(struct file *file, unsigned int cmd,
+                           unsigned long arg)
 {
         int err = 0;
         struct ubi_volume_desc *desc = file->private_data;
@@ -487,7 +475,6 @@ static int vol_cdev_ioctl(struct inode *inode, struct file *file,
                 break;
         }
 
-#ifdef CONFIG_MTD_UBI_DEBUG_USERSPACE_IO
         /* Logical eraseblock erasure command */
         case UBI_IOCEBER:
         {
@@ -518,13 +505,77 @@ static int vol_cdev_ioctl(struct inode *inode, struct file *file,
                 err = ubi_wl_flush(ubi);
                 break;
         }
-#endif
+
+        /* Logical eraseblock map command */
+        case UBI_IOCEBMAP:
+        {
+                struct ubi_map_req req;
+
+                err = copy_from_user(&req, argp, sizeof(struct ubi_map_req));
+                if (err) {
+                        err = -EFAULT;
+                        break;
+                }
+                err = ubi_leb_map(desc, req.lnum, req.dtype);
+                break;
+        }
+
+        /* Logical eraseblock un-map command */
+        case UBI_IOCEBUNMAP:
+        {
+                int32_t lnum;
+
+                err = get_user(lnum, (__user int32_t *)argp);
+                if (err) {
+                        err = -EFAULT;
+                        break;
+                }
+                err = ubi_leb_unmap(desc, lnum);
+                break;
+        }
+
+        /* Check if logical eraseblock is mapped command */
+        case UBI_IOCEBISMAP:
+        {
+                int32_t lnum;
+
+                err = get_user(lnum, (__user int32_t *)argp);
+                if (err) {
+                        err = -EFAULT;
+                        break;
+                }
+                err = ubi_is_mapped(desc, lnum);
+                break;
+        }
+
+        /* Set volume property command*/
+        case UBI_IOCSETPROP:
+        {
+                struct ubi_set_prop_req req;
+
+                err = copy_from_user(&req, argp,
+                                sizeof(struct ubi_set_prop_req));
+                if (err) {
+                        err = -EFAULT;
+                        break;
+                }
+                switch (req.property) {
+                case UBI_PROP_DIRECT_WRITE:
+                        mutex_lock(&ubi->volumes_mutex);
+                        desc->vol->direct_writes = !!req.value;
+                        mutex_unlock(&ubi->volumes_mutex);
+                        break;
+                default:
+                        err = -EINVAL;
+                        break;
+                }
+                break;
+        }
 
         default:
                 err = -ENOTTY;
                 break;
         }
-
         return err;
 }
 
@@ -762,8 +813,8 @@ out_free:
         return err;
 }
 
-static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long ubi_cdev_ioctl(struct file *file, unsigned int cmd,
+                           unsigned long arg)
 {
         int err = 0;
         struct ubi_device *ubi;
@@ -773,7 +824,7 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
         if (!capable(CAP_SYS_RESOURCE))
                 return -EPERM;
 
-        ubi = ubi_get_by_major(imajor(inode));
+        ubi = ubi_get_by_major(imajor(file->f_mapping->host));
         if (!ubi)
                 return -ENODEV;
 
@@ -843,7 +894,6 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
         case UBI_IOCRSVOL:
         {
                 int pebs;
-                uint64_t tmp;
                 struct ubi_rsvol_req req;
 
                 dbg_gen("re-size volume");
@@ -863,9 +913,8 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
                         break;
                 }
 
-                tmp = req.bytes;
-                pebs = !!do_div(tmp, desc->vol->usable_leb_size);
-                pebs += tmp;
+                pebs = div_u64(req.bytes + desc->vol->usable_leb_size - 1,
+                               desc->vol->usable_leb_size);
 
                 mutex_lock(&ubi->volumes_mutex);
                 err = ubi_resize_volume(desc, pebs);
@@ -909,8 +958,8 @@ static int ubi_cdev_ioctl(struct inode *inode, struct file *file,
         return err;
 }
 
-static int ctrl_cdev_ioctl(struct inode *inode, struct file *file,
-                           unsigned int cmd, unsigned long arg)
+static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd,
+                            unsigned long arg)
 {
         int err = 0;
         void __user *argp = (void __user *)arg;
@@ -986,26 +1035,59 @@ static int ctrl_cdev_ioctl(struct inode *inode, struct file *file,
         return err;
 }
 
-/* UBI control character device operations */
-struct file_operations ubi_ctrl_cdev_operations = {
-        .ioctl = ctrl_cdev_ioctl,
-        .owner = THIS_MODULE,
+#ifdef CONFIG_COMPAT
+static long vol_cdev_compat_ioctl(struct file *file, unsigned int cmd,
+                                  unsigned long arg)
+{
+        unsigned long translated_arg = (unsigned long)compat_ptr(arg);
+
+        return vol_cdev_ioctl(file, cmd, translated_arg);
+}
+
+static long ubi_cdev_compat_ioctl(struct file *file, unsigned int cmd,
+                                  unsigned long arg)
+{
+        unsigned long translated_arg = (unsigned long)compat_ptr(arg);
+
+        return ubi_cdev_ioctl(file, cmd, translated_arg);
+}
+
+static long ctrl_cdev_compat_ioctl(struct file *file, unsigned int cmd,
+                                   unsigned long arg)
+{
+        unsigned long translated_arg = (unsigned long)compat_ptr(arg);
+
+        return ctrl_cdev_ioctl(file, cmd, translated_arg);
+}
+#else
+#define vol_cdev_compat_ioctl  NULL
+#define ubi_cdev_compat_ioctl  NULL
+#define ctrl_cdev_compat_ioctl NULL
+#endif
+
+/* UBI volume character device operations */
+const struct file_operations ubi_vol_cdev_operations = {
+        .owner          = THIS_MODULE,
+        .open           = vol_cdev_open,
+        .release        = vol_cdev_release,
+        .llseek         = vol_cdev_llseek,
+        .read           = vol_cdev_read,
+        .write          = vol_cdev_write,
+        .unlocked_ioctl = vol_cdev_ioctl,
+        .compat_ioctl   = vol_cdev_compat_ioctl,
 };
 
 /* UBI character device operations */
-struct file_operations ubi_cdev_operations = {
-        .owner = THIS_MODULE,
-        .ioctl = ubi_cdev_ioctl,
-        .llseek = no_llseek,
+const struct file_operations ubi_cdev_operations = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .unlocked_ioctl = ubi_cdev_ioctl,
+        .compat_ioctl   = ubi_cdev_compat_ioctl,
 };
 
-/* UBI volume character device operations */
-struct file_operations ubi_vol_cdev_operations = {
-        .owner   = THIS_MODULE,
-        .open    = vol_cdev_open,
-        .release = vol_cdev_release,
-        .llseek  = vol_cdev_llseek,
-        .read    = vol_cdev_read,
-        .write   = vol_cdev_write,
-        .ioctl   = vol_cdev_ioctl,
+/* UBI control character device operations */
+const struct file_operations ubi_ctrl_cdev_operations = {
+        .owner          = THIS_MODULE,
+        .unlocked_ioctl = ctrl_cdev_ioctl,
+        .compat_ioctl   = ctrl_cdev_compat_ioctl,
 };
diff --git a/drivers/mtd/ubi/gluebi.c b/drivers/mtd/ubi/gluebi.c
index 6dd4f5e77f82..49cd55ade9c8 100644
--- a/drivers/mtd/ubi/gluebi.c
+++ b/drivers/mtd/ubi/gluebi.c
@@ -28,7 +28,7 @@
  * eraseblock size is equivalent to the logical eraseblock size of the volume.
  */
 
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include "ubi.h"
 
 /**
@@ -109,7 +109,6 @@ static int gluebi_read(struct mtd_info *mtd, loff_t from, size_t len,
         int err = 0, lnum, offs, total_read;
         struct ubi_volume *vol;
         struct ubi_device *ubi;
-        uint64_t tmp = from;
 
         dbg_gen("read %zd bytes from offset %lld", len, from);
 
@@ -119,9 +118,7 @@ static int gluebi_read(struct mtd_info *mtd, loff_t from, size_t len,
         vol = container_of(mtd, struct ubi_volume, gluebi_mtd);
         ubi = vol->ubi;
 
-        offs = do_div(tmp, mtd->erasesize);
-        lnum = tmp;
-
+        lnum = div_u64_rem(from, mtd->erasesize, &offs);
         total_read = len;
         while (total_read) {
                 size_t to_read = mtd->erasesize - offs;
@@ -160,7 +157,6 @@ static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len,
         int err = 0, lnum, offs, total_written;
         struct ubi_volume *vol;
         struct ubi_device *ubi;
-        uint64_t tmp = to;
 
         dbg_gen("write %zd bytes to offset %lld", len, to);
 
@@ -173,8 +169,7 @@ static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len,
         if (ubi->ro_mode)
                 return -EROFS;
 
-        offs = do_div(tmp, mtd->erasesize);
-        lnum = tmp;
+        lnum = div_u64_rem(to, mtd->erasesize, &offs);
 
         if (len % mtd->writesize || offs % mtd->writesize)
                 return -EINVAL;
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index ecde202a5a12..c3d653ba5ca0 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -42,7 +42,7 @@
 
 #include <linux/err.h>
 #include <linux/crc32.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include "ubi.h"
 
 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
@@ -904,10 +904,8 @@ struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
         dbg_msg("scanning is finished");
 
         /* Calculate mean erase counter */
-        if (si->ec_count) {
-                do_div(si->ec_sum, si->ec_count);
-                si->mean_ec = si->ec_sum;
-        }
+        if (si->ec_count)
+                si->mean_ec = div_u64(si->ec_sum, si->ec_count);
 
         if (si->is_empty)
                 ubi_msg("empty MTD device detected");
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 4a8ec485c91d..c055511bb1b2 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -206,6 +206,7 @@ struct ubi_volume_desc;
  * @upd_marker: %1 if the update marker is set for this volume
  * @updating: %1 if the volume is being updated
  * @changing_leb: %1 if the atomic LEB change ioctl command is in progress
+ * @direct_writes: %1 if direct writes are enabled for this volume
  *
  * @gluebi_desc: gluebi UBI volume descriptor
  * @gluebi_refcount: reference count of the gluebi MTD device
@@ -253,6 +254,7 @@ struct ubi_volume {
         unsigned int upd_marker:1;
         unsigned int updating:1;
         unsigned int changing_leb:1;
+        unsigned int direct_writes:1;
 
 #ifdef CONFIG_MTD_UBI_GLUEBI
         /*
@@ -304,7 +306,8 @@ struct ubi_wl_entry;
  * @vtbl_size: size of the volume table in bytes
  * @vtbl: in-RAM volume table copy
  * @volumes_mutex: protects on-flash volume table and serializes volume
- *                 changes, like creation, deletion, update, re-size and re-name
+ *                 changes, like creation, deletion, update, re-size,
+ *                 re-name and set property
  *
  * @max_ec: current highest erase counter value
  * @mean_ec: current mean erase counter value
@@ -449,9 +452,9 @@ struct ubi_device {
 };
 
 extern struct kmem_cache *ubi_wl_entry_slab;
-extern struct file_operations ubi_ctrl_cdev_operations;
-extern struct file_operations ubi_cdev_operations;
-extern struct file_operations ubi_vol_cdev_operations;
+extern const struct file_operations ubi_ctrl_cdev_operations;
+extern const struct file_operations ubi_cdev_operations;
+extern const struct file_operations ubi_vol_cdev_operations;
 extern struct class *ubi_class;
 extern struct mutex ubi_devices_mutex;
 
diff --git a/drivers/mtd/ubi/upd.c b/drivers/mtd/ubi/upd.c
index 8b89cc18ff0b..6b4d1ae891ae 100644
--- a/drivers/mtd/ubi/upd.c
+++ b/drivers/mtd/ubi/upd.c
@@ -40,7 +40,7 @@
 
 #include <linux/err.h>
 #include <linux/uaccess.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include "ubi.h"
 
 /**
@@ -89,7 +89,6 @@ static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,
                                long long bytes)
 {
         int err;
-        uint64_t tmp;
         struct ubi_vtbl_record vtbl_rec;
 
         dbg_gen("clear update marker for volume %d", vol->vol_id);
@@ -101,9 +100,9 @@ static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,
 
         if (vol->vol_type == UBI_STATIC_VOLUME) {
                 vol->corrupted = 0;
-                vol->used_bytes = tmp = bytes;
-                vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size);
-                vol->used_ebs = tmp;
+                vol->used_bytes = bytes;
+                vol->used_ebs = div_u64_rem(bytes, vol->usable_leb_size,
+                                            &vol->last_eb_bytes);
                 if (vol->last_eb_bytes)
                         vol->used_ebs += 1;
                 else
@@ -131,7 +130,6 @@ int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
                      long long bytes)
 {
         int i, err;
-        uint64_t tmp;
 
         dbg_gen("start update of volume %d, %llu bytes", vol->vol_id, bytes);
         ubi_assert(!vol->updating && !vol->changing_leb);
@@ -161,9 +159,8 @@ int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
         if (!vol->upd_buf)
                 return -ENOMEM;
 
-        tmp = bytes;
-        vol->upd_ebs = !!do_div(tmp, vol->usable_leb_size);
-        vol->upd_ebs += tmp;
+        vol->upd_ebs = div_u64(bytes + vol->usable_leb_size - 1,
+                               vol->usable_leb_size);
         vol->upd_bytes = bytes;
         vol->upd_received = 0;
         return 0;
@@ -282,7 +279,6 @@ static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
 int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
                          const void __user *buf, int count)
 {
-        uint64_t tmp;
         int lnum, offs, err = 0, len, to_write = count;
 
         dbg_gen("write %d of %lld bytes, %lld already passed",
@@ -291,10 +287,7 @@ int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
         if (ubi->ro_mode)
                 return -EROFS;
 
-        tmp = vol->upd_received;
-        offs = do_div(tmp, vol->usable_leb_size);
-        lnum = tmp;
-
+        lnum = div_u64_rem(vol->upd_received,  vol->usable_leb_size, &offs);
         if (vol->upd_received + count > vol->upd_bytes)
                 to_write = count = vol->upd_bytes - vol->upd_received;
 
diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
index 22e1d7398fce..df5483562b7a 100644
--- a/drivers/mtd/ubi/vmt.c
+++ b/drivers/mtd/ubi/vmt.c
@@ -24,7 +24,7 @@
  */
 
 #include <linux/err.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include "ubi.h"
 
 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
@@ -205,7 +205,6 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
         int i, err, vol_id = req->vol_id, do_free = 1;
         struct ubi_volume *vol;
         struct ubi_vtbl_record vtbl_rec;
-        uint64_t bytes;
         dev_t dev;
 
         if (ubi->ro_mode)
@@ -255,10 +254,8 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
 
         /* Calculate how many eraseblocks are requested */
         vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
-        bytes = req->bytes;
-        if (do_div(bytes, vol->usable_leb_size))
-                vol->reserved_pebs = 1;
-        vol->reserved_pebs += bytes;
+        vol->reserved_pebs += div_u64(req->bytes + vol->usable_leb_size - 1,
+                                      vol->usable_leb_size);
 
         /* Reserve physical eraseblocks */
         if (vol->reserved_pebs > ubi->avail_pebs) {
@@ -301,10 +298,10 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
                 vol->used_bytes =
                         (long long)vol->used_ebs * vol->usable_leb_size;
         } else {
-                bytes = vol->used_bytes;
-                vol->last_eb_bytes = do_div(bytes, vol->usable_leb_size);
-                vol->used_ebs = bytes;
-                if (vol->last_eb_bytes)
+                vol->used_ebs = div_u64_rem(vol->used_bytes,
+                                            vol->usable_leb_size,
+                                            &vol->last_eb_bytes);
+                if (vol->last_eb_bytes != 0)
                         vol->used_ebs += 1;
                 else
                         vol->last_eb_bytes = vol->usable_leb_size;