drivers/mtd/mtdcore.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Core registration and callback routines for MTD
   4  * drivers and users.
   5  *
   6  * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
   7  * Copyright © 2006      Red Hat UK Limited
   8  *
   9  */
  10
  11 #ifndef __UBOOT__
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/ptrace.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/string.h>
  17 #include <linux/timer.h>
  18 #include <linux/major.h>
  19 #include <linux/fs.h>
  20 #include <linux/err.h>
  21 #include <linux/ioctl.h>
  22 #include <linux/init.h>
  23 #include <linux/proc_fs.h>
  24 #include <linux/idr.h>
  25 #include <linux/backing-dev.h>
  26 #include <linux/gfp.h>
  27 #include <linux/slab.h>
  28 #else
  29 #include <linux/err.h>
  30 #include <ubi_uboot.h>
  31 #endif
  32
  33 #include <linux/log2.h>
  34 #include <linux/mtd/mtd.h>
  35 #include <linux/mtd/partitions.h>
  36
  37 #include "mtdcore.h"
  38
  39 #ifndef __UBOOT__
  40 /*
  41  * backing device capabilities for non-mappable devices (such as NAND flash)
  42  * - permits private mappings, copies are taken of the data
  43  */
  44 static struct backing_dev_info mtd_bdi_unmappable = {
  45         .capabilities   = BDI_CAP_MAP_COPY,
  46 };
  47
  48 /*
  49  * backing device capabilities for R/O mappable devices (such as ROM)
  50  * - permits private mappings, copies are taken of the data
  51  * - permits non-writable shared mappings
  52  */
  53 static struct backing_dev_info mtd_bdi_ro_mappable = {
  54         .capabilities   = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
  55                            BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP),
  56 };
  57
  58 /*
  59  * backing device capabilities for writable mappable devices (such as RAM)
  60  * - permits private mappings, copies are taken of the data
  61  * - permits non-writable shared mappings
  62  */
  63 static struct backing_dev_info mtd_bdi_rw_mappable = {
  64         .capabilities   = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
  65                            BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP |
  66                            BDI_CAP_WRITE_MAP),
  67 };
  68
  69 static int mtd_cls_suspend(struct device *dev, pm_message_t state);
  70 static int mtd_cls_resume(struct device *dev);
  71
  72 static struct class mtd_class = {
  73         .name = "mtd",
  74         .owner = THIS_MODULE,
  75         .suspend = mtd_cls_suspend,
  76         .resume = mtd_cls_resume,
  77 };
  78 #else
  79 struct mtd_info *mtd_table[MAX_MTD_DEVICES];
  80
  81 #define MAX_IDR_ID      64
  82
  83 struct idr_layer {
  84         int     used;
  85         void    *ptr;
  86 };
  87
  88 struct idr {
  89         struct idr_layer id[MAX_IDR_ID];
  90         bool updated;
  91 };
  92
  93 #define DEFINE_IDR(name)        struct idr name;
  94
  95 void idr_remove(struct idr *idp, int id)
  96 {
  97         if (idp->id[id].used) {
  98                 idp->id[id].used = 0;
  99                 idp->updated = true;
 100         }
 101
 102         return;
 103 }
 104 void *idr_find(struct idr *idp, int id)
 105 {
 106         if (idp->id[id].used)
 107                 return idp->id[id].ptr;
 108
 109         return NULL;
 110 }
 111
 112 void *idr_get_next(struct idr *idp, int *next)
 113 {
 114         void *ret;
 115         int id = *next;
 116
 117         ret = idr_find(idp, id);
 118         if (ret) {
 119                 id ++;
 120                 if (!idp->id[id].used)
 121                         id = 0;
 122                 *next = id;
 123         } else {
 124                 *next = 0;
 125         }
 126
 127         return ret;
 128 }
 129
 130 int idr_alloc(struct idr *idp, void *ptr, int start, int end, gfp_t gfp_mask)
 131 {
 132         struct idr_layer *idl;
 133         int i = 0;
 134
 135         while (i < MAX_IDR_ID) {
 136                 idl = &idp->id[i];
 137                 if (idl->used == 0) {
 138                         idl->used = 1;
 139                         idl->ptr = ptr;
 140                         idp->updated = true;
 141                         return i;
 142                 }
 143                 i++;
 144         }
 145         return -ENOSPC;
 146 }
 147 #endif
 148
 149 static DEFINE_IDR(mtd_idr);
 150
 151 /* These are exported solely for the purpose of mtd_blkdevs.c. You
 152    should not use them for _anything_ else */
 153 DEFINE_MUTEX(mtd_table_mutex);
 154 EXPORT_SYMBOL_GPL(mtd_table_mutex);
 155
 156 struct mtd_info *__mtd_next_device(int i)
 157 {
 158         return idr_get_next(&mtd_idr, &i);
 159 }
 160 EXPORT_SYMBOL_GPL(__mtd_next_device);
 161
 162 bool mtd_dev_list_updated(void)
 163 {
 164         if (mtd_idr.updated) {
 165                 mtd_idr.updated = false;
 166                 return true;
 167         }
 168
 169         return false;
 170 }
 171
 172 #ifndef __UBOOT__
 173 static LIST_HEAD(mtd_notifiers);
 174
 175
 176 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
 177
 178 /* REVISIT once MTD uses the driver model better, whoever allocates
 179  * the mtd_info will probably want to use the release() hook...
 180  */
 181 static void mtd_release(struct device *dev)
 182 {
 183         struct mtd_info __maybe_unused *mtd = dev_get_drvdata(dev);
 184         dev_t index = MTD_DEVT(mtd->index);
 185
 186         /* remove /dev/mtdXro node if needed */
 187         if (index)
 188                 device_destroy(&mtd_class, index + 1);
 189 }
 190
 191 static int mtd_cls_suspend(struct device *dev, pm_message_t state)
 192 {
 193         struct mtd_info *mtd = dev_get_drvdata(dev);
 194
 195         return mtd ? mtd_suspend(mtd) : 0;
 196 }
 197
 198 static int mtd_cls_resume(struct device *dev)
 199 {
 200         struct mtd_info *mtd = dev_get_drvdata(dev);
 201
 202         if (mtd)
 203                 mtd_resume(mtd);
 204         return 0;
 205 }
 206
 207 static ssize_t mtd_type_show(struct device *dev,
 208                 struct device_attribute *attr, char *buf)
 209 {
 210         struct mtd_info *mtd = dev_get_drvdata(dev);
 211         char *type;
 212
 213         switch (mtd->type) {
 214         case MTD_ABSENT:
 215                 type = "absent";
 216                 break;
 217         case MTD_RAM:
 218                 type = "ram";
 219                 break;
 220         case MTD_ROM:
 221                 type = "rom";
 222                 break;
 223         case MTD_NORFLASH:
 224                 type = "nor";
 225                 break;
 226         case MTD_NANDFLASH:
 227                 type = "nand";
 228                 break;
 229         case MTD_DATAFLASH:
 230                 type = "dataflash";
 231                 break;
 232         case MTD_UBIVOLUME:
 233                 type = "ubi";
 234                 break;
 235         case MTD_MLCNANDFLASH:
 236                 type = "mlc-nand";
 237                 break;
 238         default:
 239                 type = "unknown";
 240         }
 241
 242         return snprintf(buf, PAGE_SIZE, "%s\n", type);
 243 }
 244 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
 245
 246 static ssize_t mtd_flags_show(struct device *dev,
 247                 struct device_attribute *attr, char *buf)
 248 {
 249         struct mtd_info *mtd = dev_get_drvdata(dev);
 250
 251         return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
 252
 253 }
 254 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
 255
 256 static ssize_t mtd_size_show(struct device *dev,
 257                 struct device_attribute *attr, char *buf)
 258 {
 259         struct mtd_info *mtd = dev_get_drvdata(dev);
 260
 261         return snprintf(buf, PAGE_SIZE, "%llu\n",
 262                 (unsigned long long)mtd->size);
 263
 264 }
 265 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
 266
 267 static ssize_t mtd_erasesize_show(struct device *dev,
 268                 struct device_attribute *attr, char *buf)
 269 {
 270         struct mtd_info *mtd = dev_get_drvdata(dev);
 271
 272         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
 273
 274 }
 275 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
 276
 277 static ssize_t mtd_writesize_show(struct device *dev,
 278                 struct device_attribute *attr, char *buf)
 279 {
 280         struct mtd_info *mtd = dev_get_drvdata(dev);
 281
 282         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
 283
 284 }
 285 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
 286
 287 static ssize_t mtd_subpagesize_show(struct device *dev,
 288                 struct device_attribute *attr, char *buf)
 289 {
 290         struct mtd_info *mtd = dev_get_drvdata(dev);
 291         unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
 292
 293         return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
 294
 295 }
 296 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
 297
 298 static ssize_t mtd_oobsize_show(struct device *dev,
 299                 struct device_attribute *attr, char *buf)
 300 {
 301         struct mtd_info *mtd = dev_get_drvdata(dev);
 302
 303         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
 304
 305 }
 306 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
 307
 308 static ssize_t mtd_numeraseregions_show(struct device *dev,
 309                 struct device_attribute *attr, char *buf)
 310 {
 311         struct mtd_info *mtd = dev_get_drvdata(dev);
 312
 313         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
 314
 315 }
 316 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
 317         NULL);
 318
 319 static ssize_t mtd_name_show(struct device *dev,
 320                 struct device_attribute *attr, char *buf)
 321 {
 322         struct mtd_info *mtd = dev_get_drvdata(dev);
 323
 324         return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
 325
 326 }
 327 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
 328
 329 static ssize_t mtd_ecc_strength_show(struct device *dev,
 330                                      struct device_attribute *attr, char *buf)
 331 {
 332         struct mtd_info *mtd = dev_get_drvdata(dev);
 333
 334         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_strength);
 335 }
 336 static DEVICE_ATTR(ecc_strength, S_IRUGO, mtd_ecc_strength_show, NULL);
 337
 338 static ssize_t mtd_bitflip_threshold_show(struct device *dev,
 339                                           struct device_attribute *attr,
 340                                           char *buf)
 341 {
 342         struct mtd_info *mtd = dev_get_drvdata(dev);
 343
 344         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->bitflip_threshold);
 345 }
 346
 347 static ssize_t mtd_bitflip_threshold_store(struct device *dev,
 348                                            struct device_attribute *attr,
 349                                            const char *buf, size_t count)
 350 {
 351         struct mtd_info *mtd = dev_get_drvdata(dev);
 352         unsigned int bitflip_threshold;
 353         int retval;
 354
 355         retval = kstrtouint(buf, 0, &bitflip_threshold);
 356         if (retval)
 357                 return retval;
 358
 359         mtd->bitflip_threshold = bitflip_threshold;
 360         return count;
 361 }
 362 static DEVICE_ATTR(bitflip_threshold, S_IRUGO | S_IWUSR,
 363                    mtd_bitflip_threshold_show,
 364                    mtd_bitflip_threshold_store);
 365
 366 static ssize_t mtd_ecc_step_size_show(struct device *dev,
 367                 struct device_attribute *attr, char *buf)
 368 {
 369         struct mtd_info *mtd = dev_get_drvdata(dev);
 370
 371         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_step_size);
 372
 373 }
 374 static DEVICE_ATTR(ecc_step_size, S_IRUGO, mtd_ecc_step_size_show, NULL);
 375
 376 static struct attribute *mtd_attrs[] = {
 377         &dev_attr_type.attr,
 378         &dev_attr_flags.attr,
 379         &dev_attr_size.attr,
 380         &dev_attr_erasesize.attr,
 381         &dev_attr_writesize.attr,
 382         &dev_attr_subpagesize.attr,
 383         &dev_attr_oobsize.attr,
 384         &dev_attr_numeraseregions.attr,
 385         &dev_attr_name.attr,
 386         &dev_attr_ecc_strength.attr,
 387         &dev_attr_ecc_step_size.attr,
 388         &dev_attr_bitflip_threshold.attr,
 389         NULL,
 390 };
 391 ATTRIBUTE_GROUPS(mtd);
 392
 393 static struct device_type mtd_devtype = {
 394         .name           = "mtd",
 395         .groups         = mtd_groups,
 396         .release        = mtd_release,
 397 };
 398 #endif
 399
 400 /**
 401  *      add_mtd_device - register an MTD device
 402  *      @mtd: pointer to new MTD device info structure
 403  *
 404  *      Add a device to the list of MTD devices present in the system, and
 405  *      notify each currently active MTD 'user' of its arrival. Returns
 406  *      zero on success or 1 on failure, which currently will only happen
 407  *      if there is insufficient memory or a sysfs error.
 408  */
 409
 410 int add_mtd_device(struct mtd_info *mtd)
 411 {
 412 #ifndef __UBOOT__
 413         struct mtd_notifier *not;
 414 #endif
 415         int i, error;
 416
 417 #ifndef __UBOOT__
 418         if (!mtd->backing_dev_info) {
 419                 switch (mtd->type) {
 420                 case MTD_RAM:
 421                         mtd->backing_dev_info = &mtd_bdi_rw_mappable;
 422                         break;
 423                 case MTD_ROM:
 424                         mtd->backing_dev_info = &mtd_bdi_ro_mappable;
 425                         break;
 426                 default:
 427                         mtd->backing_dev_info = &mtd_bdi_unmappable;
 428                         break;
 429                 }
 430         }
 431 #endif
 432
 433         BUG_ON(mtd->writesize == 0);
 434         mutex_lock(&mtd_table_mutex);
 435
 436         i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL);
 437         if (i < 0)
 438                 goto fail_locked;
 439
 440         mtd->index = i;
 441         mtd->usecount = 0;
 442
 443         INIT_LIST_HEAD(&mtd->partitions);
 444
 445         /* default value if not set by driver */
 446         if (mtd->bitflip_threshold == 0)
 447                 mtd->bitflip_threshold = mtd->ecc_strength;
 448
 449         if (is_power_of_2(mtd->erasesize))
 450                 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
 451         else
 452                 mtd->erasesize_shift = 0;
 453
 454         if (is_power_of_2(mtd->writesize))
 455                 mtd->writesize_shift = ffs(mtd->writesize) - 1;
 456         else
 457                 mtd->writesize_shift = 0;
 458
 459         mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
 460         mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
 461
 462         /* Some chips always power up locked. Unlock them now */
 463         if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) {
 464                 error = mtd_unlock(mtd, 0, mtd->size);
 465                 if (error && error != -EOPNOTSUPP)
 466                         printk(KERN_WARNING
 467                                "%s: unlock failed, writes may not work\n",
 468                                mtd->name);
 469         }
 470
 471 #ifndef __UBOOT__
 472         /* Caller should have set dev.parent to match the
 473          * physical device.
 474          */
 475         mtd->dev.type = &mtd_devtype;
 476         mtd->dev.class = &mtd_class;
 477         mtd->dev.devt = MTD_DEVT(i);
 478         dev_set_name(&mtd->dev, "mtd%d", i);
 479         dev_set_drvdata(&mtd->dev, mtd);
 480         if (device_register(&mtd->dev) != 0)
 481                 goto fail_added;
 482
 483         if (MTD_DEVT(i))
 484                 device_create(&mtd_class, mtd->dev.parent,
 485                               MTD_DEVT(i) + 1,
 486                               NULL, "mtd%dro", i);
 487
 488         pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
 489         /* No need to get a refcount on the module containing
 490            the notifier, since we hold the mtd_table_mutex */
 491         list_for_each_entry(not, &mtd_notifiers, list)
 492                 not->add(mtd);
 493 #else
 494         pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
 495 #endif
 496
 497         mutex_unlock(&mtd_table_mutex);
 498         /* We _know_ we aren't being removed, because
 499            our caller is still holding us here. So none
 500            of this try_ nonsense, and no bitching about it
 501            either. :) */
 502         __module_get(THIS_MODULE);
 503         return 0;
 504
 505 #ifndef __UBOOT__
 506 fail_added:
 507         idr_remove(&mtd_idr, i);
 508 #endif
 509 fail_locked:
 510         mutex_unlock(&mtd_table_mutex);
 511         return 1;
 512 }
 513
 514 /**
 515  *      del_mtd_device - unregister an MTD device
 516  *      @mtd: pointer to MTD device info structure
 517  *
 518  *      Remove a device from the list of MTD devices present in the system,
 519  *      and notify each currently active MTD 'user' of its departure.
 520  *      Returns zero on success or 1 on failure, which currently will happen
 521  *      if the requested device does not appear to be present in the list.
 522  */
 523
 524 int del_mtd_device(struct mtd_info *mtd)
 525 {
 526         int ret;
 527 #ifndef __UBOOT__
 528         struct mtd_notifier *not;
 529 #endif
 530
 531         ret = del_mtd_partitions(mtd);
 532         if (ret) {
 533                 debug("Failed to delete MTD partitions attached to %s (err %d)\n",
 534                       mtd->name, ret);
 535                 return ret;
 536         }
 537
 538         mutex_lock(&mtd_table_mutex);
 539
 540         if (idr_find(&mtd_idr, mtd->index) != mtd) {
 541                 ret = -ENODEV;
 542                 goto out_error;
 543         }
 544
 545 #ifndef __UBOOT__
 546         /* No need to get a refcount on the module containing
 547                 the notifier, since we hold the mtd_table_mutex */
 548         list_for_each_entry(not, &mtd_notifiers, list)
 549                 not->remove(mtd);
 550 #endif
 551
 552         if (mtd->usecount) {
 553                 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
 554                        mtd->index, mtd->name, mtd->usecount);
 555                 ret = -EBUSY;
 556         } else {
 557 #ifndef __UBOOT__
 558                 device_unregister(&mtd->dev);
 559 #endif
 560
 561                 idr_remove(&mtd_idr, mtd->index);
 562
 563                 module_put(THIS_MODULE);
 564                 ret = 0;
 565         }
 566
 567 out_error:
 568         mutex_unlock(&mtd_table_mutex);
 569         return ret;
 570 }
 571
 572 #ifndef __UBOOT__
 573 /**
 574  * mtd_device_parse_register - parse partitions and register an MTD device.
 575  *
 576  * @mtd: the MTD device to register
 577  * @types: the list of MTD partition probes to try, see
 578  *         'parse_mtd_partitions()' for more information
 579  * @parser_data: MTD partition parser-specific data
 580  * @parts: fallback partition information to register, if parsing fails;
 581  *         only valid if %nr_parts > %0
 582  * @nr_parts: the number of partitions in parts, if zero then the full
 583  *            MTD device is registered if no partition info is found
 584  *
 585  * This function aggregates MTD partitions parsing (done by
 586  * 'parse_mtd_partitions()') and MTD device and partitions registering. It
 587  * basically follows the most common pattern found in many MTD drivers:
 588  *
 589  * * It first tries to probe partitions on MTD device @mtd using parsers
 590  *   specified in @types (if @types is %NULL, then the default list of parsers
 591  *   is used, see 'parse_mtd_partitions()' for more information). If none are
 592  *   found this functions tries to fallback to information specified in
 593  *   @parts/@nr_parts.
 594  * * If any partitioning info was found, this function registers the found
 595  *   partitions.
 596  * * If no partitions were found this function just registers the MTD device
 597  *   @mtd and exits.
 598  *
 599  * Returns zero in case of success and a negative error code in case of failure.
 600  */
 601 int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
 602                               struct mtd_part_parser_data *parser_data,
 603                               const struct mtd_partition *parts,
 604                               int nr_parts)
 605 {
 606         int err;
 607         struct mtd_partition *real_parts;
 608
 609         err = parse_mtd_partitions(mtd, types, &real_parts, parser_data);
 610         if (err <= 0 && nr_parts && parts) {
 611                 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts,
 612                                      GFP_KERNEL);
 613                 if (!real_parts)
 614                         err = -ENOMEM;
 615                 else
 616                         err = nr_parts;
 617         }
 618
 619         if (err > 0) {
 620                 err = add_mtd_partitions(mtd, real_parts, err);
 621                 kfree(real_parts);
 622         } else if (err == 0) {
 623                 err = add_mtd_device(mtd);
 624                 if (err == 1)
 625                         err = -ENODEV;
 626         }
 627
 628         return err;
 629 }
 630 EXPORT_SYMBOL_GPL(mtd_device_parse_register);
 631
 632 /**
 633  * mtd_device_unregister - unregister an existing MTD device.
 634  *
 635  * @master: the MTD device to unregister.  This will unregister both the master
 636  *          and any partitions if registered.
 637  */
 638 int mtd_device_unregister(struct mtd_info *master)
 639 {
 640         int err;
 641
 642         err = del_mtd_partitions(master);
 643         if (err)
 644                 return err;
 645
 646         if (!device_is_registered(&master->dev))
 647                 return 0;
 648
 649         return del_mtd_device(master);
 650 }
 651 EXPORT_SYMBOL_GPL(mtd_device_unregister);
 652
 653 /**
 654  *      register_mtd_user - register a 'user' of MTD devices.
 655  *      @new: pointer to notifier info structure
 656  *
 657  *      Registers a pair of callbacks function to be called upon addition
 658  *      or removal of MTD devices. Causes the 'add' callback to be immediately
 659  *      invoked for each MTD device currently present in the system.
 660  */
 661 void register_mtd_user (struct mtd_notifier *new)
 662 {
 663         struct mtd_info *mtd;
 664
 665         mutex_lock(&mtd_table_mutex);
 666
 667         list_add(&new->list, &mtd_notifiers);
 668
 669         __module_get(THIS_MODULE);
 670
 671         mtd_for_each_device(mtd)
 672                 new->add(mtd);
 673
 674         mutex_unlock(&mtd_table_mutex);
 675 }
 676 EXPORT_SYMBOL_GPL(register_mtd_user);
 677
 678 /**
 679  *      unregister_mtd_user - unregister a 'user' of MTD devices.
 680  *      @old: pointer to notifier info structure
 681  *
 682  *      Removes a callback function pair from the list of 'users' to be
 683  *      notified upon addition or removal of MTD devices. Causes the
 684  *      'remove' callback to be immediately invoked for each MTD device
 685  *      currently present in the system.
 686  */
 687 int unregister_mtd_user (struct mtd_notifier *old)
 688 {
 689         struct mtd_info *mtd;
 690
 691         mutex_lock(&mtd_table_mutex);
 692
 693         module_put(THIS_MODULE);
 694
 695         mtd_for_each_device(mtd)
 696                 old->remove(mtd);
 697
 698         list_del(&old->list);
 699         mutex_unlock(&mtd_table_mutex);
 700         return 0;
 701 }
 702 EXPORT_SYMBOL_GPL(unregister_mtd_user);
 703 #endif
 704
 705 /**
 706  *      get_mtd_device - obtain a validated handle for an MTD device
 707  *      @mtd: last known address of the required MTD device
 708  *      @num: internal device number of the required MTD device
 709  *
 710  *      Given a number and NULL address, return the num'th entry in the device
 711  *      table, if any.  Given an address and num == -1, search the device table
 712  *      for a device with that address and return if it's still present. Given
 713  *      both, return the num'th driver only if its address matches. Return
 714  *      error code if not.
 715  */
 716 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
 717 {
 718         struct mtd_info *ret = NULL, *other;
 719         int err = -ENODEV;
 720
 721         mutex_lock(&mtd_table_mutex);
 722
 723         if (num == -1) {
 724                 mtd_for_each_device(other) {
 725                         if (other == mtd) {
 726                                 ret = mtd;
 727                                 break;
 728                         }
 729                 }
 730         } else if (num >= 0) {
 731                 ret = idr_find(&mtd_idr, num);
 732                 if (mtd && mtd != ret)
 733                         ret = NULL;
 734         }
 735
 736         if (!ret) {
 737                 ret = ERR_PTR(err);
 738                 goto out;
 739         }
 740
 741         err = __get_mtd_device(ret);
 742         if (err)
 743                 ret = ERR_PTR(err);
 744 out:
 745         mutex_unlock(&mtd_table_mutex);
 746         return ret;
 747 }
 748 EXPORT_SYMBOL_GPL(get_mtd_device);
 749
 750
 751 int __get_mtd_device(struct mtd_info *mtd)
 752 {
 753         int err;
 754
 755         if (!try_module_get(mtd->owner))
 756                 return -ENODEV;
 757
 758         if (mtd->_get_device) {
 759                 err = mtd->_get_device(mtd);
 760
 761                 if (err) {
 762                         module_put(mtd->owner);
 763                         return err;
 764                 }
 765         }
 766         mtd->usecount++;
 767         return 0;
 768 }
 769 EXPORT_SYMBOL_GPL(__get_mtd_device);
 770
 771 /**
 772  *      get_mtd_device_nm - obtain a validated handle for an MTD device by
 773  *      device name
 774  *      @name: MTD device name to open
 775  *
 776  *      This function returns MTD device description structure in case of
 777  *      success and an error code in case of failure.
 778  */
 779 struct mtd_info *get_mtd_device_nm(const char *name)
 780 {
 781         int err = -ENODEV;
 782         struct mtd_info *mtd = NULL, *other;
 783
 784         mutex_lock(&mtd_table_mutex);
 785
 786         mtd_for_each_device(other) {
 787                 if (!strcmp(name, other->name)) {
 788                         mtd = other;
 789                         break;
 790                 }
 791         }
 792
 793         if (!mtd)
 794                 goto out_unlock;
 795
 796         err = __get_mtd_device(mtd);
 797         if (err)
 798                 goto out_unlock;
 799
 800         mutex_unlock(&mtd_table_mutex);
 801         return mtd;
 802
 803 out_unlock:
 804         mutex_unlock(&mtd_table_mutex);
 805         return ERR_PTR(err);
 806 }
 807 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
 808
 809 #if defined(CONFIG_CMD_MTDPARTS_SPREAD)
 810 /**
 811  * mtd_get_len_incl_bad
 812  *
 813  * Check if length including bad blocks fits into device.
 814  *
 815  * @param mtd an MTD device
 816  * @param offset offset in flash
 817  * @param length image length
 818  * @return image length including bad blocks in *len_incl_bad and whether or not
 819  *         the length returned was truncated in *truncated
 820  */
 821 void mtd_get_len_incl_bad(struct mtd_info *mtd, uint64_t offset,
 822                           const uint64_t length, uint64_t *len_incl_bad,
 823                           int *truncated)
 824 {
 825         *truncated = 0;
 826         *len_incl_bad = 0;
 827
 828         if (!mtd->_block_isbad) {
 829                 *len_incl_bad = length;
 830                 return;
 831         }
 832
 833         uint64_t len_excl_bad = 0;
 834         uint64_t block_len;
 835
 836         while (len_excl_bad < length) {
 837                 if (offset >= mtd->size) {
 838                         *truncated = 1;
 839                         return;
 840                 }
 841
 842                 block_len = mtd->erasesize - (offset & (mtd->erasesize - 1));
 843
 844                 if (!mtd->_block_isbad(mtd, offset & ~(mtd->erasesize - 1)))
 845                         len_excl_bad += block_len;
 846
 847                 *len_incl_bad += block_len;
 848                 offset       += block_len;
 849         }
 850 }
 851 #endif /* defined(CONFIG_CMD_MTDPARTS_SPREAD) */
 852
 853 void put_mtd_device(struct mtd_info *mtd)
 854 {
 855         mutex_lock(&mtd_table_mutex);
 856         __put_mtd_device(mtd);
 857         mutex_unlock(&mtd_table_mutex);
 858
 859 }
 860 EXPORT_SYMBOL_GPL(put_mtd_device);
 861
 862 void __put_mtd_device(struct mtd_info *mtd)
 863 {
 864         --mtd->usecount;
 865         BUG_ON(mtd->usecount < 0);
 866
 867         if (mtd->_put_device)
 868                 mtd->_put_device(mtd);
 869
 870         module_put(mtd->owner);
 871 }
 872 EXPORT_SYMBOL_GPL(__put_mtd_device);
 873
 874 /*
 875  * Erase is an asynchronous operation.  Device drivers are supposed
 876  * to call instr->callback() whenever the operation completes, even
 877  * if it completes with a failure.
 878  * Callers are supposed to pass a callback function and wait for it
 879  * to be called before writing to the block.
 880  */
 881 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
 882 {
 883         if (instr->addr > mtd->size || instr->len > mtd->size - instr->addr)
 884                 return -EINVAL;
 885         if (!(mtd->flags & MTD_WRITEABLE))
 886                 return -EROFS;
 887         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
 888         if (!instr->len) {
 889                 instr->state = MTD_ERASE_DONE;
 890                 mtd_erase_callback(instr);
 891                 return 0;
 892         }
 893         return mtd->_erase(mtd, instr);
 894 }
 895 EXPORT_SYMBOL_GPL(mtd_erase);
 896
 897 #ifndef __UBOOT__
 898 /*
 899  * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
 900  */
 901 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
 902               void **virt, resource_size_t *phys)
 903 {
 904         *retlen = 0;
 905         *virt = NULL;
 906         if (phys)
 907                 *phys = 0;
 908         if (!mtd->_point)
 909                 return -EOPNOTSUPP;
 910         if (from < 0 || from > mtd->size || len > mtd->size - from)
 911                 return -EINVAL;
 912         if (!len)
 913                 return 0;
 914         return mtd->_point(mtd, from, len, retlen, virt, phys);
 915 }
 916 EXPORT_SYMBOL_GPL(mtd_point);
 917
 918 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
 919 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
 920 {
 921         if (!mtd->_point)
 922                 return -EOPNOTSUPP;
 923         if (from < 0 || from > mtd->size || len > mtd->size - from)
 924                 return -EINVAL;
 925         if (!len)
 926                 return 0;
 927         return mtd->_unpoint(mtd, from, len);
 928 }
 929 EXPORT_SYMBOL_GPL(mtd_unpoint);
 930 #endif
 931
 932 /*
 933  * Allow NOMMU mmap() to directly map the device (if not NULL)
 934  * - return the address to which the offset maps
 935  * - return -ENOSYS to indicate refusal to do the mapping
 936  */
 937 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
 938                                     unsigned long offset, unsigned long flags)
 939 {
 940         if (!mtd->_get_unmapped_area)
 941                 return -EOPNOTSUPP;
 942         if (offset > mtd->size || len > mtd->size - offset)
 943                 return -EINVAL;
 944         return mtd->_get_unmapped_area(mtd, len, offset, flags);
 945 }
 946 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
 947
 948 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
 949              u_char *buf)
 950 {
 951         int ret_code;
 952         *retlen = 0;
 953         if (from < 0 || from > mtd->size || len > mtd->size - from)
 954                 return -EINVAL;
 955         if (!len)
 956                 return 0;
 957
 958         /*
 959          * In the absence of an error, drivers return a non-negative integer
 960          * representing the maximum number of bitflips that were corrected on
 961          * any one ecc region (if applicable; zero otherwise).
 962          */
 963         if (mtd->_read) {
 964                 ret_code = mtd->_read(mtd, from, len, retlen, buf);
 965         } else if (mtd->_read_oob) {
 966                 struct mtd_oob_ops ops = {
 967                         .len = len,
 968                         .datbuf = buf,
 969                 };
 970
 971                 ret_code = mtd->_read_oob(mtd, from, &ops);
 972                 *retlen = ops.retlen;
 973         } else {
 974                 return -ENOTSUPP;
 975         }
 976
 977         if (unlikely(ret_code < 0))
 978                 return ret_code;
 979         if (mtd->ecc_strength == 0)
 980                 return 0;       /* device lacks ecc */
 981         return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
 982 }
 983 EXPORT_SYMBOL_GPL(mtd_read);
 984
 985 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
 986               const u_char *buf)
 987 {
 988         *retlen = 0;
 989         if (to < 0 || to > mtd->size || len > mtd->size - to)
 990                 return -EINVAL;
 991         if ((!mtd->_write && !mtd->_write_oob) ||
 992             !(mtd->flags & MTD_WRITEABLE))
 993                 return -EROFS;
 994         if (!len)
 995                 return 0;
 996
 997         if (!mtd->_write) {
 998                 struct mtd_oob_ops ops = {
 999                         .len = len,
1000                         .datbuf = (u8 *)buf,
1001                 };
1002                 int ret;
1003
1004                 ret = mtd->_write_oob(mtd, to, &ops);
1005                 *retlen = ops.retlen;
1006                 return ret;
1007         }
1008
1009         return mtd->_write(mtd, to, len, retlen, buf);
1010 }
1011 EXPORT_SYMBOL_GPL(mtd_write);
1012
1013 /*
1014  * In blackbox flight recorder like scenarios we want to make successful writes
1015  * in interrupt context. panic_write() is only intended to be called when its
1016  * known the kernel is about to panic and we need the write to succeed. Since
1017  * the kernel is not going to be running for much longer, this function can
1018  * break locks and delay to ensure the write succeeds (but not sleep).
1019  */
1020 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1021                     const u_char *buf)
1022 {
1023         *retlen = 0;
1024         if (!mtd->_panic_write)
1025                 return -EOPNOTSUPP;
1026         if (to < 0 || to > mtd->size || len > mtd->size - to)
1027                 return -EINVAL;
1028         if (!(mtd->flags & MTD_WRITEABLE))
1029                 return -EROFS;
1030         if (!len)
1031                 return 0;
1032         return mtd->_panic_write(mtd, to, len, retlen, buf);
1033 }
1034 EXPORT_SYMBOL_GPL(mtd_panic_write);
1035
1036 static int mtd_check_oob_ops(struct mtd_info *mtd, loff_t offs,
1037                              struct mtd_oob_ops *ops)
1038 {
1039         /*
1040          * Some users are setting ->datbuf or ->oobbuf to NULL, but are leaving
1041          * ->len or ->ooblen uninitialized. Force ->len and ->ooblen to 0 in
1042          *  this case.
1043          */
1044         if (!ops->datbuf)
1045                 ops->len = 0;
1046
1047         if (!ops->oobbuf)
1048                 ops->ooblen = 0;
1049
1050         if (offs < 0 || offs + ops->len > mtd->size)
1051                 return -EINVAL;
1052
1053         if (ops->ooblen) {
1054                 u64 maxooblen;
1055
1056                 if (ops->ooboffs >= mtd_oobavail(mtd, ops))
1057                         return -EINVAL;
1058
1059                 maxooblen = ((mtd_div_by_ws(mtd->size, mtd) -
1060                               mtd_div_by_ws(offs, mtd)) *
1061                              mtd_oobavail(mtd, ops)) - ops->ooboffs;
1062                 if (ops->ooblen > maxooblen)
1063                         return -EINVAL;
1064         }
1065
1066         return 0;
1067 }
1068
1069 int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
1070 {
1071         int ret_code;
1072         ops->retlen = ops->oobretlen = 0;
1073
1074         ret_code = mtd_check_oob_ops(mtd, from, ops);
1075         if (ret_code)
1076                 return ret_code;
1077
1078         /* Check the validity of a potential fallback on mtd->_read */
1079         if (!mtd->_read_oob && (!mtd->_read || ops->oobbuf))
1080                 return -EOPNOTSUPP;
1081
1082         if (mtd->_read_oob)
1083                 ret_code = mtd->_read_oob(mtd, from, ops);
1084         else
1085                 ret_code = mtd->_read(mtd, from, ops->len, &ops->retlen,
1086                                       ops->datbuf);
1087
1088         /*
1089          * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
1090          * similar to mtd->_read(), returning a non-negative integer
1091          * representing max bitflips. In other cases, mtd->_read_oob() may
1092          * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
1093          */
1094         if (unlikely(ret_code < 0))
1095                 return ret_code;
1096         if (mtd->ecc_strength == 0)
1097                 return 0;       /* device lacks ecc */
1098         return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1099 }
1100 EXPORT_SYMBOL_GPL(mtd_read_oob);
1101
1102 int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1103                                 struct mtd_oob_ops *ops)
1104 {
1105         int ret;
1106
1107         ops->retlen = ops->oobretlen = 0;
1108
1109         if (!(mtd->flags & MTD_WRITEABLE))
1110                 return -EROFS;
1111
1112         ret = mtd_check_oob_ops(mtd, to, ops);
1113         if (ret)
1114                 return ret;
1115
1116         /* Check the validity of a potential fallback on mtd->_write */
1117         if (!mtd->_write_oob && (!mtd->_write || ops->oobbuf))
1118                 return -EOPNOTSUPP;
1119
1120         if (mtd->_write_oob)
1121                 return mtd->_write_oob(mtd, to, ops);
1122         else
1123                 return mtd->_write(mtd, to, ops->len, &ops->retlen,
1124                                    ops->datbuf);
1125 }
1126 EXPORT_SYMBOL_GPL(mtd_write_oob);
1127
1128 /**
1129  * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
1130  * @mtd: MTD device structure
1131  * @section: ECC section. Depending on the layout you may have all the ECC
1132  *           bytes stored in a single contiguous section, or one section
1133  *           per ECC chunk (and sometime several sections for a single ECC
1134  *           ECC chunk)
1135  * @oobecc: OOB region struct filled with the appropriate ECC position
1136  *          information
1137  *
1138  * This function returns ECC section information in the OOB area. If you want
1139  * to get all the ECC bytes information, then you should call
1140  * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
1141  *
1142  * Returns zero on success, a negative error code otherwise.
1143  */
1144 int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1145                       struct mtd_oob_region *oobecc)
1146 {
1147         memset(oobecc, 0, sizeof(*oobecc));
1148
1149         if (!mtd || section < 0)
1150                 return -EINVAL;
1151
1152         if (!mtd->ooblayout || !mtd->ooblayout->ecc)
1153                 return -ENOTSUPP;
1154
1155         return mtd->ooblayout->ecc(mtd, section, oobecc);
1156 }
1157 EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1158
1159 /**
1160  * mtd_ooblayout_free - Get the OOB region definition of a specific free
1161  *                      section
1162  * @mtd: MTD device structure
1163  * @section: Free section you are interested in. Depending on the layout
1164  *           you may have all the free bytes stored in a single contiguous
1165  *           section, or one section per ECC chunk plus an extra section
1166  *           for the remaining bytes (or other funky layout).
1167  * @oobfree: OOB region struct filled with the appropriate free position
1168  *           information
1169  *
1170  * This function returns free bytes position in the OOB area. If you want
1171  * to get all the free bytes information, then you should call
1172  * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
1173  *
1174  * Returns zero on success, a negative error code otherwise.
1175  */
1176 int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1177                        struct mtd_oob_region *oobfree)
1178 {
1179         memset(oobfree, 0, sizeof(*oobfree));
1180
1181         if (!mtd || section < 0)
1182                 return -EINVAL;
1183
1184         if (!mtd->ooblayout || !mtd->ooblayout->free)
1185                 return -ENOTSUPP;
1186
1187         return mtd->ooblayout->free(mtd, section, oobfree);
1188 }
1189 EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1190
1191 /**
1192  * mtd_ooblayout_find_region - Find the region attached to a specific byte
1193  * @mtd: mtd info structure
1194  * @byte: the byte we are searching for
1195  * @sectionp: pointer where the section id will be stored
1196  * @oobregion: used to retrieve the ECC position
1197  * @iter: iterator function. Should be either mtd_ooblayout_free or
1198  *        mtd_ooblayout_ecc depending on the region type you're searching for
1199  *
1200  * This function returns the section id and oobregion information of a
1201  * specific byte. For example, say you want to know where the 4th ECC byte is
1202  * stored, you'll use:
1203  *
1204  * mtd_ooblayout_find_region(mtd, 3, &section, &oobregion, mtd_ooblayout_ecc);
1205  *
1206  * Returns zero on success, a negative error code otherwise.
1207  */
1208 static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
1209                                 int *sectionp, struct mtd_oob_region *oobregion,
1210                                 int (*iter)(struct mtd_info *,
1211                                             int section,
1212                                             struct mtd_oob_region *oobregion))
1213 {
1214         int pos = 0, ret, section = 0;
1215
1216         memset(oobregion, 0, sizeof(*oobregion));
1217
1218         while (1) {
1219                 ret = iter(mtd, section, oobregion);
1220                 if (ret)
1221                         return ret;
1222
1223                 if (pos + oobregion->length > byte)
1224                         break;
1225
1226                 pos += oobregion->length;
1227                 section++;
1228         }
1229
1230         /*
1231          * Adjust region info to make it start at the beginning at the
1232          * 'start' ECC byte.
1233          */
1234         oobregion->offset += byte - pos;
1235         oobregion->length -= byte - pos;
1236         *sectionp = section;
1237
1238         return 0;
1239 }
1240
1241 /**
1242  * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
1243  *                                ECC byte
1244  * @mtd: mtd info structure
1245  * @eccbyte: the byte we are searching for
1246  * @sectionp: pointer where the section id will be stored
1247  * @oobregion: OOB region information
1248  *
1249  * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
1250  * byte.
1251  *
1252  * Returns zero on success, a negative error code otherwise.
1253  */
1254 int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
1255                                  int *section,
1256                                  struct mtd_oob_region *oobregion)
1257 {
1258         return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
1259                                          mtd_ooblayout_ecc);
1260 }
1261 EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
1262
1263 /**
1264  * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
1265  * @mtd: mtd info structure
1266  * @buf: destination buffer to store OOB bytes
1267  * @oobbuf: OOB buffer
1268  * @start: first byte to retrieve
1269  * @nbytes: number of bytes to retrieve
1270  * @iter: section iterator
1271  *
1272  * Extract bytes attached to a specific category (ECC or free)
1273  * from the OOB buffer and copy them into buf.
1274  *
1275  * Returns zero on success, a negative error code otherwise.
1276  */
1277 static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
1278                                 const u8 *oobbuf, int start, int nbytes,
1279                                 int (*iter)(struct mtd_info *,
1280                                             int section,
1281                                             struct mtd_oob_region *oobregion))
1282 {
1283         struct mtd_oob_region oobregion;
1284         int section, ret;
1285
1286         ret = mtd_ooblayout_find_region(mtd, start, &section,
1287                                         &oobregion, iter);
1288
1289         while (!ret) {
1290                 int cnt;
1291
1292                 cnt = min_t(int, nbytes, oobregion.length);
1293                 memcpy(buf, oobbuf + oobregion.offset, cnt);
1294                 buf += cnt;
1295                 nbytes -= cnt;
1296
1297                 if (!nbytes)
1298                         break;
1299
1300                 ret = iter(mtd, ++section, &oobregion);
1301         }
1302
1303         return ret;
1304 }
1305
1306 /**
1307  * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
1308  * @mtd: mtd info structure
1309  * @buf: source buffer to get OOB bytes from
1310  * @oobbuf: OOB buffer
1311  * @start: first OOB byte to set
1312  * @nbytes: number of OOB bytes to set
1313  * @iter: section iterator
1314  *
1315  * Fill the OOB buffer with data provided in buf. The category (ECC or free)
1316  * is selected by passing the appropriate iterator.
1317  *
1318  * Returns zero on success, a negative error code otherwise.
1319  */
1320 static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
1321                                 u8 *oobbuf, int start, int nbytes,
1322                                 int (*iter)(struct mtd_info *,
1323                                             int section,
1324                                             struct mtd_oob_region *oobregion))
1325 {
1326         struct mtd_oob_region oobregion;
1327         int section, ret;
1328
1329         ret = mtd_ooblayout_find_region(mtd, start, &section,
1330                                         &oobregion, iter);
1331
1332         while (!ret) {
1333                 int cnt;
1334
1335                 cnt = min_t(int, nbytes, oobregion.length);
1336                 memcpy(oobbuf + oobregion.offset, buf, cnt);
1337                 buf += cnt;
1338                 nbytes -= cnt;
1339
1340                 if (!nbytes)
1341                         break;
1342
1343                 ret = iter(mtd, ++section, &oobregion);
1344         }
1345
1346         return ret;
1347 }
1348
1349 /**
1350  * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
1351  * @mtd: mtd info structure
1352  * @iter: category iterator
1353  *
1354  * Count the number of bytes in a given category.
1355  *
1356  * Returns a positive value on success, a negative error code otherwise.
1357  */
1358 static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
1359                                 int (*iter)(struct mtd_info *,
1360                                             int section,
1361                                             struct mtd_oob_region *oobregion))
1362 {
1363         struct mtd_oob_region oobregion;
1364         int section = 0, ret, nbytes = 0;
1365
1366         while (1) {
1367                 ret = iter(mtd, section++, &oobregion);
1368                 if (ret) {
1369                         if (ret == -ERANGE)
1370                                 ret = nbytes;
1371                         break;
1372                 }
1373
1374                 nbytes += oobregion.length;
1375         }
1376
1377         return ret;
1378 }
1379
1380 /**
1381  * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
1382  * @mtd: mtd info structure
1383  * @eccbuf: destination buffer to store ECC bytes
1384  * @oobbuf: OOB buffer
1385  * @start: first ECC byte to retrieve
1386  * @nbytes: number of ECC bytes to retrieve
1387  *
1388  * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
1389  *
1390  * Returns zero on success, a negative error code otherwise.
1391  */
1392 int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
1393                                const u8 *oobbuf, int start, int nbytes)
1394 {
1395         return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1396                                        mtd_ooblayout_ecc);
1397 }
1398 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
1399
1400 /**
1401  * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
1402  * @mtd: mtd info structure
1403  * @eccbuf: source buffer to get ECC bytes from
1404  * @oobbuf: OOB buffer
1405  * @start: first ECC byte to set
1406  * @nbytes: number of ECC bytes to set
1407  *
1408  * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
1409  *
1410  * Returns zero on success, a negative error code otherwise.
1411  */
1412 int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
1413                                u8 *oobbuf, int start, int nbytes)
1414 {
1415         return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1416                                        mtd_ooblayout_ecc);
1417 }
1418 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
1419
1420 /**
1421  * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
1422  * @mtd: mtd info structure
1423  * @databuf: destination buffer to store ECC bytes
1424  * @oobbuf: OOB buffer
1425  * @start: first ECC byte to retrieve
1426  * @nbytes: number of ECC bytes to retrieve
1427  *
1428  * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1429  *
1430  * Returns zero on success, a negative error code otherwise.
1431  */
1432 int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
1433                                 const u8 *oobbuf, int start, int nbytes)
1434 {
1435         return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
1436                                        mtd_ooblayout_free);
1437 }
1438 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
1439
1440 /**
1441  * mtd_ooblayout_get_eccbytes - set data bytes into the oob buffer
1442  * @mtd: mtd info structure
1443  * @eccbuf: source buffer to get data bytes from
1444  * @oobbuf: OOB buffer
1445  * @start: first ECC byte to set
1446  * @nbytes: number of ECC bytes to set
1447  *
1448  * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1449  *
1450  * Returns zero on success, a negative error code otherwise.
1451  */
1452 int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
1453                                 u8 *oobbuf, int start, int nbytes)
1454 {
1455         return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
1456                                        mtd_ooblayout_free);
1457 }
1458 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
1459
1460 /**
1461  * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
1462  * @mtd: mtd info structure
1463  *
1464  * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
1465  *
1466  * Returns zero on success, a negative error code otherwise.
1467  */
1468 int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
1469 {
1470         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
1471 }
1472 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
1473
1474 /**
1475  * mtd_ooblayout_count_freebytes - count the number of ECC bytes in OOB
1476  * @mtd: mtd info structure
1477  *
1478  * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
1479  *
1480  * Returns zero on success, a negative error code otherwise.
1481  */
1482 int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
1483 {
1484         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
1485 }
1486 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
1487
1488 /*
1489  * Method to access the protection register area, present in some flash
1490  * devices. The user data is one time programmable but the factory data is read
1491  * only.
1492  */
1493 int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1494                            struct otp_info *buf)
1495 {
1496         if (!mtd->_get_fact_prot_info)
1497                 return -EOPNOTSUPP;
1498         if (!len)
1499                 return 0;
1500         return mtd->_get_fact_prot_info(mtd, len, retlen, buf);
1501 }
1502 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
1503
1504 int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1505                            size_t *retlen, u_char *buf)
1506 {
1507         *retlen = 0;
1508         if (!mtd->_read_fact_prot_reg)
1509                 return -EOPNOTSUPP;
1510         if (!len)
1511                 return 0;
1512         return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);
1513 }
1514 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
1515
1516 int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1517                            struct otp_info *buf)
1518 {
1519         if (!mtd->_get_user_prot_info)
1520                 return -EOPNOTSUPP;
1521         if (!len)
1522                 return 0;
1523         return mtd->_get_user_prot_info(mtd, len, retlen, buf);
1524 }
1525 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
1526
1527 int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1528                            size_t *retlen, u_char *buf)
1529 {
1530         *retlen = 0;
1531         if (!mtd->_read_user_prot_reg)
1532                 return -EOPNOTSUPP;
1533         if (!len)
1534                 return 0;
1535         return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);
1536 }
1537 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
1538
1539 int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
1540                             size_t *retlen, u_char *buf)
1541 {
1542         int ret;
1543
1544         *retlen = 0;
1545         if (!mtd->_write_user_prot_reg)
1546                 return -EOPNOTSUPP;
1547         if (!len)
1548                 return 0;
1549         ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);
1550         if (ret)
1551                 return ret;
1552
1553         /*
1554          * If no data could be written at all, we are out of memory and
1555          * must return -ENOSPC.
1556          */
1557         return (*retlen) ? 0 : -ENOSPC;
1558 }
1559 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);
1560
1561 int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
1562 {
1563         if (!mtd->_lock_user_prot_reg)
1564                 return -EOPNOTSUPP;
1565         if (!len)
1566                 return 0;
1567         return mtd->_lock_user_prot_reg(mtd, from, len);
1568 }
1569 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
1570
1571 /* Chip-supported device locking */
1572 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1573 {
1574         if (!mtd->_lock)
1575                 return -EOPNOTSUPP;
1576         if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs)
1577                 return -EINVAL;
1578         if (!len)
1579                 return 0;
1580         return mtd->_lock(mtd, ofs, len);
1581 }
1582 EXPORT_SYMBOL_GPL(mtd_lock);
1583
1584 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1585 {
1586         if (!mtd->_unlock)
1587                 return -EOPNOTSUPP;
1588         if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs)
1589                 return -EINVAL;
1590         if (!len)
1591                 return 0;
1592         return mtd->_unlock(mtd, ofs, len);
1593 }
1594 EXPORT_SYMBOL_GPL(mtd_unlock);
1595
1596 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1597 {
1598         if (!mtd->_is_locked)
1599                 return -EOPNOTSUPP;
1600         if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs)
1601                 return -EINVAL;
1602         if (!len)
1603                 return 0;
1604         return mtd->_is_locked(mtd, ofs, len);
1605 }
1606 EXPORT_SYMBOL_GPL(mtd_is_locked);
1607
1608 int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1609 {
1610         if (ofs < 0 || ofs > mtd->size)
1611                 return -EINVAL;
1612         if (!mtd->_block_isreserved)
1613                 return 0;
1614         return mtd->_block_isreserved(mtd, ofs);
1615 }
1616 EXPORT_SYMBOL_GPL(mtd_block_isreserved);
1617
1618 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
1619 {
1620         if (ofs < 0 || ofs > mtd->size)
1621                 return -EINVAL;
1622         if (!mtd->_block_isbad)
1623                 return 0;
1624         return mtd->_block_isbad(mtd, ofs);
1625 }
1626 EXPORT_SYMBOL_GPL(mtd_block_isbad);
1627
1628 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
1629 {
1630         if (!mtd->_block_markbad)
1631                 return -EOPNOTSUPP;
1632         if (ofs < 0 || ofs > mtd->size)
1633                 return -EINVAL;
1634         if (!(mtd->flags & MTD_WRITEABLE))
1635                 return -EROFS;
1636         return mtd->_block_markbad(mtd, ofs);
1637 }
1638 EXPORT_SYMBOL_GPL(mtd_block_markbad);
1639
1640 #ifndef __UBOOT__
1641 /*
1642  * default_mtd_writev - the default writev method
1643  * @mtd: mtd device description object pointer
1644  * @vecs: the vectors to write
1645  * @count: count of vectors in @vecs
1646  * @to: the MTD device offset to write to
1647  * @retlen: on exit contains the count of bytes written to the MTD device.
1648  *
1649  * This function returns zero in case of success and a negative error code in
1650  * case of failure.
1651  */
1652 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1653                               unsigned long count, loff_t to, size_t *retlen)
1654 {
1655         unsigned long i;
1656         size_t totlen = 0, thislen;
1657         int ret = 0;
1658
1659         for (i = 0; i < count; i++) {
1660                 if (!vecs[i].iov_len)
1661                         continue;
1662                 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
1663                                 vecs[i].iov_base);
1664                 totlen += thislen;
1665                 if (ret || thislen != vecs[i].iov_len)
1666                         break;
1667                 to += vecs[i].iov_len;
1668         }
1669         *retlen = totlen;
1670         return ret;
1671 }
1672
1673 /*
1674  * mtd_writev - the vector-based MTD write method
1675  * @mtd: mtd device description object pointer
1676  * @vecs: the vectors to write
1677  * @count: count of vectors in @vecs
1678  * @to: the MTD device offset to write to
1679  * @retlen: on exit contains the count of bytes written to the MTD device.
1680  *
1681  * This function returns zero in case of success and a negative error code in
1682  * case of failure.
1683  */
1684 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1685                unsigned long count, loff_t to, size_t *retlen)
1686 {
1687         *retlen = 0;
1688         if (!(mtd->flags & MTD_WRITEABLE))
1689                 return -EROFS;
1690         if (!mtd->_writev)
1691                 return default_mtd_writev(mtd, vecs, count, to, retlen);
1692         return mtd->_writev(mtd, vecs, count, to, retlen);
1693 }
1694 EXPORT_SYMBOL_GPL(mtd_writev);
1695
1696 /**
1697  * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
1698  * @mtd: mtd device description object pointer
1699  * @size: a pointer to the ideal or maximum size of the allocation, points
1700  *        to the actual allocation size on success.
1701  *
1702  * This routine attempts to allocate a contiguous kernel buffer up to
1703  * the specified size, backing off the size of the request exponentially
1704  * until the request succeeds or until the allocation size falls below
1705  * the system page size. This attempts to make sure it does not adversely
1706  * impact system performance, so when allocating more than one page, we
1707  * ask the memory allocator to avoid re-trying, swapping, writing back
1708  * or performing I/O.
1709  *
1710  * Note, this function also makes sure that the allocated buffer is aligned to
1711  * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
1712  *
1713  * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
1714  * to handle smaller (i.e. degraded) buffer allocations under low- or
1715  * fragmented-memory situations where such reduced allocations, from a
1716  * requested ideal, are allowed.
1717  *
1718  * Returns a pointer to the allocated buffer on success; otherwise, NULL.
1719  */
1720 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
1721 {
1722         gfp_t flags = __GFP_NOWARN | __GFP_WAIT |
1723                        __GFP_NORETRY | __GFP_NO_KSWAPD;
1724         size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
1725         void *kbuf;
1726
1727         *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
1728
1729         while (*size > min_alloc) {
1730                 kbuf = kmalloc(*size, flags);
1731                 if (kbuf)
1732                         return kbuf;
1733
1734                 *size >>= 1;
1735                 *size = ALIGN(*size, mtd->writesize);
1736         }
1737
1738         /*
1739          * For the last resort allocation allow 'kmalloc()' to do all sorts of
1740          * things (write-back, dropping caches, etc) by using GFP_KERNEL.
1741          */
1742         return kmalloc(*size, GFP_KERNEL);
1743 }
1744 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
1745 #endif
1746
1747 #ifdef CONFIG_PROC_FS
1748
1749 /*====================================================================*/
1750 /* Support for /proc/mtd */
1751
1752 static int mtd_proc_show(struct seq_file *m, void *v)
1753 {
1754         struct mtd_info *mtd;
1755
1756         seq_puts(m, "dev:    size   erasesize  name\n");
1757         mutex_lock(&mtd_table_mutex);
1758         mtd_for_each_device(mtd) {
1759                 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
1760                            mtd->index, (unsigned long long)mtd->size,
1761                            mtd->erasesize, mtd->name);
1762         }
1763         mutex_unlock(&mtd_table_mutex);
1764         return 0;
1765 }
1766
1767 static int mtd_proc_open(struct inode *inode, struct file *file)
1768 {
1769         return single_open(file, mtd_proc_show, NULL);
1770 }
1771
1772 static const struct file_operations mtd_proc_ops = {
1773         .open           = mtd_proc_open,
1774         .read           = seq_read,
1775         .llseek         = seq_lseek,
1776         .release        = single_release,
1777 };
1778 #endif /* CONFIG_PROC_FS */
1779
1780 /*====================================================================*/
1781 /* Init code */
1782
1783 #ifndef __UBOOT__
1784 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name)
1785 {
1786         int ret;
1787
1788         ret = bdi_init(bdi);
1789         if (!ret)
1790                 ret = bdi_register(bdi, NULL, "%s", name);
1791
1792         if (ret)
1793                 bdi_destroy(bdi);
1794
1795         return ret;
1796 }
1797
1798 static struct proc_dir_entry *proc_mtd;
1799
1800 static int __init init_mtd(void)
1801 {
1802         int ret;
1803
1804         ret = class_register(&mtd_class);
1805         if (ret)
1806                 goto err_reg;
1807
1808         ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap");
1809         if (ret)
1810                 goto err_bdi1;
1811
1812         ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap");
1813         if (ret)
1814                 goto err_bdi2;
1815
1816         ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap");
1817         if (ret)
1818                 goto err_bdi3;
1819
1820         proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
1821
1822         ret = init_mtdchar();
1823         if (ret)
1824                 goto out_procfs;
1825
1826         return 0;
1827
1828 out_procfs:
1829         if (proc_mtd)
1830                 remove_proc_entry("mtd", NULL);
1831 err_bdi3:
1832         bdi_destroy(&mtd_bdi_ro_mappable);
1833 err_bdi2:
1834         bdi_destroy(&mtd_bdi_unmappable);
1835 err_bdi1:
1836         class_unregister(&mtd_class);
1837 err_reg:
1838         pr_err("Error registering mtd class or bdi: %d\n", ret);
1839         return ret;
1840 }
1841
1842 static void __exit cleanup_mtd(void)
1843 {
1844         cleanup_mtdchar();
1845         if (proc_mtd)
1846                 remove_proc_entry("mtd", NULL);
1847         class_unregister(&mtd_class);
1848         bdi_destroy(&mtd_bdi_unmappable);
1849         bdi_destroy(&mtd_bdi_ro_mappable);
1850         bdi_destroy(&mtd_bdi_rw_mappable);
1851 }
1852
1853 module_init(init_mtd);
1854 module_exit(cleanup_mtd);
1855 #endif
1856
1857 MODULE_LICENSE("GPL");
1858 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1859 MODULE_DESCRIPTION("Core MTD registration and access routines");