Merge branch 'linux-next' of git://git.infradead.org/ubi-2.6

* 'linux-next' of git://git.infradead.org/ubi-2.6:
  UBI: allow direct user-space I/O
  UBI: fix resource de-allocation
  UBI: remove unused variable
  UBI: use nicer 64-bit math
  UBI: add ioctl compatibility
  UBI: constify file operations
  UBI: allow all ioctls
  UBI: remove unnecessry header inclusion
  UBI: improve ioctl commentaries
  UBI: add ioctl for is_mapped operation
  UBI: add ioctl for unmap operation
  UBI: add ioctl for map operation

8 files changed, 174 insertions, 109 deletions

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;