uboot/drivers/mtd/ubi/build.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (c) International Business Machines Corp., 2006
   4 * Copyright (c) Nokia Corporation, 2007
   5 *
   6 * Author: Artem Bityutskiy (Битюцкий Артём),
   7 *         Frank Haverkamp
   8 */
   9
  10/*
  11 * This file includes UBI initialization and building of UBI devices.
  12 *
  13 * When UBI is initialized, it attaches all the MTD devices specified as the
  14 * module load parameters or the kernel boot parameters. If MTD devices were
  15 * specified, UBI does not attach any MTD device, but it is possible to do
  16 * later using the "UBI control device".
  17 */
  18
  19#ifndef __UBOOT__
  20#include <log.h>
  21#include <dm/devres.h>
  22#include <linux/module.h>
  23#include <linux/moduleparam.h>
  24#include <linux/stringify.h>
  25#include <linux/namei.h>
  26#include <linux/stat.h>
  27#include <linux/miscdevice.h>
  28#include <linux/log2.h>
  29#include <linux/kthread.h>
  30#include <linux/kernel.h>
  31#include <linux/slab.h>
  32#include <linux/major.h>
  33#else
  34#include <linux/bug.h>
  35#include <linux/log2.h>
  36#endif
  37#include <linux/err.h>
  38#include <ubi_uboot.h>
  39#include <linux/mtd/partitions.h>
  40
  41#include "ubi.h"
  42
  43/* Maximum length of the 'mtd=' parameter */
  44#define MTD_PARAM_LEN_MAX 64
  45
  46/* Maximum number of comma-separated items in the 'mtd=' parameter */
  47#define MTD_PARAM_MAX_COUNT 4
  48
  49/* Maximum value for the number of bad PEBs per 1024 PEBs */
  50#define MAX_MTD_UBI_BEB_LIMIT 768
  51
  52#ifdef CONFIG_MTD_UBI_MODULE
  53#define ubi_is_module() 1
  54#else
  55#define ubi_is_module() 0
  56#endif
  57
  58#if (CONFIG_SYS_MALLOC_LEN < (512 << 10))
  59#error Malloc area too small for UBI, increase CONFIG_SYS_MALLOC_LEN to >= 512k
  60#endif
  61
  62/**
  63 * struct mtd_dev_param - MTD device parameter description data structure.
  64 * @name: MTD character device node path, MTD device name, or MTD device number
  65 *        string
  66 * @vid_hdr_offs: VID header offset
  67 * @max_beb_per1024: maximum expected number of bad PEBs per 1024 PEBs
  68 */
  69struct mtd_dev_param {
  70        char name[MTD_PARAM_LEN_MAX];
  71        int ubi_num;
  72        int vid_hdr_offs;
  73        int max_beb_per1024;
  74};
  75
  76/* Numbers of elements set in the @mtd_dev_param array */
  77static int __initdata mtd_devs;
  78
  79/* MTD devices specification parameters */
  80static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
  81#ifndef __UBOOT__
  82#ifdef CONFIG_MTD_UBI_FASTMAP
  83/* UBI module parameter to enable fastmap automatically on non-fastmap images */
  84static bool fm_autoconvert;
  85static bool fm_debug;
  86#endif
  87#else
  88#ifdef CONFIG_MTD_UBI_FASTMAP
  89#if !defined(CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT)
  90#define CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT 0
  91#endif
  92static bool fm_autoconvert = CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT;
  93#if !defined(CONFIG_MTD_UBI_FM_DEBUG)
  94#define CONFIG_MTD_UBI_FM_DEBUG 0
  95#endif
  96static bool fm_debug = CONFIG_MTD_UBI_FM_DEBUG;
  97#endif
  98#endif
  99
 100/* Slab cache for wear-leveling entries */
 101struct kmem_cache *ubi_wl_entry_slab;
 102
 103#ifndef __UBOOT__
 104/* UBI control character device */
 105static struct miscdevice ubi_ctrl_cdev = {
 106        .minor = MISC_DYNAMIC_MINOR,
 107        .name = "ubi_ctrl",
 108        .fops = &ubi_ctrl_cdev_operations,
 109};
 110#endif
 111
 112/* All UBI devices in system */
 113#ifndef __UBOOT__
 114static struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
 115#else
 116struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
 117#endif
 118 
 119#ifndef __UBOOT__
 120/* Serializes UBI devices creations and removals */
 121DEFINE_MUTEX(ubi_devices_mutex);
 122
 123/* Protects @ubi_devices and @ubi->ref_count */
 124static DEFINE_SPINLOCK(ubi_devices_lock);
 125
 126/* "Show" method for files in '/<sysfs>/class/ubi/' */
 127static ssize_t ubi_version_show(struct class *class,
 128                                struct class_attribute *attr, char *buf)
 129{
 130        return sprintf(buf, "%d\n", UBI_VERSION);
 131}
 132
 133/* UBI version attribute ('/<sysfs>/class/ubi/version') */
 134static struct class_attribute ubi_class_attrs[] = {
 135        __ATTR(version, S_IRUGO, ubi_version_show, NULL),
 136        __ATTR_NULL
 137};
 138
 139/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
 140struct class ubi_class = {
 141        .name           = UBI_NAME_STR,
 142        .owner          = THIS_MODULE,
 143        .class_attrs    = ubi_class_attrs,
 144};
 145
 146static ssize_t dev_attribute_show(struct device *dev,
 147                                  struct device_attribute *attr, char *buf);
 148
 149/* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
 150static struct device_attribute dev_eraseblock_size =
 151        __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
 152static struct device_attribute dev_avail_eraseblocks =
 153        __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 154static struct device_attribute dev_total_eraseblocks =
 155        __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 156static struct device_attribute dev_volumes_count =
 157        __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
 158static struct device_attribute dev_max_ec =
 159        __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
 160static struct device_attribute dev_reserved_for_bad =
 161        __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
 162static struct device_attribute dev_bad_peb_count =
 163        __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
 164static struct device_attribute dev_max_vol_count =
 165        __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
 166static struct device_attribute dev_min_io_size =
 167        __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
 168static struct device_attribute dev_bgt_enabled =
 169        __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
 170static struct device_attribute dev_mtd_num =
 171        __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
 172#endif
 173
 174/**
 175 * ubi_volume_notify - send a volume change notification.
 176 * @ubi: UBI device description object
 177 * @vol: volume description object of the changed volume
 178 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 179 *
 180 * This is a helper function which notifies all subscribers about a volume
 181 * change event (creation, removal, re-sizing, re-naming, updating). Returns
 182 * zero in case of success and a negative error code in case of failure.
 183 */
 184int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
 185{
 186        int ret;
 187        struct ubi_notification nt;
 188
 189        ubi_do_get_device_info(ubi, &nt.di);
 190        ubi_do_get_volume_info(ubi, vol, &nt.vi);
 191
 192        switch (ntype) {
 193        case UBI_VOLUME_ADDED:
 194        case UBI_VOLUME_REMOVED:
 195        case UBI_VOLUME_RESIZED:
 196        case UBI_VOLUME_RENAMED:
 197                ret = ubi_update_fastmap(ubi);
 198                if (ret)
 199                        ubi_msg(ubi, "Unable to write a new fastmap: %i", ret);
 200        }
 201
 202        return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
 203}
 204
 205/**
 206 * ubi_notify_all - send a notification to all volumes.
 207 * @ubi: UBI device description object
 208 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 209 * @nb: the notifier to call
 210 *
 211 * This function walks all volumes of UBI device @ubi and sends the @ntype
 212 * notification for each volume. If @nb is %NULL, then all registered notifiers
 213 * are called, otherwise only the @nb notifier is called. Returns the number of
 214 * sent notifications.
 215 */
 216int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
 217{
 218        struct ubi_notification nt;
 219        int i, count = 0;
 220#ifndef __UBOOT__
 221        int ret;
 222#endif
 223
 224        ubi_do_get_device_info(ubi, &nt.di);
 225
 226        mutex_lock(&ubi->device_mutex);
 227        for (i = 0; i < ubi->vtbl_slots; i++) {
 228                /*
 229                 * Since the @ubi->device is locked, and we are not going to
 230                 * change @ubi->volumes, we do not have to lock
 231                 * @ubi->volumes_lock.
 232                 */
 233                if (!ubi->volumes[i])
 234                        continue;
 235
 236                ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
 237#ifndef __UBOOT__
 238                if (nb)
 239                        nb->notifier_call(nb, ntype, &nt);
 240                else
 241                        ret = blocking_notifier_call_chain(&ubi_notifiers, ntype,
 242                                                     &nt);
 243#endif
 244                count += 1;
 245        }
 246        mutex_unlock(&ubi->device_mutex);
 247
 248        return count;
 249}
 250
 251/**
 252 * ubi_enumerate_volumes - send "add" notification for all existing volumes.
 253 * @nb: the notifier to call
 254 *
 255 * This function walks all UBI devices and volumes and sends the
 256 * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
 257 * registered notifiers are called, otherwise only the @nb notifier is called.
 258 * Returns the number of sent notifications.
 259 */
 260int ubi_enumerate_volumes(struct notifier_block *nb)
 261{
 262        int i, count = 0;
 263
 264        /*
 265         * Since the @ubi_devices_mutex is locked, and we are not going to
 266         * change @ubi_devices, we do not have to lock @ubi_devices_lock.
 267         */
 268        for (i = 0; i < UBI_MAX_DEVICES; i++) {
 269                struct ubi_device *ubi = ubi_devices[i];
 270
 271                if (!ubi)
 272                        continue;
 273                count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
 274        }
 275
 276        return count;
 277}
 278
 279/**
 280 * ubi_get_device - get UBI device.
 281 * @ubi_num: UBI device number
 282 *
 283 * This function returns UBI device description object for UBI device number
 284 * @ubi_num, or %NULL if the device does not exist. This function increases the
 285 * device reference count to prevent removal of the device. In other words, the
 286 * device cannot be removed if its reference count is not zero.
 287 */
 288struct ubi_device *ubi_get_device(int ubi_num)
 289{
 290        struct ubi_device *ubi;
 291
 292        spin_lock(&ubi_devices_lock);
 293        ubi = ubi_devices[ubi_num];
 294        if (ubi) {
 295                ubi_assert(ubi->ref_count >= 0);
 296                ubi->ref_count += 1;
 297                get_device(&ubi->dev);
 298        }
 299        spin_unlock(&ubi_devices_lock);
 300
 301        return ubi;
 302}
 303
 304/**
 305 * ubi_put_device - drop an UBI device reference.
 306 * @ubi: UBI device description object
 307 */
 308void ubi_put_device(struct ubi_device *ubi)
 309{
 310        spin_lock(&ubi_devices_lock);
 311        ubi->ref_count -= 1;
 312        put_device(&ubi->dev);
 313        spin_unlock(&ubi_devices_lock);
 314}
 315
 316/**
 317 * ubi_get_by_major - get UBI device by character device major number.
 318 * @major: major number
 319 *
 320 * This function is similar to 'ubi_get_device()', but it searches the device
 321 * by its major number.
 322 */
 323struct ubi_device *ubi_get_by_major(int major)
 324{
 325        int i;
 326        struct ubi_device *ubi;
 327
 328        spin_lock(&ubi_devices_lock);
 329        for (i = 0; i < UBI_MAX_DEVICES; i++) {
 330                ubi = ubi_devices[i];
 331                if (ubi && MAJOR(ubi->cdev.dev) == major) {
 332                        ubi_assert(ubi->ref_count >= 0);
 333                        ubi->ref_count += 1;
 334                        get_device(&ubi->dev);
 335                        spin_unlock(&ubi_devices_lock);
 336                        return ubi;
 337                }
 338        }
 339        spin_unlock(&ubi_devices_lock);
 340
 341        return NULL;
 342}
 343
 344/**
 345 * ubi_major2num - get UBI device number by character device major number.
 346 * @major: major number
 347 *
 348 * This function searches UBI device number object by its major number. If UBI
 349 * device was not found, this function returns -ENODEV, otherwise the UBI device
 350 * number is returned.
 351 */
 352int ubi_major2num(int major)
 353{
 354        int i, ubi_num = -ENODEV;
 355
 356        spin_lock(&ubi_devices_lock);
 357        for (i = 0; i < UBI_MAX_DEVICES; i++) {
 358                struct ubi_device *ubi = ubi_devices[i];
 359
 360                if (ubi && MAJOR(ubi->cdev.dev) == major) {
 361                        ubi_num = ubi->ubi_num;
 362                        break;
 363                }
 364        }
 365        spin_unlock(&ubi_devices_lock);
 366
 367        return ubi_num;
 368}
 369
 370#ifndef __UBOOT__
 371/* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
 372static ssize_t dev_attribute_show(struct device *dev,
 373                                  struct device_attribute *attr, char *buf)
 374{
 375        ssize_t ret;
 376        struct ubi_device *ubi;
 377
 378        /*
 379         * The below code looks weird, but it actually makes sense. We get the
 380         * UBI device reference from the contained 'struct ubi_device'. But it
 381         * is unclear if the device was removed or not yet. Indeed, if the
 382         * device was removed before we increased its reference count,
 383         * 'ubi_get_device()' will return -ENODEV and we fail.
 384         *
 385         * Remember, 'struct ubi_device' is freed in the release function, so
 386         * we still can use 'ubi->ubi_num'.
 387         */
 388        ubi = container_of(dev, struct ubi_device, dev);
 389        ubi = ubi_get_device(ubi->ubi_num);
 390        if (!ubi)
 391                return -ENODEV;
 392
 393        if (attr == &dev_eraseblock_size)
 394                ret = sprintf(buf, "%d\n", ubi->leb_size);
 395        else if (attr == &dev_avail_eraseblocks)
 396                ret = sprintf(buf, "%d\n", ubi->avail_pebs);
 397        else if (attr == &dev_total_eraseblocks)
 398                ret = sprintf(buf, "%d\n", ubi->good_peb_count);
 399        else if (attr == &dev_volumes_count)
 400                ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
 401        else if (attr == &dev_max_ec)
 402                ret = sprintf(buf, "%d\n", ubi->max_ec);
 403        else if (attr == &dev_reserved_for_bad)
 404                ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
 405        else if (attr == &dev_bad_peb_count)
 406                ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
 407        else if (attr == &dev_max_vol_count)
 408                ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
 409        else if (attr == &dev_min_io_size)
 410                ret = sprintf(buf, "%d\n", ubi->min_io_size);
 411        else if (attr == &dev_bgt_enabled)
 412                ret = sprintf(buf, "%d\n", ubi->thread_enabled);
 413        else if (attr == &dev_mtd_num)
 414                ret = sprintf(buf, "%d\n", ubi->mtd->index);
 415        else
 416                ret = -EINVAL;
 417
 418        ubi_put_device(ubi);
 419        return ret;
 420}
 421
 422static struct attribute *ubi_dev_attrs[] = {
 423        &dev_eraseblock_size.attr,
 424        &dev_avail_eraseblocks.attr,
 425        &dev_total_eraseblocks.attr,
 426        &dev_volumes_count.attr,
 427        &dev_max_ec.attr,
 428        &dev_reserved_for_bad.attr,
 429        &dev_bad_peb_count.attr,
 430        &dev_max_vol_count.attr,
 431        &dev_min_io_size.attr,
 432        &dev_bgt_enabled.attr,
 433        &dev_mtd_num.attr,
 434        NULL
 435};
 436ATTRIBUTE_GROUPS(ubi_dev);
 437
 438static void dev_release(struct device *dev)
 439{
 440        struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
 441
 442        kfree(ubi);
 443}
 444
 445/**
 446 * ubi_sysfs_init - initialize sysfs for an UBI device.
 447 * @ubi: UBI device description object
 448 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
 449 *       taken
 450 *
 451 * This function returns zero in case of success and a negative error code in
 452 * case of failure.
 453 */
 454static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
 455{
 456        int err;
 457
 458        ubi->dev.release = dev_release;
 459        ubi->dev.devt = ubi->cdev.dev;
 460        ubi->dev.class = &ubi_class;
 461        ubi->dev.groups = ubi_dev_groups;
 462        dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
 463        err = device_register(&ubi->dev);
 464        if (err)
 465                return err;
 466
 467        *ref = 1;
 468        return 0;
 469}
 470
 471/**
 472 * ubi_sysfs_close - close sysfs for an UBI device.
 473 * @ubi: UBI device description object
 474 */
 475static void ubi_sysfs_close(struct ubi_device *ubi)
 476{
 477        device_unregister(&ubi->dev);
 478}
 479#endif
 480
 481/**
 482 * kill_volumes - destroy all user volumes.
 483 * @ubi: UBI device description object
 484 */
 485static void kill_volumes(struct ubi_device *ubi)
 486{
 487        int i;
 488
 489        for (i = 0; i < ubi->vtbl_slots; i++)
 490                if (ubi->volumes[i])
 491                        ubi_free_volume(ubi, ubi->volumes[i]);
 492}
 493
 494/**
 495 * uif_init - initialize user interfaces for an UBI device.
 496 * @ubi: UBI device description object
 497 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
 498 *       taken, otherwise set to %0
 499 *
 500 * This function initializes various user interfaces for an UBI device. If the
 501 * initialization fails at an early stage, this function frees all the
 502 * resources it allocated, returns an error, and @ref is set to %0. However,
 503 * if the initialization fails after the UBI device was registered in the
 504 * driver core subsystem, this function takes a reference to @ubi->dev, because
 505 * otherwise the release function ('dev_release()') would free whole @ubi
 506 * object. The @ref argument is set to %1 in this case. The caller has to put
 507 * this reference.
 508 *
 509 * This function returns zero in case of success and a negative error code in
 510 * case of failure.
 511 */
 512static int uif_init(struct ubi_device *ubi, int *ref)
 513{
 514        int i, err;
 515#ifndef __UBOOT__
 516        dev_t dev;
 517#endif
 518
 519        *ref = 0;
 520        sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
 521
 522        /*
 523         * Major numbers for the UBI character devices are allocated
 524         * dynamically. Major numbers of volume character devices are
 525         * equivalent to ones of the corresponding UBI character device. Minor
 526         * numbers of UBI character devices are 0, while minor numbers of
 527         * volume character devices start from 1. Thus, we allocate one major
 528         * number and ubi->vtbl_slots + 1 minor numbers.
 529         */
 530        err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
 531        if (err) {
 532                ubi_err(ubi, "cannot register UBI character devices");
 533                return err;
 534        }
 535
 536        ubi_assert(MINOR(dev) == 0);
 537        cdev_init(&ubi->cdev, &ubi_cdev_operations);
 538        dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
 539        ubi->cdev.owner = THIS_MODULE;
 540
 541        err = cdev_add(&ubi->cdev, dev, 1);
 542        if (err) {
 543                ubi_err(ubi, "cannot add character device");
 544                goto out_unreg;
 545        }
 546
 547        err = ubi_sysfs_init(ubi, ref);
 548        if (err)
 549                goto out_sysfs;
 550
 551        for (i = 0; i < ubi->vtbl_slots; i++)
 552                if (ubi->volumes[i]) {
 553                        err = ubi_add_volume(ubi, ubi->volumes[i]);
 554                        if (err) {
 555                                ubi_err(ubi, "cannot add volume %d", i);
 556                                goto out_volumes;
 557                        }
 558                }
 559
 560        return 0;
 561
 562out_volumes:
 563        kill_volumes(ubi);
 564out_sysfs:
 565        if (*ref)
 566                get_device(&ubi->dev);
 567        ubi_sysfs_close(ubi);
 568        cdev_del(&ubi->cdev);
 569out_unreg:
 570        unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 571        ubi_err(ubi, "cannot initialize UBI %s, error %d",
 572                ubi->ubi_name, err);
 573        return err;
 574}
 575
 576/**
 577 * uif_close - close user interfaces for an UBI device.
 578 * @ubi: UBI device description object
 579 *
 580 * Note, since this function un-registers UBI volume device objects (@vol->dev),
 581 * the memory allocated voe the volumes is freed as well (in the release
 582 * function).
 583 */
 584static void uif_close(struct ubi_device *ubi)
 585{
 586        kill_volumes(ubi);
 587        ubi_sysfs_close(ubi);
 588        cdev_del(&ubi->cdev);
 589        unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 590}
 591
 592/**
 593 * ubi_free_internal_volumes - free internal volumes.
 594 * @ubi: UBI device description object
 595 */
 596void ubi_free_internal_volumes(struct ubi_device *ubi)
 597{
 598        int i;
 599
 600        for (i = ubi->vtbl_slots;
 601             i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
 602                kfree(ubi->volumes[i]->eba_tbl);
 603                kfree(ubi->volumes[i]);
 604        }
 605}
 606
 607static int get_bad_peb_limit(const struct ubi_device *ubi, int max_beb_per1024)
 608{
 609        int limit, device_pebs;
 610        uint64_t device_size;
 611
 612        if (!max_beb_per1024)
 613                return 0;
 614
 615        /*
 616         * Here we are using size of the entire flash chip and
 617         * not just the MTD partition size because the maximum
 618         * number of bad eraseblocks is a percentage of the
 619         * whole device and bad eraseblocks are not fairly
 620         * distributed over the flash chip. So the worst case
 621         * is that all the bad eraseblocks of the chip are in
 622         * the MTD partition we are attaching (ubi->mtd).
 623         */
 624        device_size = mtd_get_device_size(ubi->mtd);
 625        device_pebs = mtd_div_by_eb(device_size, ubi->mtd);
 626        limit = mult_frac(device_pebs, max_beb_per1024, 1024);
 627
 628        /* Round it up */
 629        if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs)
 630                limit += 1;
 631
 632        return limit;
 633}
 634
 635/**
 636 * io_init - initialize I/O sub-system for a given UBI device.
 637 * @ubi: UBI device description object
 638 * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
 639 *
 640 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
 641 * assumed:
 642 *   o EC header is always at offset zero - this cannot be changed;
 643 *   o VID header starts just after the EC header at the closest address
 644 *     aligned to @io->hdrs_min_io_size;
 645 *   o data starts just after the VID header at the closest address aligned to
 646 *     @io->min_io_size
 647 *
 648 * This function returns zero in case of success and a negative error code in
 649 * case of failure.
 650 */
 651static int io_init(struct ubi_device *ubi, int max_beb_per1024)
 652{
 653        dbg_gen("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb));
 654        dbg_gen("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
 655
 656        if (ubi->mtd->numeraseregions != 0) {
 657                /*
 658                 * Some flashes have several erase regions. Different regions
 659                 * may have different eraseblock size and other
 660                 * characteristics. It looks like mostly multi-region flashes
 661                 * have one "main" region and one or more small regions to
 662                 * store boot loader code or boot parameters or whatever. I
 663                 * guess we should just pick the largest region. But this is
 664                 * not implemented.
 665                 */
 666                ubi_err(ubi, "multiple regions, not implemented");
 667                return -EINVAL;
 668        }
 669
 670        if (ubi->vid_hdr_offset < 0)
 671                return -EINVAL;
 672
 673        /*
 674         * Note, in this implementation we support MTD devices with 0x7FFFFFFF
 675         * physical eraseblocks maximum.
 676         */
 677
 678        ubi->peb_size   = ubi->mtd->erasesize;
 679        ubi->peb_count  = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
 680        ubi->flash_size = ubi->mtd->size;
 681
 682        if (mtd_can_have_bb(ubi->mtd)) {
 683                ubi->bad_allowed = 1;
 684                ubi->bad_peb_limit = get_bad_peb_limit(ubi, max_beb_per1024);
 685        }
 686
 687        if (ubi->mtd->type == MTD_NORFLASH) {
 688                ubi_assert(ubi->mtd->writesize == 1);
 689                ubi->nor_flash = 1;
 690        }
 691
 692        ubi->min_io_size = ubi->mtd->writesize;
 693        ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 694
 695        /*
 696         * Make sure minimal I/O unit is power of 2. Note, there is no
 697         * fundamental reason for this assumption. It is just an optimization
 698         * which allows us to avoid costly division operations.
 699         */
 700        if (!is_power_of_2(ubi->min_io_size)) {
 701                ubi_err(ubi, "min. I/O unit (%d) is not power of 2",
 702                        ubi->min_io_size);
 703                return -EINVAL;
 704        }
 705
 706        ubi_assert(ubi->hdrs_min_io_size > 0);
 707        ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
 708        ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
 709
 710        ubi->max_write_size = ubi->mtd->writebufsize;
 711        /*
 712         * Maximum write size has to be greater or equivalent to min. I/O
 713         * size, and be multiple of min. I/O size.
 714         */
 715        if (ubi->max_write_size < ubi->min_io_size ||
 716            ubi->max_write_size % ubi->min_io_size ||
 717            !is_power_of_2(ubi->max_write_size)) {
 718                ubi_err(ubi, "bad write buffer size %d for %d min. I/O unit",
 719                        ubi->max_write_size, ubi->min_io_size);
 720                return -EINVAL;
 721        }
 722
 723        /* Calculate default aligned sizes of EC and VID headers */
 724        ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
 725        ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
 726
 727        dbg_gen("min_io_size      %d", ubi->min_io_size);
 728        dbg_gen("max_write_size   %d", ubi->max_write_size);
 729        dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
 730        dbg_gen("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
 731        dbg_gen("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
 732
 733        if (ubi->vid_hdr_offset == 0)
 734                /* Default offset */
 735                ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
 736                                      ubi->ec_hdr_alsize;
 737        else {
 738                ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
 739                                                ~(ubi->hdrs_min_io_size - 1);
 740                ubi->vid_hdr_shift = ubi->vid_hdr_offset -
 741                                                ubi->vid_hdr_aloffset;
 742        }
 743
 744        /* Similar for the data offset */
 745        ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
 746        ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
 747
 748        dbg_gen("vid_hdr_offset   %d", ubi->vid_hdr_offset);
 749        dbg_gen("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
 750        dbg_gen("vid_hdr_shift    %d", ubi->vid_hdr_shift);
 751        dbg_gen("leb_start        %d", ubi->leb_start);
 752
 753        /* The shift must be aligned to 32-bit boundary */
 754        if (ubi->vid_hdr_shift % 4) {
 755                ubi_err(ubi, "unaligned VID header shift %d",
 756                        ubi->vid_hdr_shift);
 757                return -EINVAL;
 758        }
 759
 760        /* Check sanity */
 761        if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
 762            ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
 763            ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
 764            ubi->leb_start & (ubi->min_io_size - 1)) {
 765                ubi_err(ubi, "bad VID header (%d) or data offsets (%d)",
 766                        ubi->vid_hdr_offset, ubi->leb_start);
 767                return -EINVAL;
 768        }
 769
 770        /*
 771         * Set maximum amount of physical erroneous eraseblocks to be 10%.
 772         * Erroneous PEB are those which have read errors.
 773         */
 774        ubi->max_erroneous = ubi->peb_count / 10;
 775        if (ubi->max_erroneous < 16)
 776                ubi->max_erroneous = 16;
 777        dbg_gen("max_erroneous    %d", ubi->max_erroneous);
 778
 779        /*
 780         * It may happen that EC and VID headers are situated in one minimal
 781         * I/O unit. In this case we can only accept this UBI image in
 782         * read-only mode.
 783         */
 784        if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
 785                ubi_warn(ubi, "EC and VID headers are in the same minimal I/O unit, switch to read-only mode");
 786                ubi->ro_mode = 1;
 787        }
 788
 789        ubi->leb_size = ubi->peb_size - ubi->leb_start;
 790
 791        if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
 792                ubi_msg(ubi, "MTD device %d is write-protected, attach in read-only mode",
 793                        ubi->mtd->index);
 794                ubi->ro_mode = 1;
 795        }
 796
 797        /*
 798         * Note, ideally, we have to initialize @ubi->bad_peb_count here. But
 799         * unfortunately, MTD does not provide this information. We should loop
 800         * over all physical eraseblocks and invoke mtd->block_is_bad() for
 801         * each physical eraseblock. So, we leave @ubi->bad_peb_count
 802         * uninitialized so far.
 803         */
 804
 805        return 0;
 806}
 807
 808/**
 809 * autoresize - re-size the volume which has the "auto-resize" flag set.
 810 * @ubi: UBI device description object
 811 * @vol_id: ID of the volume to re-size
 812 *
 813 * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in
 814 * the volume table to the largest possible size. See comments in ubi-header.h
 815 * for more description of the flag. Returns zero in case of success and a
 816 * negative error code in case of failure.
 817 */
 818static int autoresize(struct ubi_device *ubi, int vol_id)
 819{
 820        struct ubi_volume_desc desc;
 821        struct ubi_volume *vol = ubi->volumes[vol_id];
 822        int err, old_reserved_pebs = vol->reserved_pebs;
 823
 824        if (ubi->ro_mode) {
 825                ubi_warn(ubi, "skip auto-resize because of R/O mode");
 826                return 0;
 827        }
 828
 829        /*
 830         * Clear the auto-resize flag in the volume in-memory copy of the
 831         * volume table, and 'ubi_resize_volume()' will propagate this change
 832         * to the flash.
 833         */
 834        ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
 835
 836        if (ubi->avail_pebs == 0) {
 837                struct ubi_vtbl_record vtbl_rec;
 838
 839                /*
 840                 * No available PEBs to re-size the volume, clear the flag on
 841                 * flash and exit.
 842                 */
 843                vtbl_rec = ubi->vtbl[vol_id];
 844                err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
 845                if (err)
 846                        ubi_err(ubi, "cannot clean auto-resize flag for volume %d",
 847                                vol_id);
 848        } else {
 849                desc.vol = vol;
 850                err = ubi_resize_volume(&desc,
 851                                        old_reserved_pebs + ubi->avail_pebs);
 852                if (err)
 853                        ubi_err(ubi, "cannot auto-resize volume %d",
 854                                vol_id);
 855        }
 856
 857        if (err)
 858                return err;
 859
 860        ubi_msg(ubi, "volume %d (\"%s\") re-sized from %d to %d LEBs",
 861                vol_id, vol->name, old_reserved_pebs, vol->reserved_pebs);
 862        return 0;
 863}
 864
 865/**
 866 * ubi_attach_mtd_dev - attach an MTD device.
 867 * @mtd: MTD device description object
 868 * @ubi_num: number to assign to the new UBI device
 869 * @vid_hdr_offset: VID header offset
 870 * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
 871 *
 872 * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
 873 * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
 874 * which case this function finds a vacant device number and assigns it
 875 * automatically. Returns the new UBI device number in case of success and a
 876 * negative error code in case of failure.
 877 *
 878 * Note, the invocations of this function has to be serialized by the
 879 * @ubi_devices_mutex.
 880 */
 881int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
 882                       int vid_hdr_offset, int max_beb_per1024)
 883{
 884        struct ubi_device *ubi;
 885        int i, err, ref = 0;
 886
 887        if (max_beb_per1024 < 0 || max_beb_per1024 > MAX_MTD_UBI_BEB_LIMIT)
 888                return -EINVAL;
 889
 890        if (!max_beb_per1024)
 891                max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT;
 892
 893        /*
 894         * Check if we already have the same MTD device attached.
 895         *
 896         * Note, this function assumes that UBI devices creations and deletions
 897         * are serialized, so it does not take the &ubi_devices_lock.
 898         */
 899        for (i = 0; i < UBI_MAX_DEVICES; i++) {
 900                ubi = ubi_devices[i];
 901                if (ubi && mtd->index == ubi->mtd->index) {
 902                        ubi_err(ubi, "mtd%d is already attached to ubi%d",
 903                                mtd->index, i);
 904                        return -EEXIST;
 905                }
 906        }
 907
 908        /*
 909         * Make sure this MTD device is not emulated on top of an UBI volume
 910         * already. Well, generally this recursion works fine, but there are
 911         * different problems like the UBI module takes a reference to itself
 912         * by attaching (and thus, opening) the emulated MTD device. This
 913         * results in inability to unload the module. And in general it makes
 914         * no sense to attach emulated MTD devices, so we prohibit this.
 915         */
 916        if (mtd->type == MTD_UBIVOLUME) {
 917                ubi_err(ubi, "refuse attaching mtd%d - it is already emulated on top of UBI",
 918                        mtd->index);
 919                return -EINVAL;
 920        }
 921
 922        if (ubi_num == UBI_DEV_NUM_AUTO) {
 923                /* Search for an empty slot in the @ubi_devices array */
 924                for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
 925                        if (!ubi_devices[ubi_num])
 926                                break;
 927                if (ubi_num == UBI_MAX_DEVICES) {
 928                        ubi_err(ubi, "only %d UBI devices may be created",
 929                                UBI_MAX_DEVICES);
 930                        return -ENFILE;
 931                }
 932        } else {
 933                if (ubi_num >= UBI_MAX_DEVICES)
 934                        return -EINVAL;
 935
 936                /* Make sure ubi_num is not busy */
 937                if (ubi_devices[ubi_num]) {
 938                        ubi_err(ubi, "already exists");
 939                        return -EEXIST;
 940                }
 941        }
 942
 943        ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
 944        if (!ubi)
 945                return -ENOMEM;
 946
 947        ubi->mtd = mtd;
 948        ubi->ubi_num = ubi_num;
 949        ubi->vid_hdr_offset = vid_hdr_offset;
 950        ubi->autoresize_vol_id = -1;
 951
 952#ifdef CONFIG_MTD_UBI_FASTMAP
 953        ubi->fm_pool.used = ubi->fm_pool.size = 0;
 954        ubi->fm_wl_pool.used = ubi->fm_wl_pool.size = 0;
 955
 956        /*
 957         * fm_pool.max_size is 5% of the total number of PEBs but it's also
 958         * between UBI_FM_MAX_POOL_SIZE and UBI_FM_MIN_POOL_SIZE.
 959         */
 960        ubi->fm_pool.max_size = min(((int)mtd_div_by_eb(ubi->mtd->size,
 961                ubi->mtd) / 100) * 5, UBI_FM_MAX_POOL_SIZE);
 962        ubi->fm_pool.max_size = max(ubi->fm_pool.max_size,
 963                UBI_FM_MIN_POOL_SIZE);
 964
 965        ubi->fm_wl_pool.max_size = ubi->fm_pool.max_size / 2;
 966        ubi->fm_disabled = !fm_autoconvert;
 967        if (fm_debug)
 968                ubi_enable_dbg_chk_fastmap(ubi);
 969
 970        if (!ubi->fm_disabled && (int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd)
 971            <= UBI_FM_MAX_START) {
 972                ubi_err(ubi, "More than %i PEBs are needed for fastmap, sorry.",
 973                        UBI_FM_MAX_START);
 974                ubi->fm_disabled = 1;
 975        }
 976
 977        ubi_msg(ubi, "default fastmap pool size: %d", ubi->fm_pool.max_size);
 978        ubi_msg(ubi, "default fastmap WL pool size: %d",
 979                ubi->fm_wl_pool.max_size);
 980#else
 981        ubi->fm_disabled = 1;
 982#endif
 983        mutex_init(&ubi->buf_mutex);
 984        mutex_init(&ubi->ckvol_mutex);
 985        mutex_init(&ubi->device_mutex);
 986        spin_lock_init(&ubi->volumes_lock);
 987        init_rwsem(&ubi->fm_protect);
 988        init_rwsem(&ubi->fm_eba_sem);
 989
 990        ubi_msg(ubi, "attaching mtd%d", mtd->index);
 991
 992        err = io_init(ubi, max_beb_per1024);
 993        if (err)
 994                goto out_free;
 995
 996        err = -ENOMEM;
 997        ubi->peb_buf = vmalloc(ubi->peb_size);
 998        if (!ubi->peb_buf)
 999                goto out_free;
1000
1001#ifdef CONFIG_MTD_UBI_FASTMAP
1002        ubi->fm_size = ubi_calc_fm_size(ubi);
1003        ubi->fm_buf = vzalloc(ubi->fm_size);
1004        if (!ubi->fm_buf)
1005                goto out_free;
1006#endif
1007        err = ubi_attach(ubi, 0);
1008        if (err) {
1009                ubi_err(ubi, "failed to attach mtd%d, error %d",
1010                        mtd->index, err);
1011                goto out_free;
1012        }
1013
1014        if (ubi->autoresize_vol_id != -1) {
1015                err = autoresize(ubi, ubi->autoresize_vol_id);
1016                if (err)
1017                        goto out_detach;
1018        }
1019
1020        err = uif_init(ubi, &ref);
1021        if (err)
1022                goto out_detach;
1023
1024        err = ubi_debugfs_init_dev(ubi);
1025        if (err)
1026                goto out_uif;
1027
1028        ubi->bgt_thread = kthread_create(ubi_thread, ubi, "%s", ubi->bgt_name);
1029        if (IS_ERR(ubi->bgt_thread)) {
1030                err = PTR_ERR(ubi->bgt_thread);
1031                ubi_err(ubi, "cannot spawn \"%s\", error %d",
1032                        ubi->bgt_name, err);
1033                goto out_debugfs;
1034        }
1035
1036        ubi_msg(ubi, "attached mtd%d (name \"%s\", size %llu MiB)",
1037                mtd->index, mtd->name, ubi->flash_size >> 20);
1038        ubi_msg(ubi, "PEB size: %d bytes (%d KiB), LEB size: %d bytes",
1039                ubi->peb_size, ubi->peb_size >> 10, ubi->leb_size);
1040        ubi_msg(ubi, "min./max. I/O unit sizes: %d/%d, sub-page size %d",
1041                ubi->min_io_size, ubi->max_write_size, ubi->hdrs_min_io_size);
1042        ubi_msg(ubi, "VID header offset: %d (aligned %d), data offset: %d",
1043                ubi->vid_hdr_offset, ubi->vid_hdr_aloffset, ubi->leb_start);
1044        ubi_msg(ubi, "good PEBs: %d, bad PEBs: %d, corrupted PEBs: %d",
1045                ubi->good_peb_count, ubi->bad_peb_count, ubi->corr_peb_count);
1046        ubi_msg(ubi, "user volume: %d, internal volumes: %d, max. volumes count: %d",
1047                ubi->vol_count - UBI_INT_VOL_COUNT, UBI_INT_VOL_COUNT,
1048                ubi->vtbl_slots);
1049        ubi_msg(ubi, "max/mean erase counter: %d/%d, WL threshold: %d, image sequence number: %u",
1050                ubi->max_ec, ubi->mean_ec, CONFIG_MTD_UBI_WL_THRESHOLD,
1051                ubi->image_seq);
1052        ubi_msg(ubi, "available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d",
1053                ubi->avail_pebs, ubi->rsvd_pebs, ubi->beb_rsvd_pebs);
1054
1055        /*
1056         * The below lock makes sure we do not race with 'ubi_thread()' which
1057         * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
1058         */
1059        spin_lock(&ubi->wl_lock);
1060        ubi->thread_enabled = 1;
1061#ifndef __UBOOT__
1062        wake_up_process(ubi->bgt_thread);
1063#else
1064        ubi_do_worker(ubi);
1065#endif
1066
1067        spin_unlock(&ubi->wl_lock);
1068
1069        ubi_devices[ubi_num] = ubi;
1070        ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
1071        return ubi_num;
1072
1073out_debugfs:
1074        ubi_debugfs_exit_dev(ubi);
1075out_uif:
1076        get_device(&ubi->dev);
1077        ubi_assert(ref);
1078        uif_close(ubi);
1079out_detach:
1080        ubi_wl_close(ubi);
1081        ubi_free_internal_volumes(ubi);
1082        vfree(ubi->vtbl);
1083out_free:
1084        vfree(ubi->peb_buf);
1085        vfree(ubi->fm_buf);
1086        if (ref)
1087                put_device(&ubi->dev);
1088        else
1089                kfree(ubi);
1090        return err;
1091}
1092
1093/**
1094 * ubi_detach_mtd_dev - detach an MTD device.
1095 * @ubi_num: UBI device number to detach from
1096 * @anyway: detach MTD even if device reference count is not zero
1097 *
1098 * This function destroys an UBI device number @ubi_num and detaches the
1099 * underlying MTD device. Returns zero in case of success and %-EBUSY if the
1100 * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
1101 * exist.
1102 *
1103 * Note, the invocations of this function has to be serialized by the
1104 * @ubi_devices_mutex.
1105 */
1106int ubi_detach_mtd_dev(int ubi_num, int anyway)
1107{
1108        struct ubi_device *ubi;
1109
1110        if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
1111                return -EINVAL;
1112
1113        ubi = ubi_get_device(ubi_num);
1114        if (!ubi)
1115                return -EINVAL;
1116
1117        spin_lock(&ubi_devices_lock);
1118        put_device(&ubi->dev);
1119        ubi->ref_count -= 1;
1120        if (ubi->ref_count) {
1121                if (!anyway) {
1122                        spin_unlock(&ubi_devices_lock);
1123                        return -EBUSY;
1124                }
1125                /* This may only happen if there is a bug */
1126                ubi_err(ubi, "%s reference count %d, destroy anyway",
1127                        ubi->ubi_name, ubi->ref_count);
1128        }
1129        ubi_devices[ubi_num] = NULL;
1130        spin_unlock(&ubi_devices_lock);
1131
1132        ubi_assert(ubi_num == ubi->ubi_num);
1133        ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
1134        ubi_msg(ubi, "detaching mtd%d", ubi->mtd->index);
1135#ifdef CONFIG_MTD_UBI_FASTMAP
1136        /* If we don't write a new fastmap at detach time we lose all
1137         * EC updates that have been made since the last written fastmap.
1138         * In case of fastmap debugging we omit the update to simulate an
1139         * unclean shutdown. */
1140        if (!ubi_dbg_chk_fastmap(ubi))
1141                ubi_update_fastmap(ubi);
1142#endif
1143        /*
1144         * Before freeing anything, we have to stop the background thread to
1145         * prevent it from doing anything on this device while we are freeing.
1146         */
1147        if (ubi->bgt_thread)
1148                kthread_stop(ubi->bgt_thread);
1149
1150        /*
1151         * Get a reference to the device in order to prevent 'dev_release()'
1152         * from freeing the @ubi object.
1153         */
1154        get_device(&ubi->dev);
1155
1156        ubi_debugfs_exit_dev(ubi);
1157        uif_close(ubi);
1158
1159        ubi_wl_close(ubi);
1160        ubi_free_internal_volumes(ubi);
1161        vfree(ubi->vtbl);
1162        put_mtd_device(ubi->mtd);
1163        vfree(ubi->peb_buf);
1164        vfree(ubi->fm_buf);
1165        ubi_msg(ubi, "mtd%d is detached", ubi->mtd->index);
1166        put_device(&ubi->dev);
1167        return 0;
1168}
1169
1170#ifndef __UBOOT__
1171/**
1172 * open_mtd_by_chdev - open an MTD device by its character device node path.
1173 * @mtd_dev: MTD character device node path
1174 *
1175 * This helper function opens an MTD device by its character node device path.
1176 * Returns MTD device description object in case of success and a negative
1177 * error code in case of failure.
1178 */
1179static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
1180{
1181        int err, major, minor, mode;
1182        struct path path;
1183
1184        /* Probably this is an MTD character device node path */
1185        err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
1186        if (err)
1187                return ERR_PTR(err);
1188
1189        /* MTD device number is defined by the major / minor numbers */
1190        major = imajor(d_backing_inode(path.dentry));
1191        minor = iminor(d_backing_inode(path.dentry));
1192        mode = d_backing_inode(path.dentry)->i_mode;
1193        path_put(&path);
1194        if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
1195                return ERR_PTR(-EINVAL);
1196
1197        if (minor & 1)
1198                /*
1199                 * Just do not think the "/dev/mtdrX" devices support is need,
1200                 * so do not support them to avoid doing extra work.
1201                 */
1202                return ERR_PTR(-EINVAL);
1203
1204        return get_mtd_device(NULL, minor / 2);
1205}
1206#endif
1207
1208/**
1209 * open_mtd_device - open MTD device by name, character device path, or number.
1210 * @mtd_dev: name, character device node path, or MTD device device number
1211 *
1212 * This function tries to open and MTD device described by @mtd_dev string,
1213 * which is first treated as ASCII MTD device number, and if it is not true, it
1214 * is treated as MTD device name, and if that is also not true, it is treated
1215 * as MTD character device node path. Returns MTD device description object in
1216 * case of success and a negative error code in case of failure.
1217 */
1218static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
1219{
1220        struct mtd_info *mtd;
1221        int mtd_num;
1222        char *endp;
1223
1224        mtd_num = simple_strtoul(mtd_dev, &endp, 0);
1225        if (*endp != '\0' || mtd_dev == endp) {
1226                /*
1227                 * This does not look like an ASCII integer, probably this is
1228                 * MTD device name.
1229                 */
1230                mtd = get_mtd_device_nm(mtd_dev);
1231#ifndef __UBOOT__
1232                if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV)
1233                        /* Probably this is an MTD character device node path */
1234                        mtd = open_mtd_by_chdev(mtd_dev);
1235#endif
1236        } else
1237                mtd = get_mtd_device(NULL, mtd_num);
1238
1239        return mtd;
1240}
1241
1242#ifndef __UBOOT__
1243static int __init ubi_init(void)
1244#else
1245int ubi_init(void)
1246#endif
1247{
1248        int err, i, k;
1249
1250        /* Ensure that EC and VID headers have correct size */
1251        BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
1252        BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
1253
1254        if (mtd_devs > UBI_MAX_DEVICES) {
1255                pr_err("UBI error: too many MTD devices, maximum is %d\n",
1256                       UBI_MAX_DEVICES);
1257                return -EINVAL;
1258        }
1259
1260        /* Create base sysfs directory and sysfs files */
1261        err = class_register(&ubi_class);
1262        if (err < 0)
1263                return err;
1264
1265        err = misc_register(&ubi_ctrl_cdev);
1266        if (err) {
1267                pr_err("UBI error: cannot register device\n");
1268                goto out;
1269        }
1270
1271        ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
1272                                              sizeof(struct ubi_wl_entry),
1273                                              0, 0, NULL);
1274        if (!ubi_wl_entry_slab) {
1275                err = -ENOMEM;
1276                goto out_dev_unreg;
1277        }
1278
1279        err = ubi_debugfs_init();
1280        if (err)
1281                goto out_slab;
1282
1283
1284        /* Attach MTD devices */
1285        for (i = 0; i < mtd_devs; i++) {
1286                struct mtd_dev_param *p = &mtd_dev_param[i];
1287                struct mtd_info *mtd;
1288
1289                cond_resched();
1290
1291                mtd = open_mtd_device(p->name);
1292                if (IS_ERR(mtd)) {
1293                        err = PTR_ERR(mtd);
1294                        pr_err("UBI error: cannot open mtd %s, error %d\n",
1295                               p->name, err);
1296                        /* See comment below re-ubi_is_module(). */
1297                        if (ubi_is_module())
1298                                goto out_detach;
1299                        continue;
1300                }
1301
1302                mutex_lock(&ubi_devices_mutex);
1303                err = ubi_attach_mtd_dev(mtd, p->ubi_num,
1304                                         p->vid_hdr_offs, p->max_beb_per1024);
1305                mutex_unlock(&ubi_devices_mutex);
1306                if (err < 0) {
1307                        pr_err("UBI error: cannot attach mtd%d\n",
1308                               mtd->index);
1309                        put_mtd_device(mtd);
1310
1311                        /*
1312                         * Originally UBI stopped initializing on any error.
1313                         * However, later on it was found out that this
1314                         * behavior is not very good when UBI is compiled into
1315                         * the kernel and the MTD devices to attach are passed
1316                         * through the command line. Indeed, UBI failure
1317                         * stopped whole boot sequence.
1318                         *
1319                         * To fix this, we changed the behavior for the
1320                         * non-module case, but preserved the old behavior for
1321                         * the module case, just for compatibility. This is a
1322                         * little inconsistent, though.
1323                         */
1324                        if (ubi_is_module())
1325                                goto out_detach;
1326                }
1327        }
1328
1329        err = ubiblock_init();
1330        if (err) {
1331                pr_err("UBI error: block: cannot initialize, error %d\n", err);
1332
1333                /* See comment above re-ubi_is_module(). */
1334                if (ubi_is_module())
1335                        goto out_detach;
1336        }
1337
1338        return 0;
1339
1340out_detach:
1341        for (k = 0; k < i; k++)
1342                if (ubi_devices[k]) {
1343                        mutex_lock(&ubi_devices_mutex);
1344                        ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
1345                        mutex_unlock(&ubi_devices_mutex);
1346                }
1347        ubi_debugfs_exit();
1348out_slab:
1349        kmem_cache_destroy(ubi_wl_entry_slab);
1350out_dev_unreg:
1351        misc_deregister(&ubi_ctrl_cdev);
1352out:
1353#ifdef __UBOOT__
1354        /* Reset any globals that the driver depends on being zeroed */
1355        mtd_devs = 0;
1356#endif
1357        class_unregister(&ubi_class);
1358        pr_err("UBI error: cannot initialize UBI, error %d\n", err);
1359        return err;
1360}
1361late_initcall(ubi_init);
1362
1363#ifndef __UBOOT__
1364static void __exit ubi_exit(void)
1365#else
1366void ubi_exit(void)
1367#endif
1368{
1369        int i;
1370
1371        ubiblock_exit();
1372
1373        for (i = 0; i < UBI_MAX_DEVICES; i++)
1374                if (ubi_devices[i]) {
1375                        mutex_lock(&ubi_devices_mutex);
1376                        ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
1377                        mutex_unlock(&ubi_devices_mutex);
1378                }
1379        ubi_debugfs_exit();
1380        kmem_cache_destroy(ubi_wl_entry_slab);
1381        misc_deregister(&ubi_ctrl_cdev);
1382        class_unregister(&ubi_class);
1383#ifdef __UBOOT__
1384        /* Reset any globals that the driver depends on being zeroed */
1385        mtd_devs = 0;
1386#endif
1387}
1388module_exit(ubi_exit);
1389
1390/**
1391 * bytes_str_to_int - convert a number of bytes string into an integer.
1392 * @str: the string to convert
1393 *
1394 * This function returns positive resulting integer in case of success and a
1395 * negative error code in case of failure.
1396 */
1397static int __init bytes_str_to_int(const char *str)
1398{
1399        char *endp;
1400        unsigned long result;
1401
1402        result = simple_strtoul(str, &endp, 0);
1403        if (str == endp || result >= INT_MAX) {
1404                pr_err("UBI error: incorrect bytes count: \"%s\"\n", str);
1405                return -EINVAL;
1406        }
1407
1408        switch (*endp) {
1409        case 'G':
1410                result *= 1024;
1411        case 'M':
1412                result *= 1024;
1413        case 'K':
1414                result *= 1024;
1415                if (endp[1] == 'i' && endp[2] == 'B')
1416                        endp += 2;
1417        case '\0':
1418                break;
1419        default:
1420                pr_err("UBI error: incorrect bytes count: \"%s\"\n", str);
1421                return -EINVAL;
1422        }
1423
1424        return result;
1425}
1426
1427int kstrtoint(const char *s, unsigned int base, int *res)
1428{
1429        unsigned long long tmp;
1430
1431        tmp = simple_strtoull(s, NULL, base);
1432        if (tmp != (unsigned long long)(int)tmp)
1433                return -ERANGE;
1434
1435        return (int)tmp;
1436}
1437
1438/**
1439 * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
1440 * @val: the parameter value to parse
1441 * @kp: not used
1442 *
1443 * This function returns zero in case of success and a negative error code in
1444 * case of error.
1445 */
1446#ifndef __UBOOT__
1447static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
1448#else
1449int ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
1450#endif
1451{
1452        int i, len;
1453        struct mtd_dev_param *p;
1454        char buf[MTD_PARAM_LEN_MAX];
1455        char *pbuf = &buf[0];
1456        char *tokens[MTD_PARAM_MAX_COUNT], *token;
1457
1458        if (!val)
1459                return -EINVAL;
1460
1461        if (mtd_devs == UBI_MAX_DEVICES) {
1462                pr_err("UBI error: too many parameters, max. is %d\n",
1463                       UBI_MAX_DEVICES);
1464                return -EINVAL;
1465        }
1466
1467        len = strnlen(val, MTD_PARAM_LEN_MAX);
1468        if (len == MTD_PARAM_LEN_MAX) {
1469                pr_err("UBI error: parameter \"%s\" is too long, max. is %d\n",
1470                       val, MTD_PARAM_LEN_MAX);
1471                return -EINVAL;
1472        }
1473
1474        if (len == 0) {
1475                pr_warn("UBI warning: empty 'mtd=' parameter - ignored\n");
1476                return 0;
1477        }
1478
1479        strcpy(buf, val);
1480
1481        /* Get rid of the final newline */
1482        if (buf[len - 1] == '\n')
1483                buf[len - 1] = '\0';
1484
1485        for (i = 0; i < MTD_PARAM_MAX_COUNT; i++)
1486                tokens[i] = strsep(&pbuf, ",");
1487
1488        if (pbuf) {
1489                pr_err("UBI error: too many arguments at \"%s\"\n", val);
1490                return -EINVAL;
1491        }
1492
1493        p = &mtd_dev_param[mtd_devs];
1494        strcpy(&p->name[0], tokens[0]);
1495
1496        token = tokens[1];
1497        if (token) {
1498                p->vid_hdr_offs = bytes_str_to_int(token);
1499
1500                if (p->vid_hdr_offs < 0)
1501                        return p->vid_hdr_offs;
1502        }
1503
1504        token = tokens[2];
1505        if (token) {
1506                int err = kstrtoint(token, 10, &p->max_beb_per1024);
1507
1508                if (err) {
1509                        pr_err("UBI error: bad value for max_beb_per1024 parameter: %s",
1510                               token);
1511                        return -EINVAL;
1512                }
1513        }
1514
1515        token = tokens[3];
1516        if (token) {
1517                int err = kstrtoint(token, 10, &p->ubi_num);
1518
1519                if (err) {
1520                        pr_err("UBI error: bad value for ubi_num parameter: %s",
1521                               token);
1522                        return -EINVAL;
1523                }
1524        } else
1525                p->ubi_num = UBI_DEV_NUM_AUTO;
1526
1527        mtd_devs += 1;
1528        return 0;
1529}
1530
1531module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
1532MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num]]].\n"
1533                      "Multiple \"mtd\" parameters may be specified.\n"
1534                      "MTD devices may be specified by their number, name, or path to the MTD character device node.\n"
1535                      "Optional \"vid_hdr_offs\" parameter specifies UBI VID header position to be used by UBI. (default value if 0)\n"
1536                      "Optional \"max_beb_per1024\" parameter specifies the maximum expected bad eraseblock per 1024 eraseblocks. (default value ("
1537                      __stringify(CONFIG_MTD_UBI_BEB_LIMIT) ") if 0)\n"
1538                      "Optional \"ubi_num\" parameter specifies UBI device number which have to be assigned to the newly created UBI device (assigned automatically by default)\n"
1539                      "\n"
1540                      "Example 1: mtd=/dev/mtd0 - attach MTD device /dev/mtd0.\n"
1541                      "Example 2: mtd=content,1984 mtd=4 - attach MTD device with name \"content\" using VID header offset 1984, and MTD device number 4 with default VID header offset.\n"
1542                      "Example 3: mtd=/dev/mtd1,0,25 - attach MTD device /dev/mtd1 using default VID header offset and reserve 25*nand_size_in_blocks/1024 erase blocks for bad block handling.\n"
1543                      "Example 4: mtd=/dev/mtd1,0,0,5 - attach MTD device /dev/mtd1 to UBI 5 and using default values for the other fields.\n"
1544                      "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device).");
1545#ifdef CONFIG_MTD_UBI_FASTMAP
1546module_param(fm_autoconvert, bool, 0644);
1547MODULE_PARM_DESC(fm_autoconvert, "Set this parameter to enable fastmap automatically on images without a fastmap.");
1548module_param(fm_debug, bool, 0);
1549MODULE_PARM_DESC(fm_debug, "Set this parameter to enable fastmap debugging by default. Warning, this will make fastmap slow!");
1550#endif
1551MODULE_VERSION(__stringify(UBI_VERSION));
1552MODULE_DESCRIPTION("UBI - Unsorted Block Images");
1553MODULE_AUTHOR("Artem Bityutskiy");
1554MODULE_LICENSE("GPL");
1555