int err;
 
        ubi->dev.release = dev_release;
-       ubi->dev.devt = MKDEV(ubi->major, 0);
+       ubi->dev.devt = ubi->cdev.dev;
        ubi->dev.class = ubi_class;
        sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
        err = device_register(&ubi->dev);
                return err;
        }
 
+       ubi_assert(MINOR(dev) == 0);
        cdev_init(&ubi->cdev, &ubi_cdev_operations);
-       ubi->major = MAJOR(dev);
-       dbg_msg("%s major is %u", ubi->ubi_name, ubi->major);
+       dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev));
        ubi->cdev.owner = THIS_MODULE;
 
-       dev = MKDEV(ubi->major, 0);
        err = cdev_add(&ubi->cdev, dev, 1);
        if (err) {
                ubi_err("cannot add character device %s", ubi->ubi_name);
 out_cdev:
        cdev_del(&ubi->cdev);
 out_unreg:
-       unregister_chrdev_region(MKDEV(ubi->major, 0),
-                                ubi->vtbl_slots + 1);
+       unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
        return err;
 }
 
        kill_volumes(ubi);
        ubi_sysfs_close(ubi);
        cdev_del(&ubi->cdev);
-       unregister_chrdev_region(MKDEV(ubi->major, 0), ubi->vtbl_slots + 1);
+       unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 }
 
 /**
 
        int i;
 
        for (i = 0; i < ubi_devices_cnt; i++)
-               if (ubi_devices[i] && ubi_devices[i]->major == major)
+               if (ubi_devices[i] && MAJOR(ubi_devices[i]->cdev.dev) == major)
                        return ubi_devices[i];
        BUG();
        return NULL;
 
        di->leb_size = ubi->leb_size;
        di->min_io_size = ubi->min_io_size;
        di->ro_mode = ubi->ro_mode;
-       di->cdev = MKDEV(ubi->major, 0);
+       di->cdev = ubi->cdev.dev;
        return 0;
 }
 EXPORT_SYMBOL_GPL(ubi_get_device_info);
        vi->usable_leb_size = vol->usable_leb_size;
        vi->name_len = vol->name_len;
        vi->name = vol->name;
-       vi->cdev = MKDEV(ubi->major, vi->vol_id + 1);
+       vi->cdev = vol->cdev.dev;
 }
 EXPORT_SYMBOL_GPL(ubi_get_volume_info);
 
 
  * @cdev: character device object to create character device
  * @ubi_num: UBI device number
  * @ubi_name: UBI device name
- * @major: character device major number
  * @vol_count: number of volumes in this UBI device
  * @volumes: volumes of this UBI device
  * @volumes_lock: protects @volumes, @rsvd_pebs, @avail_pebs, beb_rsvd_pebs,
        struct device dev;
        int ubi_num;
        char ubi_name[sizeof(UBI_NAME_STR)+5];
-       int major;
        int vol_count;
        struct ubi_volume *volumes[UBI_MAX_VOLUMES+UBI_INT_VOL_COUNT];
        spinlock_t volumes_lock;
 
        struct ubi_volume *vol;
        struct ubi_vtbl_record vtbl_rec;
        uint64_t bytes;
+       dev_t dev;
 
        if (ubi->ro_mode)
                return -EROFS;
        /* Register character device for the volume */
        cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
        vol->cdev.owner = THIS_MODULE;
-       err = cdev_add(&vol->cdev, MKDEV(ubi->major, vol_id + 1), 1);
+       dev = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
+       err = cdev_add(&vol->cdev, dev, 1);
        if (err) {
                ubi_err("cannot add character device for volume %d", vol_id);
                goto out_mapping;
 
        vol->dev.release = vol_release;
        vol->dev.parent = &ubi->dev;
-       vol->dev.devt = MKDEV(ubi->major, vol->vol_id + 1);
+       vol->dev.devt = dev;
        vol->dev.class = ubi_class;
        sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);
 int ubi_add_volume(struct ubi_device *ubi, int vol_id)
 {
        int err;
+       dev_t dev;
        struct ubi_volume *vol = ubi->volumes[vol_id];
 
        dbg_msg("add volume %d", vol_id);
        /* Register character device for the volume */
        cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
        vol->cdev.owner = THIS_MODULE;
-       err = cdev_add(&vol->cdev, MKDEV(ubi->major, vol->vol_id + 1), 1);
+       dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
+       err = cdev_add(&vol->cdev, dev, 1);
        if (err) {
                ubi_err("cannot add character device for volume %d", vol_id);
                return err;
 
        vol->dev.release = vol_release;
        vol->dev.parent = &ubi->dev;
-       vol->dev.devt = MKDEV(ubi->major, vol->vol_id + 1);
+       vol->dev.devt = dev;
        vol->dev.class = ubi_class;
        sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);