drivers/mtd/ubi/build.c

   1 /*
   2  * Copyright (c) International Business Machines Corp., 2006
   3  * Copyright (c) Nokia Corporation, 2007
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  13  * the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  * Author: Artem Bityutskiy (Битюцкий Артём),
  20  *         Frank Haverkamp
  21  */
  22
  23 /*
  24  * This file includes UBI initialization and building of UBI devices. At the
  25  * moment UBI devices may only be added while UBI is initialized, but dynamic
  26  * device add/remove functionality is planned. Also, at the moment we only
  27  * attach UBI devices by scanning, which will become a bottleneck when flashes
  28  * reach certain large size. Then one may improve UBI and add other methods.
  29  */
  30
  31 #include <linux/err.h>
  32 #include <linux/module.h>
  33 #include <linux/moduleparam.h>
  34 #include <linux/stringify.h>
  35 #include <linux/stat.h>
  36 #include "ubi.h"
  37
  38 /* Maximum length of the 'mtd=' parameter */
  39 #define MTD_PARAM_LEN_MAX 64
  40
  41 /**
  42  * struct mtd_dev_param - MTD device parameter description data structure.
  43  * @name: MTD device name or number string
  44  * @vid_hdr_offs: VID header offset
  45  * @data_offs: data offset
  46  */
  47 struct mtd_dev_param
  48 {
  49         char name[MTD_PARAM_LEN_MAX];
  50         int vid_hdr_offs;
  51         int data_offs;
  52 };
  53
  54 /* Numbers of elements set in the @mtd_dev_param array */
  55 static int mtd_devs = 0;
  56
  57 /* MTD devices specification parameters */
  58 static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
  59
  60 /* Number of UBI devices in system */
  61 int ubi_devices_cnt;
  62
  63 /* All UBI devices in system */
  64 struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
  65
  66 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
  67 struct class *ubi_class;
  68
  69 /* "Show" method for files in '/<sysfs>/class/ubi/' */
  70 static ssize_t ubi_version_show(struct class *class, char *buf)
  71 {
  72         return sprintf(buf, "%d\n", UBI_VERSION);
  73 }
  74
  75 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
  76 static struct class_attribute ubi_version =
  77         __ATTR(version, S_IRUGO, ubi_version_show, NULL);
  78
  79 static ssize_t dev_attribute_show(struct device *dev,
  80                                   struct device_attribute *attr, char *buf);
  81
  82 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
  83 static struct device_attribute dev_eraseblock_size =
  84         __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
  85 static struct device_attribute dev_avail_eraseblocks =
  86         __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
  87 static struct device_attribute dev_total_eraseblocks =
  88         __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
  89 static struct device_attribute dev_volumes_count =
  90         __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
  91 static struct device_attribute dev_max_ec =
  92         __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
  93 static struct device_attribute dev_reserved_for_bad =
  94         __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
  95 static struct device_attribute dev_bad_peb_count =
  96         __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
  97 static struct device_attribute dev_max_vol_count =
  98         __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
  99 static struct device_attribute dev_min_io_size =
 100         __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
 101 static struct device_attribute dev_bgt_enabled =
 102         __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
 103
 104 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
 105 static ssize_t dev_attribute_show(struct device *dev,
 106                                   struct device_attribute *attr, char *buf)
 107 {
 108         const struct ubi_device *ubi;
 109
 110         ubi = container_of(dev, struct ubi_device, dev);
 111         if (attr == &dev_eraseblock_size)
 112                 return sprintf(buf, "%d\n", ubi->leb_size);
 113         else if (attr == &dev_avail_eraseblocks)
 114                 return sprintf(buf, "%d\n", ubi->avail_pebs);
 115         else if (attr == &dev_total_eraseblocks)
 116                 return sprintf(buf, "%d\n", ubi->good_peb_count);
 117         else if (attr == &dev_volumes_count)
 118                 return sprintf(buf, "%d\n", ubi->vol_count);
 119         else if (attr == &dev_max_ec)
 120                 return sprintf(buf, "%d\n", ubi->max_ec);
 121         else if (attr == &dev_reserved_for_bad)
 122                 return sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
 123         else if (attr == &dev_bad_peb_count)
 124                 return sprintf(buf, "%d\n", ubi->bad_peb_count);
 125         else if (attr == &dev_max_vol_count)
 126                 return sprintf(buf, "%d\n", ubi->vtbl_slots);
 127         else if (attr == &dev_min_io_size)
 128                 return sprintf(buf, "%d\n", ubi->min_io_size);
 129         else if (attr == &dev_bgt_enabled)
 130                 return sprintf(buf, "%d\n", ubi->thread_enabled);
 131         else
 132                 BUG();
 133
 134         return 0;
 135 }
 136
 137 /* Fake "release" method for UBI devices */
 138 static void dev_release(struct device *dev) { }
 139
 140 /**
 141  * ubi_sysfs_init - initialize sysfs for an UBI device.
 142  * @ubi: UBI device description object
 143  *
 144  * This function returns zero in case of success and a negative error code in
 145  * case of failure.
 146  */
 147 static int ubi_sysfs_init(struct ubi_device *ubi)
 148 {
 149         int err;
 150
 151         ubi->dev.release = dev_release;
 152         ubi->dev.devt = MKDEV(ubi->major, 0);
 153         ubi->dev.class = ubi_class;
 154         sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
 155         err = device_register(&ubi->dev);
 156         if (err)
 157                 goto out;
 158
 159         err = device_create_file(&ubi->dev, &dev_eraseblock_size);
 160         if (err)
 161                 goto out_unregister;
 162         err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
 163         if (err)
 164                 goto out_eraseblock_size;
 165         err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
 166         if (err)
 167                 goto out_avail_eraseblocks;
 168         err = device_create_file(&ubi->dev, &dev_volumes_count);
 169         if (err)
 170                 goto out_total_eraseblocks;
 171         err = device_create_file(&ubi->dev, &dev_max_ec);
 172         if (err)
 173                 goto out_volumes_count;
 174         err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
 175         if (err)
 176                 goto out_volumes_max_ec;
 177         err = device_create_file(&ubi->dev, &dev_bad_peb_count);
 178         if (err)
 179                 goto out_reserved_for_bad;
 180         err = device_create_file(&ubi->dev, &dev_max_vol_count);
 181         if (err)
 182                 goto out_bad_peb_count;
 183         err = device_create_file(&ubi->dev, &dev_min_io_size);
 184         if (err)
 185                 goto out_max_vol_count;
 186         err = device_create_file(&ubi->dev, &dev_bgt_enabled);
 187         if (err)
 188                 goto out_min_io_size;
 189
 190         return 0;
 191
 192 out_min_io_size:
 193         device_remove_file(&ubi->dev, &dev_min_io_size);
 194 out_max_vol_count:
 195         device_remove_file(&ubi->dev, &dev_max_vol_count);
 196 out_bad_peb_count:
 197         device_remove_file(&ubi->dev, &dev_bad_peb_count);
 198 out_reserved_for_bad:
 199         device_remove_file(&ubi->dev, &dev_reserved_for_bad);
 200 out_volumes_max_ec:
 201         device_remove_file(&ubi->dev, &dev_max_ec);
 202 out_volumes_count:
 203         device_remove_file(&ubi->dev, &dev_volumes_count);
 204 out_total_eraseblocks:
 205         device_remove_file(&ubi->dev, &dev_total_eraseblocks);
 206 out_avail_eraseblocks:
 207         device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
 208 out_eraseblock_size:
 209         device_remove_file(&ubi->dev, &dev_eraseblock_size);
 210 out_unregister:
 211         device_unregister(&ubi->dev);
 212 out:
 213         ubi_err("failed to initialize sysfs for %s", ubi->ubi_name);
 214         return err;
 215 }
 216
 217 /**
 218  * ubi_sysfs_close - close sysfs for an UBI device.
 219  * @ubi: UBI device description object
 220  */
 221 static void ubi_sysfs_close(struct ubi_device *ubi)
 222 {
 223         device_remove_file(&ubi->dev, &dev_bgt_enabled);
 224         device_remove_file(&ubi->dev, &dev_min_io_size);
 225         device_remove_file(&ubi->dev, &dev_max_vol_count);
 226         device_remove_file(&ubi->dev, &dev_bad_peb_count);
 227         device_remove_file(&ubi->dev, &dev_reserved_for_bad);
 228         device_remove_file(&ubi->dev, &dev_max_ec);
 229         device_remove_file(&ubi->dev, &dev_volumes_count);
 230         device_remove_file(&ubi->dev, &dev_total_eraseblocks);
 231         device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
 232         device_remove_file(&ubi->dev, &dev_eraseblock_size);
 233         device_unregister(&ubi->dev);
 234 }
 235
 236 /**
 237  * kill_volumes - destroy all volumes.
 238  * @ubi: UBI device description object
 239  */
 240 static void kill_volumes(struct ubi_device *ubi)
 241 {
 242         int i;
 243
 244         for (i = 0; i < ubi->vtbl_slots; i++)
 245                 if (ubi->volumes[i])
 246                         ubi_free_volume(ubi, i);
 247 }
 248
 249 /**
 250  * uif_init - initialize user interfaces for an UBI device.
 251  * @ubi: UBI device description object
 252  *
 253  * This function returns zero in case of success and a negative error code in
 254  * case of failure.
 255  */
 256 static int uif_init(struct ubi_device *ubi)
 257 {
 258         int i, err;
 259         dev_t dev;
 260
 261         mutex_init(&ubi->vtbl_mutex);
 262         spin_lock_init(&ubi->volumes_lock);
 263
 264         sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
 265
 266         /*
 267          * Major numbers for the UBI character devices are allocated
 268          * dynamically. Major numbers of volume character devices are
 269          * equivalent to ones of the corresponding UBI character device. Minor
 270          * numbers of UBI character devices are 0, while minor numbers of
 271          * volume character devices start from 1. Thus, we allocate one major
 272          * number and ubi->vtbl_slots + 1 minor numbers.
 273          */
 274         err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
 275         if (err) {
 276                 ubi_err("cannot register UBI character devices");
 277                 return err;
 278         }
 279
 280         cdev_init(&ubi->cdev, &ubi_cdev_operations);
 281         ubi->major = MAJOR(dev);
 282         dbg_msg("%s major is %u", ubi->ubi_name, ubi->major);
 283         ubi->cdev.owner = THIS_MODULE;
 284
 285         dev = MKDEV(ubi->major, 0);
 286         err = cdev_add(&ubi->cdev, dev, 1);
 287         if (err) {
 288                 ubi_err("cannot add character device %s", ubi->ubi_name);
 289                 goto out_unreg;
 290         }
 291
 292         err = ubi_sysfs_init(ubi);
 293         if (err)
 294                 goto out_cdev;
 295
 296         for (i = 0; i < ubi->vtbl_slots; i++)
 297                 if (ubi->volumes[i]) {
 298                         err = ubi_add_volume(ubi, i);
 299                         if (err)
 300                                 goto out_volumes;
 301                 }
 302
 303         return 0;
 304
 305 out_volumes:
 306         kill_volumes(ubi);
 307         ubi_sysfs_close(ubi);
 308 out_cdev:
 309         cdev_del(&ubi->cdev);
 310 out_unreg:
 311         unregister_chrdev_region(MKDEV(ubi->major, 0),
 312                                  ubi->vtbl_slots + 1);
 313         return err;
 314 }
 315
 316 /**
 317  * uif_close - close user interfaces for an UBI device.
 318  * @ubi: UBI device description object
 319  */
 320 static void uif_close(struct ubi_device *ubi)
 321 {
 322         kill_volumes(ubi);
 323         ubi_sysfs_close(ubi);
 324         cdev_del(&ubi->cdev);
 325         unregister_chrdev_region(MKDEV(ubi->major, 0), ubi->vtbl_slots + 1);
 326 }
 327
 328 /**
 329  * attach_by_scanning - attach an MTD device using scanning method.
 330  * @ubi: UBI device descriptor
 331  *
 332  * This function returns zero in case of success and a negative error code in
 333  * case of failure.
 334  *
 335  * Note, currently this is the only method to attach UBI devices. Hopefully in
 336  * the future we'll have more scalable attaching methods and avoid full media
 337  * scanning. But even in this case scanning will be needed as a fall-back
 338  * attaching method if there are some on-flash table corruptions.
 339  */
 340 static int attach_by_scanning(struct ubi_device *ubi)
 341 {
 342         int err;
 343         struct ubi_scan_info *si;
 344
 345         si = ubi_scan(ubi);
 346         if (IS_ERR(si))
 347                 return PTR_ERR(si);
 348
 349         ubi->bad_peb_count = si->bad_peb_count;
 350         ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
 351         ubi->max_ec = si->max_ec;
 352         ubi->mean_ec = si->mean_ec;
 353
 354         err = ubi_read_volume_table(ubi, si);
 355         if (err)
 356                 goto out_si;
 357
 358         err = ubi_wl_init_scan(ubi, si);
 359         if (err)
 360                 goto out_vtbl;
 361
 362         err = ubi_eba_init_scan(ubi, si);
 363         if (err)
 364                 goto out_wl;
 365
 366         ubi_scan_destroy_si(si);
 367         return 0;
 368
 369 out_wl:
 370         ubi_wl_close(ubi);
 371 out_vtbl:
 372         kfree(ubi->vtbl);
 373 out_si:
 374         ubi_scan_destroy_si(si);
 375         return err;
 376 }
 377
 378 /**
 379  * io_init - initialize I/O unit for a given UBI device.
 380  * @ubi: UBI device description object
 381  *
 382  * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
 383  * assumed:
 384  *   o EC header is always at offset zero - this cannot be changed;
 385  *   o VID header starts just after the EC header at the closest address
 386  *   aligned to @io->@hdrs_min_io_size;
 387  *   o data starts just after the VID header at the closest address aligned to
 388  *     @io->@min_io_size
 389  *
 390  * This function returns zero in case of success and a negative error code in
 391  * case of failure.
 392  */
 393 static int io_init(struct ubi_device *ubi)
 394 {
 395         if (ubi->mtd->numeraseregions != 0) {
 396                 /*
 397                  * Some flashes have several erase regions. Different regions
 398                  * may have different eraseblock size and other
 399                  * characteristics. It looks like mostly multi-region flashes
 400                  * have one "main" region and one or more small regions to
 401                  * store boot loader code or boot parameters or whatever. I
 402                  * guess we should just pick the largest region. But this is
 403                  * not implemented.
 404                  */
 405                 ubi_err("multiple regions, not implemented");
 406                 return -EINVAL;
 407         }
 408
 409         /*
 410          * Note, in this implementation we support MTD devices with 0x7FFFFFFF
 411          * physical eraseblocks maximum.
 412          */
 413
 414         ubi->peb_size   = ubi->mtd->erasesize;
 415         ubi->peb_count  = ubi->mtd->size / ubi->mtd->erasesize;
 416         ubi->flash_size = ubi->mtd->size;
 417
 418         if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
 419                 ubi->bad_allowed = 1;
 420
 421         ubi->min_io_size = ubi->mtd->writesize;
 422         ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 423
 424         /* Make sure minimal I/O unit is power of 2 */
 425         if (ubi->min_io_size == 0 ||
 426             (ubi->min_io_size & (ubi->min_io_size - 1))) {
 427                 ubi_err("bad min. I/O unit");
 428                 return -EINVAL;
 429         }
 430
 431         ubi_assert(ubi->hdrs_min_io_size > 0);
 432         ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
 433         ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
 434
 435         /* Calculate default aligned sizes of EC and VID headers */
 436         ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
 437         ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
 438
 439         dbg_msg("min_io_size      %d", ubi->min_io_size);
 440         dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
 441         dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
 442         dbg_msg("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
 443
 444         if (ubi->vid_hdr_offset == 0)
 445                 /* Default offset */
 446                 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
 447                                       ubi->ec_hdr_alsize;
 448         else {
 449                 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
 450                                                 ~(ubi->hdrs_min_io_size - 1);
 451                 ubi->vid_hdr_shift = ubi->vid_hdr_offset -
 452                                                 ubi->vid_hdr_aloffset;
 453         }
 454
 455         /* Similar for the data offset */
 456         if (ubi->leb_start == 0) {
 457                 ubi->leb_start = ubi->vid_hdr_offset + ubi->vid_hdr_alsize;
 458                 ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
 459         }
 460
 461         dbg_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
 462         dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
 463         dbg_msg("vid_hdr_shift    %d", ubi->vid_hdr_shift);
 464         dbg_msg("leb_start        %d", ubi->leb_start);
 465
 466         /* The shift must be aligned to 32-bit boundary */
 467         if (ubi->vid_hdr_shift % 4) {
 468                 ubi_err("unaligned VID header shift %d",
 469                         ubi->vid_hdr_shift);
 470                 return -EINVAL;
 471         }
 472
 473         /* Check sanity */
 474         if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
 475             ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
 476             ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
 477             ubi->leb_start % ubi->min_io_size) {
 478                 ubi_err("bad VID header (%d) or data offsets (%d)",
 479                         ubi->vid_hdr_offset, ubi->leb_start);
 480                 return -EINVAL;
 481         }
 482
 483         /*
 484          * It may happen that EC and VID headers are situated in one minimal
 485          * I/O unit. In this case we can only accept this UBI image in
 486          * read-only mode.
 487          */
 488         if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
 489                 ubi_warn("EC and VID headers are in the same minimal I/O unit, "
 490                          "switch to read-only mode");
 491                 ubi->ro_mode = 1;
 492         }
 493
 494         ubi->leb_size = ubi->peb_size - ubi->leb_start;
 495
 496         if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
 497                 ubi_msg("MTD device %d is write-protected, attach in "
 498                         "read-only mode", ubi->mtd->index);
 499                 ubi->ro_mode = 1;
 500         }
 501
 502         dbg_msg("leb_size         %d", ubi->leb_size);
 503         dbg_msg("ro_mode          %d", ubi->ro_mode);
 504
 505         /*
 506          * Note, ideally, we have to initialize ubi->bad_peb_count here. But
 507          * unfortunately, MTD does not provide this information. We should loop
 508          * over all physical eraseblocks and invoke mtd->block_is_bad() for
 509          * each physical eraseblock. So, we skip ubi->bad_peb_count
 510          * uninitialized and initialize it after scanning.
 511          */
 512
 513         return 0;
 514 }
 515
 516 /**
 517  * attach_mtd_dev - attach an MTD device.
 518  * @mtd_dev: MTD device name or number string
 519  * @vid_hdr_offset: VID header offset
 520  * @data_offset: data offset
 521  *
 522  * This function attaches an MTD device to UBI. It first treats @mtd_dev as the
 523  * MTD device name, and tries to open it by this name. If it is unable to open,
 524  * it tries to convert @mtd_dev to an integer and open the MTD device by its
 525  * number. Returns zero in case of success and a negative error code in case of
 526  * failure.
 527  */
 528 static int attach_mtd_dev(const char *mtd_dev, int vid_hdr_offset,
 529                           int data_offset)
 530 {
 531         struct ubi_device *ubi;
 532         struct mtd_info *mtd;
 533         int i, err;
 534
 535         mtd = get_mtd_device_nm(mtd_dev);
 536         if (IS_ERR(mtd)) {
 537                 int mtd_num;
 538                 char *endp;
 539
 540                 if (PTR_ERR(mtd) != -ENODEV)
 541                         return PTR_ERR(mtd);
 542
 543                 /*
 544                  * Probably this is not MTD device name but MTD device number -
 545                  * check this out.
 546                  */
 547                 mtd_num = simple_strtoul(mtd_dev, &endp, 0);
 548                 if (*endp != '\0' || mtd_dev == endp) {
 549                         ubi_err("incorrect MTD device: \"%s\"", mtd_dev);
 550                         return -ENODEV;
 551                 }
 552
 553                 mtd = get_mtd_device(NULL, mtd_num);
 554                 if (IS_ERR(mtd))
 555                         return PTR_ERR(mtd);
 556         }
 557
 558         /* Check if we already have the same MTD device attached */
 559         for (i = 0; i < ubi_devices_cnt; i++)
 560                 if (ubi_devices[i]->mtd->index == mtd->index) {
 561                         ubi_err("mtd%d is already attached to ubi%d",
 562                                 mtd->index, i);
 563                         err = -EINVAL;
 564                         goto out_mtd;
 565                 }
 566
 567         ubi = ubi_devices[ubi_devices_cnt] = kzalloc(sizeof(struct ubi_device),
 568                                                       GFP_KERNEL);
 569         if (!ubi) {
 570                 err = -ENOMEM;
 571                 goto out_mtd;
 572         }
 573
 574         ubi->ubi_num = ubi_devices_cnt;
 575         ubi->mtd = mtd;
 576
 577         dbg_msg("attaching mtd%d to ubi%d: VID header offset %d data offset %d",
 578                 ubi->mtd->index, ubi_devices_cnt, vid_hdr_offset, data_offset);
 579
 580         ubi->vid_hdr_offset = vid_hdr_offset;
 581         ubi->leb_start = data_offset;
 582         err = io_init(ubi);
 583         if (err)
 584                 goto out_free;
 585
 586         err = attach_by_scanning(ubi);
 587         if (err) {
 588                 dbg_err("failed to attach by scanning, error %d", err);
 589                 goto out_free;
 590         }
 591
 592         err = uif_init(ubi);
 593         if (err)
 594                 goto out_detach;
 595
 596         ubi_devices_cnt += 1;
 597
 598         ubi_msg("attached mtd%d to ubi%d", ubi->mtd->index, ubi_devices_cnt);
 599         ubi_msg("MTD device name:            \"%s\"", ubi->mtd->name);
 600         ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
 601         ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
 602                 ubi->peb_size, ubi->peb_size >> 10);
 603         ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
 604         ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
 605         ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
 606         ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
 607         ubi_msg("VID header offset:          %d (aligned %d)",
 608                 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
 609         ubi_msg("data offset:                %d", ubi->leb_start);
 610         ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
 611         ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
 612         ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
 613         ubi_msg("number of user volumes:     %d",
 614                 ubi->vol_count - UBI_INT_VOL_COUNT);
 615         ubi_msg("available PEBs:             %d", ubi->avail_pebs);
 616         ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
 617         ubi_msg("number of PEBs reserved for bad PEB handling: %d",
 618                 ubi->beb_rsvd_pebs);
 619         ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
 620
 621         /* Enable the background thread */
 622         if (!DBG_DISABLE_BGT) {
 623                 ubi->thread_enabled = 1;
 624                 wake_up_process(ubi->bgt_thread);
 625         }
 626
 627         return 0;
 628
 629 out_detach:
 630         ubi_eba_close(ubi);
 631         ubi_wl_close(ubi);
 632         kfree(ubi->vtbl);
 633 out_free:
 634         kfree(ubi);
 635 out_mtd:
 636         put_mtd_device(mtd);
 637         ubi_devices[ubi_devices_cnt] = NULL;
 638         return err;
 639 }
 640
 641 /**
 642  * detach_mtd_dev - detach an MTD device.
 643  * @ubi: UBI device description object
 644  */
 645 static void detach_mtd_dev(struct ubi_device *ubi)
 646 {
 647         int ubi_num = ubi->ubi_num, mtd_num = ubi->mtd->index;
 648
 649         dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
 650         uif_close(ubi);
 651         ubi_eba_close(ubi);
 652         ubi_wl_close(ubi);
 653         kfree(ubi->vtbl);
 654         put_mtd_device(ubi->mtd);
 655         kfree(ubi_devices[ubi_num]);
 656         ubi_devices[ubi_num] = NULL;
 657         ubi_devices_cnt -= 1;
 658         ubi_assert(ubi_devices_cnt >= 0);
 659         ubi_msg("mtd%d is detached from ubi%d", mtd_num, ubi_num);
 660 }
 661
 662 static int __init ubi_init(void)
 663 {
 664         int err, i, k;
 665
 666         /* Ensure that EC and VID headers have correct size */
 667         BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
 668         BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
 669
 670         if (mtd_devs > UBI_MAX_DEVICES) {
 671                 printk("UBI error: too many MTD devices, maximum is %d\n",
 672                        UBI_MAX_DEVICES);
 673                 return -EINVAL;
 674         }
 675
 676         ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
 677         if (IS_ERR(ubi_class))
 678                 return PTR_ERR(ubi_class);
 679
 680         err = class_create_file(ubi_class, &ubi_version);
 681         if (err)
 682                 goto out_class;
 683
 684         /* Attach MTD devices */
 685         for (i = 0; i < mtd_devs; i++) {
 686                 struct mtd_dev_param *p = &mtd_dev_param[i];
 687
 688                 cond_resched();
 689
 690                 if (!p->name) {
 691                         dbg_err("empty name");
 692                         err = -EINVAL;
 693                         goto out_detach;
 694                 }
 695
 696                 err = attach_mtd_dev(p->name, p->vid_hdr_offs, p->data_offs);
 697                 if (err)
 698                         goto out_detach;
 699         }
 700
 701         return 0;
 702
 703 out_detach:
 704         for (k = 0; k < i; k++)
 705                 detach_mtd_dev(ubi_devices[k]);
 706         class_remove_file(ubi_class, &ubi_version);
 707 out_class:
 708         class_destroy(ubi_class);
 709         return err;
 710 }
 711 module_init(ubi_init);
 712
 713 static void __exit ubi_exit(void)
 714 {
 715         int i, n = ubi_devices_cnt;
 716
 717         for (i = 0; i < n; i++)
 718                 detach_mtd_dev(ubi_devices[i]);
 719         class_remove_file(ubi_class, &ubi_version);
 720         class_destroy(ubi_class);
 721 }
 722 module_exit(ubi_exit);
 723
 724 /**
 725  * bytes_str_to_int - convert a string representing number of bytes to an
 726  * integer.
 727  * @str: the string to convert
 728  *
 729  * This function returns positive resulting integer in case of success and a
 730  * negative error code in case of failure.
 731  */
 732 static int __init bytes_str_to_int(const char *str)
 733 {
 734         char *endp;
 735         unsigned long result;
 736
 737         result = simple_strtoul(str, &endp, 0);
 738         if (str == endp || result < 0) {
 739                 printk("UBI error: incorrect bytes count: \"%s\"\n", str);
 740                 return -EINVAL;
 741         }
 742
 743         switch (*endp) {
 744         case 'G':
 745                 result *= 1024;
 746         case 'M':
 747                 result *= 1024;
 748         case 'K':
 749         case 'k':
 750                 result *= 1024;
 751                 if (endp[1] == 'i' && (endp[2] == '\0' ||
 752                           endp[2] == 'B'  || endp[2] == 'b'))
 753                         endp += 2;
 754         case '\0':
 755                 break;
 756         default:
 757                 printk("UBI error: incorrect bytes count: \"%s\"\n", str);
 758                 return -EINVAL;
 759         }
 760
 761         return result;
 762 }
 763
 764 /**
 765  * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
 766  * @val: the parameter value to parse
 767  * @kp: not used
 768  *
 769  * This function returns zero in case of success and a negative error code in
 770  * case of error.
 771  */
 772 static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
 773 {
 774         int i, len;
 775         struct mtd_dev_param *p;
 776         char buf[MTD_PARAM_LEN_MAX];
 777         char *pbuf = &buf[0];
 778         char *tokens[3] = {NULL, NULL, NULL};
 779
 780         if (mtd_devs == UBI_MAX_DEVICES) {
 781                 printk("UBI error: too many parameters, max. is %d\n",
 782                        UBI_MAX_DEVICES);
 783                 return -EINVAL;
 784         }
 785
 786         len = strnlen(val, MTD_PARAM_LEN_MAX);
 787         if (len == MTD_PARAM_LEN_MAX) {
 788                 printk("UBI error: parameter \"%s\" is too long, max. is %d\n",
 789                        val, MTD_PARAM_LEN_MAX);
 790                 return -EINVAL;
 791         }
 792
 793         if (len == 0) {
 794                 printk("UBI warning: empty 'mtd=' parameter - ignored\n");
 795                 return 0;
 796         }
 797
 798         strcpy(buf, val);
 799
 800         /* Get rid of the final newline */
 801         if (buf[len - 1] == '\n')
 802                 buf[len - 1] = 0;
 803
 804         for (i = 0; i < 3; i++)
 805                 tokens[i] = strsep(&pbuf, ",");
 806
 807         if (pbuf) {
 808                 printk("UBI error: too many arguments at \"%s\"\n", val);
 809                 return -EINVAL;
 810         }
 811
 812         if (tokens[0] == '\0')
 813                 return -EINVAL;
 814
 815         p = &mtd_dev_param[mtd_devs];
 816         strcpy(&p->name[0], tokens[0]);
 817
 818         if (tokens[1])
 819                 p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
 820         if (tokens[2])
 821                 p->data_offs = bytes_str_to_int(tokens[2]);
 822
 823         if (p->vid_hdr_offs < 0)
 824                 return p->vid_hdr_offs;
 825         if (p->data_offs < 0)
 826                 return p->data_offs;
 827
 828         mtd_devs += 1;
 829         return 0;
 830 }
 831
 832 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
 833 MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
 834                       "mtd=<name|num>[,<vid_hdr_offs>,<data_offs>]. "
 835                       "Multiple \"mtd\" parameters may be specified.\n"
 836                       "MTD devices may be specified by their number or name. "
 837                       "Optional \"vid_hdr_offs\" and \"data_offs\" parameters "
 838                       "specify UBI VID header position and data starting "
 839                       "position to be used by UBI.\n"
 840                       "Example: mtd=content,1984,2048 mtd=4 - attach MTD device"
 841                       "with name content using VID header offset 1984 and data "
 842                       "start 2048, and MTD device number 4 using default "
 843                       "offsets");
 844
 845 MODULE_VERSION(__stringify(UBI_VERSION));
 846 MODULE_DESCRIPTION("UBI - Unsorted Block Images");
 847 MODULE_AUTHOR("Artem Bityutskiy");
 848 MODULE_LICENSE("GPL");