drivers/mtd/mtdcore.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   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 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/seq_file.h>
  14 #include <linux/string.h>
  15 #include <linux/timer.h>
  16 #include <linux/major.h>
  17 #include <linux/fs.h>
  18 #include <linux/err.h>
  19 #include <linux/ioctl.h>
  20 #include <linux/init.h>
  21 #include <linux/of.h>
  22 #include <linux/proc_fs.h>
  23 #include <linux/idr.h>
  24 #include <linux/backing-dev.h>
  25 #include <linux/gfp.h>
  26 #include <linux/slab.h>
  27 #include <linux/reboot.h>
  28 #include <linux/leds.h>
  29 #include <linux/debugfs.h>
  30 #include <linux/nvmem-provider.h>
  31 #include <linux/root_dev.h>
  32
  33 #include <linux/mtd/mtd.h>
  34 #include <linux/mtd/partitions.h>
  35
  36 #include "mtdcore.h"
  37
  38 struct backing_dev_info *mtd_bdi;
  39
  40 #ifdef CONFIG_PM_SLEEP
  41
  42 static int mtd_cls_suspend(struct device *dev)
  43 {
  44         struct mtd_info *mtd = dev_get_drvdata(dev);
  45
  46         return mtd ? mtd_suspend(mtd) : 0;
  47 }
  48
  49 static int mtd_cls_resume(struct device *dev)
  50 {
  51         struct mtd_info *mtd = dev_get_drvdata(dev);
  52
  53         if (mtd)
  54                 mtd_resume(mtd);
  55         return 0;
  56 }
  57
  58 static SIMPLE_DEV_PM_OPS(mtd_cls_pm_ops, mtd_cls_suspend, mtd_cls_resume);
  59 #define MTD_CLS_PM_OPS (&mtd_cls_pm_ops)
  60 #else
  61 #define MTD_CLS_PM_OPS NULL
  62 #endif
  63
  64 static struct class mtd_class = {
  65         .name = "mtd",
  66         .owner = THIS_MODULE,
  67         .pm = MTD_CLS_PM_OPS,
  68 };
  69
  70 static DEFINE_IDR(mtd_idr);
  71
  72 /* These are exported solely for the purpose of mtd_blkdevs.c. You
  73    should not use them for _anything_ else */
  74 DEFINE_MUTEX(mtd_table_mutex);
  75 EXPORT_SYMBOL_GPL(mtd_table_mutex);
  76
  77 struct mtd_info *__mtd_next_device(int i)
  78 {
  79         return idr_get_next(&mtd_idr, &i);
  80 }
  81 EXPORT_SYMBOL_GPL(__mtd_next_device);
  82
  83 static LIST_HEAD(mtd_notifiers);
  84
  85
  86 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
  87
  88 /* REVISIT once MTD uses the driver model better, whoever allocates
  89  * the mtd_info will probably want to use the release() hook...
  90  */
  91 static void mtd_release(struct device *dev)
  92 {
  93         struct mtd_info *mtd = dev_get_drvdata(dev);
  94         dev_t index = MTD_DEVT(mtd->index);
  95
  96         /* remove /dev/mtdXro node */
  97         device_destroy(&mtd_class, index + 1);
  98 }
  99
 100 #define MTD_DEVICE_ATTR_RO(name) \
 101 static DEVICE_ATTR(name, 0444, mtd_##name##_show, NULL)
 102
 103 #define MTD_DEVICE_ATTR_RW(name) \
 104 static DEVICE_ATTR(name, 0644, mtd_##name##_show, mtd_##name##_store)
 105
 106 static ssize_t mtd_type_show(struct device *dev,
 107                 struct device_attribute *attr, char *buf)
 108 {
 109         struct mtd_info *mtd = dev_get_drvdata(dev);
 110         char *type;
 111
 112         switch (mtd->type) {
 113         case MTD_ABSENT:
 114                 type = "absent";
 115                 break;
 116         case MTD_RAM:
 117                 type = "ram";
 118                 break;
 119         case MTD_ROM:
 120                 type = "rom";
 121                 break;
 122         case MTD_NORFLASH:
 123                 type = "nor";
 124                 break;
 125         case MTD_NANDFLASH:
 126                 type = "nand";
 127                 break;
 128         case MTD_DATAFLASH:
 129                 type = "dataflash";
 130                 break;
 131         case MTD_UBIVOLUME:
 132                 type = "ubi";
 133                 break;
 134         case MTD_MLCNANDFLASH:
 135                 type = "mlc-nand";
 136                 break;
 137         default:
 138                 type = "unknown";
 139         }
 140
 141         return sysfs_emit(buf, "%s\n", type);
 142 }
 143 MTD_DEVICE_ATTR_RO(type);
 144
 145 static ssize_t mtd_flags_show(struct device *dev,
 146                 struct device_attribute *attr, char *buf)
 147 {
 148         struct mtd_info *mtd = dev_get_drvdata(dev);
 149
 150         return sysfs_emit(buf, "0x%lx\n", (unsigned long)mtd->flags);
 151 }
 152 MTD_DEVICE_ATTR_RO(flags);
 153
 154 static ssize_t mtd_size_show(struct device *dev,
 155                 struct device_attribute *attr, char *buf)
 156 {
 157         struct mtd_info *mtd = dev_get_drvdata(dev);
 158
 159         return sysfs_emit(buf, "%llu\n", (unsigned long long)mtd->size);
 160 }
 161 MTD_DEVICE_ATTR_RO(size);
 162
 163 static ssize_t mtd_erasesize_show(struct device *dev,
 164                 struct device_attribute *attr, char *buf)
 165 {
 166         struct mtd_info *mtd = dev_get_drvdata(dev);
 167
 168         return sysfs_emit(buf, "%lu\n", (unsigned long)mtd->erasesize);
 169 }
 170 MTD_DEVICE_ATTR_RO(erasesize);
 171
 172 static ssize_t mtd_writesize_show(struct device *dev,
 173                 struct device_attribute *attr, char *buf)
 174 {
 175         struct mtd_info *mtd = dev_get_drvdata(dev);
 176
 177         return sysfs_emit(buf, "%lu\n", (unsigned long)mtd->writesize);
 178 }
 179 MTD_DEVICE_ATTR_RO(writesize);
 180
 181 static ssize_t mtd_subpagesize_show(struct device *dev,
 182                 struct device_attribute *attr, char *buf)
 183 {
 184         struct mtd_info *mtd = dev_get_drvdata(dev);
 185         unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
 186
 187         return sysfs_emit(buf, "%u\n", subpagesize);
 188 }
 189 MTD_DEVICE_ATTR_RO(subpagesize);
 190
 191 static ssize_t mtd_oobsize_show(struct device *dev,
 192                 struct device_attribute *attr, char *buf)
 193 {
 194         struct mtd_info *mtd = dev_get_drvdata(dev);
 195
 196         return sysfs_emit(buf, "%lu\n", (unsigned long)mtd->oobsize);
 197 }
 198 MTD_DEVICE_ATTR_RO(oobsize);
 199
 200 static ssize_t mtd_oobavail_show(struct device *dev,
 201                                  struct device_attribute *attr, char *buf)
 202 {
 203         struct mtd_info *mtd = dev_get_drvdata(dev);
 204
 205         return sysfs_emit(buf, "%u\n", mtd->oobavail);
 206 }
 207 MTD_DEVICE_ATTR_RO(oobavail);
 208
 209 static ssize_t mtd_numeraseregions_show(struct device *dev,
 210                 struct device_attribute *attr, char *buf)
 211 {
 212         struct mtd_info *mtd = dev_get_drvdata(dev);
 213
 214         return sysfs_emit(buf, "%u\n", mtd->numeraseregions);
 215 }
 216 MTD_DEVICE_ATTR_RO(numeraseregions);
 217
 218 static ssize_t mtd_name_show(struct device *dev,
 219                 struct device_attribute *attr, char *buf)
 220 {
 221         struct mtd_info *mtd = dev_get_drvdata(dev);
 222
 223         return sysfs_emit(buf, "%s\n", mtd->name);
 224 }
 225 MTD_DEVICE_ATTR_RO(name);
 226
 227 static ssize_t mtd_ecc_strength_show(struct device *dev,
 228                                      struct device_attribute *attr, char *buf)
 229 {
 230         struct mtd_info *mtd = dev_get_drvdata(dev);
 231
 232         return sysfs_emit(buf, "%u\n", mtd->ecc_strength);
 233 }
 234 MTD_DEVICE_ATTR_RO(ecc_strength);
 235
 236 static ssize_t mtd_bitflip_threshold_show(struct device *dev,
 237                                           struct device_attribute *attr,
 238                                           char *buf)
 239 {
 240         struct mtd_info *mtd = dev_get_drvdata(dev);
 241
 242         return sysfs_emit(buf, "%u\n", mtd->bitflip_threshold);
 243 }
 244
 245 static ssize_t mtd_bitflip_threshold_store(struct device *dev,
 246                                            struct device_attribute *attr,
 247                                            const char *buf, size_t count)
 248 {
 249         struct mtd_info *mtd = dev_get_drvdata(dev);
 250         unsigned int bitflip_threshold;
 251         int retval;
 252
 253         retval = kstrtouint(buf, 0, &bitflip_threshold);
 254         if (retval)
 255                 return retval;
 256
 257         mtd->bitflip_threshold = bitflip_threshold;
 258         return count;
 259 }
 260 MTD_DEVICE_ATTR_RW(bitflip_threshold);
 261
 262 static ssize_t mtd_ecc_step_size_show(struct device *dev,
 263                 struct device_attribute *attr, char *buf)
 264 {
 265         struct mtd_info *mtd = dev_get_drvdata(dev);
 266
 267         return sysfs_emit(buf, "%u\n", mtd->ecc_step_size);
 268
 269 }
 270 MTD_DEVICE_ATTR_RO(ecc_step_size);
 271
 272 static ssize_t mtd_corrected_bits_show(struct device *dev,
 273                 struct device_attribute *attr, char *buf)
 274 {
 275         struct mtd_info *mtd = dev_get_drvdata(dev);
 276         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 277
 278         return sysfs_emit(buf, "%u\n", ecc_stats->corrected);
 279 }
 280 MTD_DEVICE_ATTR_RO(corrected_bits);     /* ecc stats corrected */
 281
 282 static ssize_t mtd_ecc_failures_show(struct device *dev,
 283                 struct device_attribute *attr, char *buf)
 284 {
 285         struct mtd_info *mtd = dev_get_drvdata(dev);
 286         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 287
 288         return sysfs_emit(buf, "%u\n", ecc_stats->failed);
 289 }
 290 MTD_DEVICE_ATTR_RO(ecc_failures);       /* ecc stats errors */
 291
 292 static ssize_t mtd_bad_blocks_show(struct device *dev,
 293                 struct device_attribute *attr, char *buf)
 294 {
 295         struct mtd_info *mtd = dev_get_drvdata(dev);
 296         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 297
 298         return sysfs_emit(buf, "%u\n", ecc_stats->badblocks);
 299 }
 300 MTD_DEVICE_ATTR_RO(bad_blocks);
 301
 302 static ssize_t mtd_bbt_blocks_show(struct device *dev,
 303                 struct device_attribute *attr, char *buf)
 304 {
 305         struct mtd_info *mtd = dev_get_drvdata(dev);
 306         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 307
 308         return sysfs_emit(buf, "%u\n", ecc_stats->bbtblocks);
 309 }
 310 MTD_DEVICE_ATTR_RO(bbt_blocks);
 311
 312 static struct attribute *mtd_attrs[] = {
 313         &dev_attr_type.attr,
 314         &dev_attr_flags.attr,
 315         &dev_attr_size.attr,
 316         &dev_attr_erasesize.attr,
 317         &dev_attr_writesize.attr,
 318         &dev_attr_subpagesize.attr,
 319         &dev_attr_oobsize.attr,
 320         &dev_attr_oobavail.attr,
 321         &dev_attr_numeraseregions.attr,
 322         &dev_attr_name.attr,
 323         &dev_attr_ecc_strength.attr,
 324         &dev_attr_ecc_step_size.attr,
 325         &dev_attr_corrected_bits.attr,
 326         &dev_attr_ecc_failures.attr,
 327         &dev_attr_bad_blocks.attr,
 328         &dev_attr_bbt_blocks.attr,
 329         &dev_attr_bitflip_threshold.attr,
 330         NULL,
 331 };
 332 ATTRIBUTE_GROUPS(mtd);
 333
 334 static const struct device_type mtd_devtype = {
 335         .name           = "mtd",
 336         .groups         = mtd_groups,
 337         .release        = mtd_release,
 338 };
 339
 340 static bool mtd_expert_analysis_mode;
 341
 342 #ifdef CONFIG_DEBUG_FS
 343 bool mtd_check_expert_analysis_mode(void)
 344 {
 345         const char *mtd_expert_analysis_warning =
 346                 "Bad block checks have been entirely disabled.\n"
 347                 "This is only reserved for post-mortem forensics and debug purposes.\n"
 348                 "Never enable this mode if you do not know what you are doing!\n";
 349
 350         return WARN_ONCE(mtd_expert_analysis_mode, mtd_expert_analysis_warning);
 351 }
 352 EXPORT_SYMBOL_GPL(mtd_check_expert_analysis_mode);
 353 #endif
 354
 355 static struct dentry *dfs_dir_mtd;
 356
 357 static void mtd_debugfs_populate(struct mtd_info *mtd)
 358 {
 359         struct device *dev = &mtd->dev;
 360
 361         if (IS_ERR_OR_NULL(dfs_dir_mtd))
 362                 return;
 363
 364         mtd->dbg.dfs_dir = debugfs_create_dir(dev_name(dev), dfs_dir_mtd);
 365 }
 366
 367 #ifndef CONFIG_MMU
 368 unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
 369 {
 370         switch (mtd->type) {
 371         case MTD_RAM:
 372                 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
 373                         NOMMU_MAP_READ | NOMMU_MAP_WRITE;
 374         case MTD_ROM:
 375                 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
 376                         NOMMU_MAP_READ;
 377         default:
 378                 return NOMMU_MAP_COPY;
 379         }
 380 }
 381 EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
 382 #endif
 383
 384 static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
 385                                void *cmd)
 386 {
 387         struct mtd_info *mtd;
 388
 389         mtd = container_of(n, struct mtd_info, reboot_notifier);
 390         mtd->_reboot(mtd);
 391
 392         return NOTIFY_DONE;
 393 }
 394
 395 /**
 396  * mtd_wunit_to_pairing_info - get pairing information of a wunit
 397  * @mtd: pointer to new MTD device info structure
 398  * @wunit: write unit we are interested in
 399  * @info: returned pairing information
 400  *
 401  * Retrieve pairing information associated to the wunit.
 402  * This is mainly useful when dealing with MLC/TLC NANDs where pages can be
 403  * paired together, and where programming a page may influence the page it is
 404  * paired with.
 405  * The notion of page is replaced by the term wunit (write-unit) to stay
 406  * consistent with the ->writesize field.
 407  *
 408  * The @wunit argument can be extracted from an absolute offset using
 409  * mtd_offset_to_wunit(). @info is filled with the pairing information attached
 410  * to @wunit.
 411  *
 412  * From the pairing info the MTD user can find all the wunits paired with
 413  * @wunit using the following loop:
 414  *
 415  * for (i = 0; i < mtd_pairing_groups(mtd); i++) {
 416  *      info.pair = i;
 417  *      mtd_pairing_info_to_wunit(mtd, &info);
 418  *      ...
 419  * }
 420  */
 421 int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
 422                               struct mtd_pairing_info *info)
 423 {
 424         struct mtd_info *master = mtd_get_master(mtd);
 425         int npairs = mtd_wunit_per_eb(master) / mtd_pairing_groups(master);
 426
 427         if (wunit < 0 || wunit >= npairs)
 428                 return -EINVAL;
 429
 430         if (master->pairing && master->pairing->get_info)
 431                 return master->pairing->get_info(master, wunit, info);
 432
 433         info->group = 0;
 434         info->pair = wunit;
 435
 436         return 0;
 437 }
 438 EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info);
 439
 440 /**
 441  * mtd_pairing_info_to_wunit - get wunit from pairing information
 442  * @mtd: pointer to new MTD device info structure
 443  * @info: pairing information struct
 444  *
 445  * Returns a positive number representing the wunit associated to the info
 446  * struct, or a negative error code.
 447  *
 448  * This is the reverse of mtd_wunit_to_pairing_info(), and can help one to
 449  * iterate over all wunits of a given pair (see mtd_wunit_to_pairing_info()
 450  * doc).
 451  *
 452  * It can also be used to only program the first page of each pair (i.e.
 453  * page attached to group 0), which allows one to use an MLC NAND in
 454  * software-emulated SLC mode:
 455  *
 456  * info.group = 0;
 457  * npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
 458  * for (info.pair = 0; info.pair < npairs; info.pair++) {
 459  *      wunit = mtd_pairing_info_to_wunit(mtd, &info);
 460  *      mtd_write(mtd, mtd_wunit_to_offset(mtd, blkoffs, wunit),
 461  *                mtd->writesize, &retlen, buf + (i * mtd->writesize));
 462  * }
 463  */
 464 int mtd_pairing_info_to_wunit(struct mtd_info *mtd,
 465                               const struct mtd_pairing_info *info)
 466 {
 467         struct mtd_info *master = mtd_get_master(mtd);
 468         int ngroups = mtd_pairing_groups(master);
 469         int npairs = mtd_wunit_per_eb(master) / ngroups;
 470
 471         if (!info || info->pair < 0 || info->pair >= npairs ||
 472             info->group < 0 || info->group >= ngroups)
 473                 return -EINVAL;
 474
 475         if (master->pairing && master->pairing->get_wunit)
 476                 return mtd->pairing->get_wunit(master, info);
 477
 478         return info->pair;
 479 }
 480 EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit);
 481
 482 /**
 483  * mtd_pairing_groups - get the number of pairing groups
 484  * @mtd: pointer to new MTD device info structure
 485  *
 486  * Returns the number of pairing groups.
 487  *
 488  * This number is usually equal to the number of bits exposed by a single
 489  * cell, and can be used in conjunction with mtd_pairing_info_to_wunit()
 490  * to iterate over all pages of a given pair.
 491  */
 492 int mtd_pairing_groups(struct mtd_info *mtd)
 493 {
 494         struct mtd_info *master = mtd_get_master(mtd);
 495
 496         if (!master->pairing || !master->pairing->ngroups)
 497                 return 1;
 498
 499         return master->pairing->ngroups;
 500 }
 501 EXPORT_SYMBOL_GPL(mtd_pairing_groups);
 502
 503 static int mtd_nvmem_reg_read(void *priv, unsigned int offset,
 504                               void *val, size_t bytes)
 505 {
 506         struct mtd_info *mtd = priv;
 507         size_t retlen;
 508         int err;
 509
 510         err = mtd_read(mtd, offset, bytes, &retlen, val);
 511         if (err && err != -EUCLEAN)
 512                 return err;
 513
 514         return retlen == bytes ? 0 : -EIO;
 515 }
 516
 517 static int mtd_nvmem_add(struct mtd_info *mtd)
 518 {
 519         struct device_node *node = mtd_get_of_node(mtd);
 520         struct nvmem_config config = {};
 521
 522         config.id = NVMEM_DEVID_NONE;
 523         config.dev = &mtd->dev;
 524         config.name = dev_name(&mtd->dev);
 525         config.owner = THIS_MODULE;
 526         config.reg_read = mtd_nvmem_reg_read;
 527         config.size = mtd->size;
 528         config.word_size = 1;
 529         config.stride = 1;
 530         config.read_only = true;
 531         config.root_only = true;
 532         config.ignore_wp = true;
 533         config.no_of_node = !of_device_is_compatible(node, "nvmem-cells");
 534         config.priv = mtd;
 535
 536         mtd->nvmem = nvmem_register(&config);
 537         if (IS_ERR(mtd->nvmem)) {
 538                 /* Just ignore if there is no NVMEM support in the kernel */
 539                 if (PTR_ERR(mtd->nvmem) == -EOPNOTSUPP)
 540                         mtd->nvmem = NULL;
 541                 else
 542                         return dev_err_probe(&mtd->dev, PTR_ERR(mtd->nvmem),
 543                                              "Failed to register NVMEM device\n");
 544         }
 545
 546         return 0;
 547 }
 548
 549 static void mtd_check_of_node(struct mtd_info *mtd)
 550 {
 551         struct device_node *partitions, *parent_dn, *mtd_dn = NULL;
 552         const char *pname, *prefix = "partition-";
 553         int plen, mtd_name_len, offset, prefix_len;
 554
 555         /* Check if MTD already has a device node */
 556         if (mtd_get_of_node(mtd))
 557                 return;
 558
 559         if (!mtd_is_partition(mtd))
 560                 return;
 561
 562         parent_dn = of_node_get(mtd_get_of_node(mtd->parent));
 563         if (!parent_dn)
 564                 return;
 565
 566         if (mtd_is_partition(mtd->parent))
 567                 partitions = of_node_get(parent_dn);
 568         else
 569                 partitions = of_get_child_by_name(parent_dn, "partitions");
 570         if (!partitions)
 571                 goto exit_parent;
 572
 573         prefix_len = strlen(prefix);
 574         mtd_name_len = strlen(mtd->name);
 575
 576         /* Search if a partition is defined with the same name */
 577         for_each_child_of_node(partitions, mtd_dn) {
 578                 /* Skip partition with no/wrong prefix */
 579                 if (!of_node_name_prefix(mtd_dn, prefix))
 580                         continue;
 581
 582                 /* Label have priority. Check that first */
 583                 if (!of_property_read_string(mtd_dn, "label", &pname)) {
 584                         offset = 0;
 585                 } else {
 586                         pname = mtd_dn->name;
 587                         offset = prefix_len;
 588                 }
 589
 590                 plen = strlen(pname) - offset;
 591                 if (plen == mtd_name_len &&
 592                     !strncmp(mtd->name, pname + offset, plen)) {
 593                         mtd_set_of_node(mtd, mtd_dn);
 594                         break;
 595                 }
 596         }
 597
 598         of_node_put(partitions);
 599 exit_parent:
 600         of_node_put(parent_dn);
 601 }
 602
 603 /**
 604  *      add_mtd_device - register an MTD device
 605  *      @mtd: pointer to new MTD device info structure
 606  *
 607  *      Add a device to the list of MTD devices present in the system, and
 608  *      notify each currently active MTD 'user' of its arrival. Returns
 609  *      zero on success or non-zero on failure.
 610  */
 611
 612 int add_mtd_device(struct mtd_info *mtd)
 613 {
 614         struct device_node *np = mtd_get_of_node(mtd);
 615         struct mtd_info *master = mtd_get_master(mtd);
 616         struct mtd_notifier *not;
 617         int i, error, ofidx;
 618
 619         /*
 620          * May occur, for instance, on buggy drivers which call
 621          * mtd_device_parse_register() multiple times on the same master MTD,
 622          * especially with CONFIG_MTD_PARTITIONED_MASTER=y.
 623          */
 624         if (WARN_ONCE(mtd->dev.type, "MTD already registered\n"))
 625                 return -EEXIST;
 626
 627         BUG_ON(mtd->writesize == 0);
 628
 629         /*
 630          * MTD drivers should implement ->_{write,read}() or
 631          * ->_{write,read}_oob(), but not both.
 632          */
 633         if (WARN_ON((mtd->_write && mtd->_write_oob) ||
 634                     (mtd->_read && mtd->_read_oob)))
 635                 return -EINVAL;
 636
 637         if (WARN_ON((!mtd->erasesize || !master->_erase) &&
 638                     !(mtd->flags & MTD_NO_ERASE)))
 639                 return -EINVAL;
 640
 641         /*
 642          * MTD_SLC_ON_MLC_EMULATION can only be set on partitions, when the
 643          * master is an MLC NAND and has a proper pairing scheme defined.
 644          * We also reject masters that implement ->_writev() for now, because
 645          * NAND controller drivers don't implement this hook, and adding the
 646          * SLC -> MLC address/length conversion to this path is useless if we
 647          * don't have a user.
 648          */
 649         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION &&
 650             (!mtd_is_partition(mtd) || master->type != MTD_MLCNANDFLASH ||
 651              !master->pairing || master->_writev))
 652                 return -EINVAL;
 653
 654         mutex_lock(&mtd_table_mutex);
 655
 656         ofidx = -1;
 657         if (np)
 658                 ofidx = of_alias_get_id(np, "mtd");
 659         if (ofidx >= 0)
 660                 i = idr_alloc(&mtd_idr, mtd, ofidx, ofidx + 1, GFP_KERNEL);
 661         else
 662                 i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL);
 663         if (i < 0) {
 664                 error = i;
 665                 goto fail_locked;
 666         }
 667
 668         mtd->index = i;
 669         mtd->usecount = 0;
 670
 671         /* default value if not set by driver */
 672         if (mtd->bitflip_threshold == 0)
 673                 mtd->bitflip_threshold = mtd->ecc_strength;
 674
 675         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
 676                 int ngroups = mtd_pairing_groups(master);
 677
 678                 mtd->erasesize /= ngroups;
 679                 mtd->size = (u64)mtd_div_by_eb(mtd->size, master) *
 680                             mtd->erasesize;
 681         }
 682
 683         if (is_power_of_2(mtd->erasesize))
 684                 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
 685         else
 686                 mtd->erasesize_shift = 0;
 687
 688         if (is_power_of_2(mtd->writesize))
 689                 mtd->writesize_shift = ffs(mtd->writesize) - 1;
 690         else
 691                 mtd->writesize_shift = 0;
 692
 693         mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
 694         mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
 695
 696         /* Some chips always power up locked. Unlock them now */
 697         if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) {
 698                 error = mtd_unlock(mtd, 0, mtd->size);
 699                 if (error && error != -EOPNOTSUPP)
 700                         printk(KERN_WARNING
 701                                "%s: unlock failed, writes may not work\n",
 702                                mtd->name);
 703                 /* Ignore unlock failures? */
 704                 error = 0;
 705         }
 706
 707         /* Caller should have set dev.parent to match the
 708          * physical device, if appropriate.
 709          */
 710         mtd->dev.type = &mtd_devtype;
 711         mtd->dev.class = &mtd_class;
 712         mtd->dev.devt = MTD_DEVT(i);
 713         dev_set_name(&mtd->dev, "mtd%d", i);
 714         dev_set_drvdata(&mtd->dev, mtd);
 715         mtd_check_of_node(mtd);
 716         of_node_get(mtd_get_of_node(mtd));
 717         error = device_register(&mtd->dev);
 718         if (error) {
 719                 put_device(&mtd->dev);
 720                 goto fail_added;
 721         }
 722
 723         /* Add the nvmem provider */
 724         error = mtd_nvmem_add(mtd);
 725         if (error)
 726                 goto fail_nvmem_add;
 727
 728         mtd_debugfs_populate(mtd);
 729
 730         device_create(&mtd_class, mtd->dev.parent, MTD_DEVT(i) + 1, NULL,
 731                       "mtd%dro", i);
 732
 733         pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
 734         /* No need to get a refcount on the module containing
 735            the notifier, since we hold the mtd_table_mutex */
 736         list_for_each_entry(not, &mtd_notifiers, list)
 737                 not->add(mtd);
 738
 739         mutex_unlock(&mtd_table_mutex);
 740
 741         if (of_property_read_bool(mtd_get_of_node(mtd), "linux,rootfs")) {
 742                 if (IS_BUILTIN(CONFIG_MTD)) {
 743                         pr_info("mtd: setting mtd%d (%s) as root device\n", mtd->index, mtd->name);
 744                         ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, mtd->index);
 745                 } else {
 746                         pr_warn("mtd: can't set mtd%d (%s) as root device - mtd must be builtin\n",
 747                                 mtd->index, mtd->name);
 748                 }
 749         }
 750
 751         /* We _know_ we aren't being removed, because
 752            our caller is still holding us here. So none
 753            of this try_ nonsense, and no bitching about it
 754            either. :) */
 755         __module_get(THIS_MODULE);
 756         return 0;
 757
 758 fail_nvmem_add:
 759         device_unregister(&mtd->dev);
 760 fail_added:
 761         of_node_put(mtd_get_of_node(mtd));
 762         idr_remove(&mtd_idr, i);
 763 fail_locked:
 764         mutex_unlock(&mtd_table_mutex);
 765         return error;
 766 }
 767
 768 /**
 769  *      del_mtd_device - unregister an MTD device
 770  *      @mtd: pointer to MTD device info structure
 771  *
 772  *      Remove a device from the list of MTD devices present in the system,
 773  *      and notify each currently active MTD 'user' of its departure.
 774  *      Returns zero on success or 1 on failure, which currently will happen
 775  *      if the requested device does not appear to be present in the list.
 776  */
 777
 778 int del_mtd_device(struct mtd_info *mtd)
 779 {
 780         int ret;
 781         struct mtd_notifier *not;
 782         struct device_node *mtd_of_node;
 783
 784         mutex_lock(&mtd_table_mutex);
 785
 786         if (idr_find(&mtd_idr, mtd->index) != mtd) {
 787                 ret = -ENODEV;
 788                 goto out_error;
 789         }
 790
 791         /* No need to get a refcount on the module containing
 792                 the notifier, since we hold the mtd_table_mutex */
 793         list_for_each_entry(not, &mtd_notifiers, list)
 794                 not->remove(mtd);
 795
 796         if (mtd->usecount) {
 797                 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
 798                        mtd->index, mtd->name, mtd->usecount);
 799                 ret = -EBUSY;
 800         } else {
 801                 mtd_of_node = mtd_get_of_node(mtd);
 802                 debugfs_remove_recursive(mtd->dbg.dfs_dir);
 803
 804                 /* Try to remove the NVMEM provider */
 805                 nvmem_unregister(mtd->nvmem);
 806
 807                 device_unregister(&mtd->dev);
 808
 809                 /* Clear dev so mtd can be safely re-registered later if desired */
 810                 memset(&mtd->dev, 0, sizeof(mtd->dev));
 811
 812                 idr_remove(&mtd_idr, mtd->index);
 813                 of_node_put(mtd_of_node);
 814
 815                 module_put(THIS_MODULE);
 816                 ret = 0;
 817         }
 818
 819 out_error:
 820         mutex_unlock(&mtd_table_mutex);
 821         return ret;
 822 }
 823
 824 /*
 825  * Set a few defaults based on the parent devices, if not provided by the
 826  * driver
 827  */
 828 static void mtd_set_dev_defaults(struct mtd_info *mtd)
 829 {
 830         if (mtd->dev.parent) {
 831                 if (!mtd->owner && mtd->dev.parent->driver)
 832                         mtd->owner = mtd->dev.parent->driver->owner;
 833                 if (!mtd->name)
 834                         mtd->name = dev_name(mtd->dev.parent);
 835         } else {
 836                 pr_debug("mtd device won't show a device symlink in sysfs\n");
 837         }
 838
 839         INIT_LIST_HEAD(&mtd->partitions);
 840         mutex_init(&mtd->master.partitions_lock);
 841         mutex_init(&mtd->master.chrdev_lock);
 842 }
 843
 844 static ssize_t mtd_otp_size(struct mtd_info *mtd, bool is_user)
 845 {
 846         struct otp_info *info;
 847         ssize_t size = 0;
 848         unsigned int i;
 849         size_t retlen;
 850         int ret;
 851
 852         info = kmalloc(PAGE_SIZE, GFP_KERNEL);
 853         if (!info)
 854                 return -ENOMEM;
 855
 856         if (is_user)
 857                 ret = mtd_get_user_prot_info(mtd, PAGE_SIZE, &retlen, info);
 858         else
 859                 ret = mtd_get_fact_prot_info(mtd, PAGE_SIZE, &retlen, info);
 860         if (ret)
 861                 goto err;
 862
 863         for (i = 0; i < retlen / sizeof(*info); i++)
 864                 size += info[i].length;
 865
 866         kfree(info);
 867         return size;
 868
 869 err:
 870         kfree(info);
 871
 872         /* ENODATA means there is no OTP region. */
 873         return ret == -ENODATA ? 0 : ret;
 874 }
 875
 876 static struct nvmem_device *mtd_otp_nvmem_register(struct mtd_info *mtd,
 877                                                    const char *compatible,
 878                                                    int size,
 879                                                    nvmem_reg_read_t reg_read)
 880 {
 881         struct nvmem_device *nvmem = NULL;
 882         struct nvmem_config config = {};
 883         struct device_node *np;
 884
 885         /* DT binding is optional */
 886         np = of_get_compatible_child(mtd->dev.of_node, compatible);
 887
 888         /* OTP nvmem will be registered on the physical device */
 889         config.dev = mtd->dev.parent;
 890         config.name = compatible;
 891         config.id = NVMEM_DEVID_AUTO;
 892         config.owner = THIS_MODULE;
 893         config.type = NVMEM_TYPE_OTP;
 894         config.root_only = true;
 895         config.ignore_wp = true;
 896         config.reg_read = reg_read;
 897         config.size = size;
 898         config.of_node = np;
 899         config.priv = mtd;
 900
 901         nvmem = nvmem_register(&config);
 902         /* Just ignore if there is no NVMEM support in the kernel */
 903         if (IS_ERR(nvmem) && PTR_ERR(nvmem) == -EOPNOTSUPP)
 904                 nvmem = NULL;
 905
 906         of_node_put(np);
 907
 908         return nvmem;
 909 }
 910
 911 static int mtd_nvmem_user_otp_reg_read(void *priv, unsigned int offset,
 912                                        void *val, size_t bytes)
 913 {
 914         struct mtd_info *mtd = priv;
 915         size_t retlen;
 916         int ret;
 917
 918         ret = mtd_read_user_prot_reg(mtd, offset, bytes, &retlen, val);
 919         if (ret)
 920                 return ret;
 921
 922         return retlen == bytes ? 0 : -EIO;
 923 }
 924
 925 static int mtd_nvmem_fact_otp_reg_read(void *priv, unsigned int offset,
 926                                        void *val, size_t bytes)
 927 {
 928         struct mtd_info *mtd = priv;
 929         size_t retlen;
 930         int ret;
 931
 932         ret = mtd_read_fact_prot_reg(mtd, offset, bytes, &retlen, val);
 933         if (ret)
 934                 return ret;
 935
 936         return retlen == bytes ? 0 : -EIO;
 937 }
 938
 939 static int mtd_otp_nvmem_add(struct mtd_info *mtd)
 940 {
 941         struct device *dev = mtd->dev.parent;
 942         struct nvmem_device *nvmem;
 943         ssize_t size;
 944         int err;
 945
 946         if (mtd->_get_user_prot_info && mtd->_read_user_prot_reg) {
 947                 size = mtd_otp_size(mtd, true);
 948                 if (size < 0)
 949                         return size;
 950
 951                 if (size > 0) {
 952                         nvmem = mtd_otp_nvmem_register(mtd, "user-otp", size,
 953                                                        mtd_nvmem_user_otp_reg_read);
 954                         if (IS_ERR(nvmem)) {
 955                                 err = PTR_ERR(nvmem);
 956                                 goto err;
 957                         }
 958                         mtd->otp_user_nvmem = nvmem;
 959                 }
 960         }
 961
 962         if (mtd->_get_fact_prot_info && mtd->_read_fact_prot_reg) {
 963                 size = mtd_otp_size(mtd, false);
 964                 if (size < 0) {
 965                         err = size;
 966                         goto err;
 967                 }
 968
 969                 if (size > 0) {
 970                         nvmem = mtd_otp_nvmem_register(mtd, "factory-otp", size,
 971                                                        mtd_nvmem_fact_otp_reg_read);
 972                         if (IS_ERR(nvmem)) {
 973                                 err = PTR_ERR(nvmem);
 974                                 goto err;
 975                         }
 976                         mtd->otp_factory_nvmem = nvmem;
 977                 }
 978         }
 979
 980         return 0;
 981
 982 err:
 983         nvmem_unregister(mtd->otp_user_nvmem);
 984         return dev_err_probe(dev, err, "Failed to register OTP NVMEM device\n");
 985 }
 986
 987 /**
 988  * mtd_device_parse_register - parse partitions and register an MTD device.
 989  *
 990  * @mtd: the MTD device to register
 991  * @types: the list of MTD partition probes to try, see
 992  *         'parse_mtd_partitions()' for more information
 993  * @parser_data: MTD partition parser-specific data
 994  * @parts: fallback partition information to register, if parsing fails;
 995  *         only valid if %nr_parts > %0
 996  * @nr_parts: the number of partitions in parts, if zero then the full
 997  *            MTD device is registered if no partition info is found
 998  *
 999  * This function aggregates MTD partitions parsing (done by
1000  * 'parse_mtd_partitions()') and MTD device and partitions registering. It
1001  * basically follows the most common pattern found in many MTD drivers:
1002  *
1003  * * If the MTD_PARTITIONED_MASTER option is set, then the device as a whole is
1004  *   registered first.
1005  * * Then It tries to probe partitions on MTD device @mtd using parsers
1006  *   specified in @types (if @types is %NULL, then the default list of parsers
1007  *   is used, see 'parse_mtd_partitions()' for more information). If none are
1008  *   found this functions tries to fallback to information specified in
1009  *   @parts/@nr_parts.
1010  * * If no partitions were found this function just registers the MTD device
1011  *   @mtd and exits.
1012  *
1013  * Returns zero in case of success and a negative error code in case of failure.
1014  */
1015 int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
1016                               struct mtd_part_parser_data *parser_data,
1017                               const struct mtd_partition *parts,
1018                               int nr_parts)
1019 {
1020         int ret;
1021
1022         mtd_set_dev_defaults(mtd);
1023
1024         ret = mtd_otp_nvmem_add(mtd);
1025         if (ret)
1026                 goto out;
1027
1028         if (IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
1029                 ret = add_mtd_device(mtd);
1030                 if (ret)
1031                         goto out;
1032         }
1033
1034         /* Prefer parsed partitions over driver-provided fallback */
1035         ret = parse_mtd_partitions(mtd, types, parser_data);
1036         if (ret == -EPROBE_DEFER)
1037                 goto out;
1038
1039         if (ret > 0)
1040                 ret = 0;
1041         else if (nr_parts)
1042                 ret = add_mtd_partitions(mtd, parts, nr_parts);
1043         else if (!device_is_registered(&mtd->dev))
1044                 ret = add_mtd_device(mtd);
1045         else
1046                 ret = 0;
1047
1048         if (ret)
1049                 goto out;
1050
1051         /*
1052          * FIXME: some drivers unfortunately call this function more than once.
1053          * So we have to check if we've already assigned the reboot notifier.
1054          *
1055          * Generally, we can make multiple calls work for most cases, but it
1056          * does cause problems with parse_mtd_partitions() above (e.g.,
1057          * cmdlineparts will register partitions more than once).
1058          */
1059         WARN_ONCE(mtd->_reboot && mtd->reboot_notifier.notifier_call,
1060                   "MTD already registered\n");
1061         if (mtd->_reboot && !mtd->reboot_notifier.notifier_call) {
1062                 mtd->reboot_notifier.notifier_call = mtd_reboot_notifier;
1063                 register_reboot_notifier(&mtd->reboot_notifier);
1064         }
1065
1066 out:
1067         if (ret) {
1068                 nvmem_unregister(mtd->otp_user_nvmem);
1069                 nvmem_unregister(mtd->otp_factory_nvmem);
1070         }
1071
1072         if (ret && device_is_registered(&mtd->dev))
1073                 del_mtd_device(mtd);
1074
1075         return ret;
1076 }
1077 EXPORT_SYMBOL_GPL(mtd_device_parse_register);
1078
1079 /**
1080  * mtd_device_unregister - unregister an existing MTD device.
1081  *
1082  * @master: the MTD device to unregister.  This will unregister both the master
1083  *          and any partitions if registered.
1084  */
1085 int mtd_device_unregister(struct mtd_info *master)
1086 {
1087         int err;
1088
1089         if (master->_reboot) {
1090                 unregister_reboot_notifier(&master->reboot_notifier);
1091                 memset(&master->reboot_notifier, 0, sizeof(master->reboot_notifier));
1092         }
1093
1094         nvmem_unregister(master->otp_user_nvmem);
1095         nvmem_unregister(master->otp_factory_nvmem);
1096
1097         err = del_mtd_partitions(master);
1098         if (err)
1099                 return err;
1100
1101         if (!device_is_registered(&master->dev))
1102                 return 0;
1103
1104         return del_mtd_device(master);
1105 }
1106 EXPORT_SYMBOL_GPL(mtd_device_unregister);
1107
1108 /**
1109  *      register_mtd_user - register a 'user' of MTD devices.
1110  *      @new: pointer to notifier info structure
1111  *
1112  *      Registers a pair of callbacks function to be called upon addition
1113  *      or removal of MTD devices. Causes the 'add' callback to be immediately
1114  *      invoked for each MTD device currently present in the system.
1115  */
1116 void register_mtd_user (struct mtd_notifier *new)
1117 {
1118         struct mtd_info *mtd;
1119
1120         mutex_lock(&mtd_table_mutex);
1121
1122         list_add(&new->list, &mtd_notifiers);
1123
1124         __module_get(THIS_MODULE);
1125
1126         mtd_for_each_device(mtd)
1127                 new->add(mtd);
1128
1129         mutex_unlock(&mtd_table_mutex);
1130 }
1131 EXPORT_SYMBOL_GPL(register_mtd_user);
1132
1133 /**
1134  *      unregister_mtd_user - unregister a 'user' of MTD devices.
1135  *      @old: pointer to notifier info structure
1136  *
1137  *      Removes a callback function pair from the list of 'users' to be
1138  *      notified upon addition or removal of MTD devices. Causes the
1139  *      'remove' callback to be immediately invoked for each MTD device
1140  *      currently present in the system.
1141  */
1142 int unregister_mtd_user (struct mtd_notifier *old)
1143 {
1144         struct mtd_info *mtd;
1145
1146         mutex_lock(&mtd_table_mutex);
1147
1148         module_put(THIS_MODULE);
1149
1150         mtd_for_each_device(mtd)
1151                 old->remove(mtd);
1152
1153         list_del(&old->list);
1154         mutex_unlock(&mtd_table_mutex);
1155         return 0;
1156 }
1157 EXPORT_SYMBOL_GPL(unregister_mtd_user);
1158
1159 /**
1160  *      get_mtd_device - obtain a validated handle for an MTD device
1161  *      @mtd: last known address of the required MTD device
1162  *      @num: internal device number of the required MTD device
1163  *
1164  *      Given a number and NULL address, return the num'th entry in the device
1165  *      table, if any.  Given an address and num == -1, search the device table
1166  *      for a device with that address and return if it's still present. Given
1167  *      both, return the num'th driver only if its address matches. Return
1168  *      error code if not.
1169  */
1170 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
1171 {
1172         struct mtd_info *ret = NULL, *other;
1173         int err = -ENODEV;
1174
1175         mutex_lock(&mtd_table_mutex);
1176
1177         if (num == -1) {
1178                 mtd_for_each_device(other) {
1179                         if (other == mtd) {
1180                                 ret = mtd;
1181                                 break;
1182                         }
1183                 }
1184         } else if (num >= 0) {
1185                 ret = idr_find(&mtd_idr, num);
1186                 if (mtd && mtd != ret)
1187                         ret = NULL;
1188         }
1189
1190         if (!ret) {
1191                 ret = ERR_PTR(err);
1192                 goto out;
1193         }
1194
1195         err = __get_mtd_device(ret);
1196         if (err)
1197                 ret = ERR_PTR(err);
1198 out:
1199         mutex_unlock(&mtd_table_mutex);
1200         return ret;
1201 }
1202 EXPORT_SYMBOL_GPL(get_mtd_device);
1203
1204
1205 int __get_mtd_device(struct mtd_info *mtd)
1206 {
1207         struct mtd_info *master = mtd_get_master(mtd);
1208         int err;
1209
1210         if (!try_module_get(master->owner))
1211                 return -ENODEV;
1212
1213         if (master->_get_device) {
1214                 err = master->_get_device(mtd);
1215
1216                 if (err) {
1217                         module_put(master->owner);
1218                         return err;
1219                 }
1220         }
1221
1222         master->usecount++;
1223
1224         while (mtd->parent) {
1225                 mtd->usecount++;
1226                 mtd = mtd->parent;
1227         }
1228
1229         return 0;
1230 }
1231 EXPORT_SYMBOL_GPL(__get_mtd_device);
1232
1233 /**
1234  * of_get_mtd_device_by_node - obtain an MTD device associated with a given node
1235  *
1236  * @np: device tree node
1237  */
1238 struct mtd_info *of_get_mtd_device_by_node(struct device_node *np)
1239 {
1240         struct mtd_info *mtd = NULL;
1241         struct mtd_info *tmp;
1242         int err;
1243
1244         mutex_lock(&mtd_table_mutex);
1245
1246         err = -EPROBE_DEFER;
1247         mtd_for_each_device(tmp) {
1248                 if (mtd_get_of_node(tmp) == np) {
1249                         mtd = tmp;
1250                         err = __get_mtd_device(mtd);
1251                         break;
1252                 }
1253         }
1254
1255         mutex_unlock(&mtd_table_mutex);
1256
1257         return err ? ERR_PTR(err) : mtd;
1258 }
1259 EXPORT_SYMBOL_GPL(of_get_mtd_device_by_node);
1260
1261 /**
1262  *      get_mtd_device_nm - obtain a validated handle for an MTD device by
1263  *      device name
1264  *      @name: MTD device name to open
1265  *
1266  *      This function returns MTD device description structure in case of
1267  *      success and an error code in case of failure.
1268  */
1269 struct mtd_info *get_mtd_device_nm(const char *name)
1270 {
1271         int err = -ENODEV;
1272         struct mtd_info *mtd = NULL, *other;
1273
1274         mutex_lock(&mtd_table_mutex);
1275
1276         mtd_for_each_device(other) {
1277                 if (!strcmp(name, other->name)) {
1278                         mtd = other;
1279                         break;
1280                 }
1281         }
1282
1283         if (!mtd)
1284                 goto out_unlock;
1285
1286         err = __get_mtd_device(mtd);
1287         if (err)
1288                 goto out_unlock;
1289
1290         mutex_unlock(&mtd_table_mutex);
1291         return mtd;
1292
1293 out_unlock:
1294         mutex_unlock(&mtd_table_mutex);
1295         return ERR_PTR(err);
1296 }
1297 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
1298
1299 void put_mtd_device(struct mtd_info *mtd)
1300 {
1301         mutex_lock(&mtd_table_mutex);
1302         __put_mtd_device(mtd);
1303         mutex_unlock(&mtd_table_mutex);
1304
1305 }
1306 EXPORT_SYMBOL_GPL(put_mtd_device);
1307
1308 void __put_mtd_device(struct mtd_info *mtd)
1309 {
1310         struct mtd_info *master = mtd_get_master(mtd);
1311
1312         while (mtd->parent) {
1313                 --mtd->usecount;
1314                 BUG_ON(mtd->usecount < 0);
1315                 mtd = mtd->parent;
1316         }
1317
1318         master->usecount--;
1319
1320         if (master->_put_device)
1321                 master->_put_device(master);
1322
1323         module_put(master->owner);
1324 }
1325 EXPORT_SYMBOL_GPL(__put_mtd_device);
1326
1327 /*
1328  * Erase is an synchronous operation. Device drivers are epected to return a
1329  * negative error code if the operation failed and update instr->fail_addr
1330  * to point the portion that was not properly erased.
1331  */
1332 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
1333 {
1334         struct mtd_info *master = mtd_get_master(mtd);
1335         u64 mst_ofs = mtd_get_master_ofs(mtd, 0);
1336         struct erase_info adjinstr;
1337         int ret;
1338
1339         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
1340         adjinstr = *instr;
1341
1342         if (!mtd->erasesize || !master->_erase)
1343                 return -ENOTSUPP;
1344
1345         if (instr->addr >= mtd->size || instr->len > mtd->size - instr->addr)
1346                 return -EINVAL;
1347         if (!(mtd->flags & MTD_WRITEABLE))
1348                 return -EROFS;
1349
1350         if (!instr->len)
1351                 return 0;
1352
1353         ledtrig_mtd_activity();
1354
1355         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1356                 adjinstr.addr = (loff_t)mtd_div_by_eb(instr->addr, mtd) *
1357                                 master->erasesize;
1358                 adjinstr.len = ((u64)mtd_div_by_eb(instr->addr + instr->len, mtd) *
1359                                 master->erasesize) -
1360                                adjinstr.addr;
1361         }
1362
1363         adjinstr.addr += mst_ofs;
1364
1365         ret = master->_erase(master, &adjinstr);
1366
1367         if (adjinstr.fail_addr != MTD_FAIL_ADDR_UNKNOWN) {
1368                 instr->fail_addr = adjinstr.fail_addr - mst_ofs;
1369                 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1370                         instr->fail_addr = mtd_div_by_eb(instr->fail_addr,
1371                                                          master);
1372                         instr->fail_addr *= mtd->erasesize;
1373                 }
1374         }
1375
1376         return ret;
1377 }
1378 EXPORT_SYMBOL_GPL(mtd_erase);
1379
1380 /*
1381  * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
1382  */
1383 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1384               void **virt, resource_size_t *phys)
1385 {
1386         struct mtd_info *master = mtd_get_master(mtd);
1387
1388         *retlen = 0;
1389         *virt = NULL;
1390         if (phys)
1391                 *phys = 0;
1392         if (!master->_point)
1393                 return -EOPNOTSUPP;
1394         if (from < 0 || from >= mtd->size || len > mtd->size - from)
1395                 return -EINVAL;
1396         if (!len)
1397                 return 0;
1398
1399         from = mtd_get_master_ofs(mtd, from);
1400         return master->_point(master, from, len, retlen, virt, phys);
1401 }
1402 EXPORT_SYMBOL_GPL(mtd_point);
1403
1404 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
1405 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1406 {
1407         struct mtd_info *master = mtd_get_master(mtd);
1408
1409         if (!master->_unpoint)
1410                 return -EOPNOTSUPP;
1411         if (from < 0 || from >= mtd->size || len > mtd->size - from)
1412                 return -EINVAL;
1413         if (!len)
1414                 return 0;
1415         return master->_unpoint(master, mtd_get_master_ofs(mtd, from), len);
1416 }
1417 EXPORT_SYMBOL_GPL(mtd_unpoint);
1418
1419 /*
1420  * Allow NOMMU mmap() to directly map the device (if not NULL)
1421  * - return the address to which the offset maps
1422  * - return -ENOSYS to indicate refusal to do the mapping
1423  */
1424 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
1425                                     unsigned long offset, unsigned long flags)
1426 {
1427         size_t retlen;
1428         void *virt;
1429         int ret;
1430
1431         ret = mtd_point(mtd, offset, len, &retlen, &virt, NULL);
1432         if (ret)
1433                 return ret;
1434         if (retlen != len) {
1435                 mtd_unpoint(mtd, offset, retlen);
1436                 return -ENOSYS;
1437         }
1438         return (unsigned long)virt;
1439 }
1440 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
1441
1442 static void mtd_update_ecc_stats(struct mtd_info *mtd, struct mtd_info *master,
1443                                  const struct mtd_ecc_stats *old_stats)
1444 {
1445         struct mtd_ecc_stats diff;
1446
1447         if (master == mtd)
1448                 return;
1449
1450         diff = master->ecc_stats;
1451         diff.failed -= old_stats->failed;
1452         diff.corrected -= old_stats->corrected;
1453
1454         while (mtd->parent) {
1455                 mtd->ecc_stats.failed += diff.failed;
1456                 mtd->ecc_stats.corrected += diff.corrected;
1457                 mtd = mtd->parent;
1458         }
1459 }
1460
1461 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1462              u_char *buf)
1463 {
1464         struct mtd_oob_ops ops = {
1465                 .len = len,
1466                 .datbuf = buf,
1467         };
1468         int ret;
1469
1470         ret = mtd_read_oob(mtd, from, &ops);
1471         *retlen = ops.retlen;
1472
1473         return ret;
1474 }
1475 EXPORT_SYMBOL_GPL(mtd_read);
1476
1477 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1478               const u_char *buf)
1479 {
1480         struct mtd_oob_ops ops = {
1481                 .len = len,
1482                 .datbuf = (u8 *)buf,
1483         };
1484         int ret;
1485
1486         ret = mtd_write_oob(mtd, to, &ops);
1487         *retlen = ops.retlen;
1488
1489         return ret;
1490 }
1491 EXPORT_SYMBOL_GPL(mtd_write);
1492
1493 /*
1494  * In blackbox flight recorder like scenarios we want to make successful writes
1495  * in interrupt context. panic_write() is only intended to be called when its
1496  * known the kernel is about to panic and we need the write to succeed. Since
1497  * the kernel is not going to be running for much longer, this function can
1498  * break locks and delay to ensure the write succeeds (but not sleep).
1499  */
1500 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1501                     const u_char *buf)
1502 {
1503         struct mtd_info *master = mtd_get_master(mtd);
1504
1505         *retlen = 0;
1506         if (!master->_panic_write)
1507                 return -EOPNOTSUPP;
1508         if (to < 0 || to >= mtd->size || len > mtd->size - to)
1509                 return -EINVAL;
1510         if (!(mtd->flags & MTD_WRITEABLE))
1511                 return -EROFS;
1512         if (!len)
1513                 return 0;
1514         if (!master->oops_panic_write)
1515                 master->oops_panic_write = true;
1516
1517         return master->_panic_write(master, mtd_get_master_ofs(mtd, to), len,
1518                                     retlen, buf);
1519 }
1520 EXPORT_SYMBOL_GPL(mtd_panic_write);
1521
1522 static int mtd_check_oob_ops(struct mtd_info *mtd, loff_t offs,
1523                              struct mtd_oob_ops *ops)
1524 {
1525         /*
1526          * Some users are setting ->datbuf or ->oobbuf to NULL, but are leaving
1527          * ->len or ->ooblen uninitialized. Force ->len and ->ooblen to 0 in
1528          *  this case.
1529          */
1530         if (!ops->datbuf)
1531                 ops->len = 0;
1532
1533         if (!ops->oobbuf)
1534                 ops->ooblen = 0;
1535
1536         if (offs < 0 || offs + ops->len > mtd->size)
1537                 return -EINVAL;
1538
1539         if (ops->ooblen) {
1540                 size_t maxooblen;
1541
1542                 if (ops->ooboffs >= mtd_oobavail(mtd, ops))
1543                         return -EINVAL;
1544
1545                 maxooblen = ((size_t)(mtd_div_by_ws(mtd->size, mtd) -
1546                                       mtd_div_by_ws(offs, mtd)) *
1547                              mtd_oobavail(mtd, ops)) - ops->ooboffs;
1548                 if (ops->ooblen > maxooblen)
1549                         return -EINVAL;
1550         }
1551
1552         return 0;
1553 }
1554
1555 static int mtd_read_oob_std(struct mtd_info *mtd, loff_t from,
1556                             struct mtd_oob_ops *ops)
1557 {
1558         struct mtd_info *master = mtd_get_master(mtd);
1559         int ret;
1560
1561         from = mtd_get_master_ofs(mtd, from);
1562         if (master->_read_oob)
1563                 ret = master->_read_oob(master, from, ops);
1564         else
1565                 ret = master->_read(master, from, ops->len, &ops->retlen,
1566                                     ops->datbuf);
1567
1568         return ret;
1569 }
1570
1571 static int mtd_write_oob_std(struct mtd_info *mtd, loff_t to,
1572                              struct mtd_oob_ops *ops)
1573 {
1574         struct mtd_info *master = mtd_get_master(mtd);
1575         int ret;
1576
1577         to = mtd_get_master_ofs(mtd, to);
1578         if (master->_write_oob)
1579                 ret = master->_write_oob(master, to, ops);
1580         else
1581                 ret = master->_write(master, to, ops->len, &ops->retlen,
1582                                      ops->datbuf);
1583
1584         return ret;
1585 }
1586
1587 static int mtd_io_emulated_slc(struct mtd_info *mtd, loff_t start, bool read,
1588                                struct mtd_oob_ops *ops)
1589 {
1590         struct mtd_info *master = mtd_get_master(mtd);
1591         int ngroups = mtd_pairing_groups(master);
1592         int npairs = mtd_wunit_per_eb(master) / ngroups;
1593         struct mtd_oob_ops adjops = *ops;
1594         unsigned int wunit, oobavail;
1595         struct mtd_pairing_info info;
1596         int max_bitflips = 0;
1597         u32 ebofs, pageofs;
1598         loff_t base, pos;
1599
1600         ebofs = mtd_mod_by_eb(start, mtd);
1601         base = (loff_t)mtd_div_by_eb(start, mtd) * master->erasesize;
1602         info.group = 0;
1603         info.pair = mtd_div_by_ws(ebofs, mtd);
1604         pageofs = mtd_mod_by_ws(ebofs, mtd);
1605         oobavail = mtd_oobavail(mtd, ops);
1606
1607         while (ops->retlen < ops->len || ops->oobretlen < ops->ooblen) {
1608                 int ret;
1609
1610                 if (info.pair >= npairs) {
1611                         info.pair = 0;
1612                         base += master->erasesize;
1613                 }
1614
1615                 wunit = mtd_pairing_info_to_wunit(master, &info);
1616                 pos = mtd_wunit_to_offset(mtd, base, wunit);
1617
1618                 adjops.len = ops->len - ops->retlen;
1619                 if (adjops.len > mtd->writesize - pageofs)
1620                         adjops.len = mtd->writesize - pageofs;
1621
1622                 adjops.ooblen = ops->ooblen - ops->oobretlen;
1623                 if (adjops.ooblen > oobavail - adjops.ooboffs)
1624                         adjops.ooblen = oobavail - adjops.ooboffs;
1625
1626                 if (read) {
1627                         ret = mtd_read_oob_std(mtd, pos + pageofs, &adjops);
1628                         if (ret > 0)
1629                                 max_bitflips = max(max_bitflips, ret);
1630                 } else {
1631                         ret = mtd_write_oob_std(mtd, pos + pageofs, &adjops);
1632                 }
1633
1634                 if (ret < 0)
1635                         return ret;
1636
1637                 max_bitflips = max(max_bitflips, ret);
1638                 ops->retlen += adjops.retlen;
1639                 ops->oobretlen += adjops.oobretlen;
1640                 adjops.datbuf += adjops.retlen;
1641                 adjops.oobbuf += adjops.oobretlen;
1642                 adjops.ooboffs = 0;
1643                 pageofs = 0;
1644                 info.pair++;
1645         }
1646
1647         return max_bitflips;
1648 }
1649
1650 int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
1651 {
1652         struct mtd_info *master = mtd_get_master(mtd);
1653         struct mtd_ecc_stats old_stats = master->ecc_stats;
1654         int ret_code;
1655
1656         ops->retlen = ops->oobretlen = 0;
1657
1658         ret_code = mtd_check_oob_ops(mtd, from, ops);
1659         if (ret_code)
1660                 return ret_code;
1661
1662         ledtrig_mtd_activity();
1663
1664         /* Check the validity of a potential fallback on mtd->_read */
1665         if (!master->_read_oob && (!master->_read || ops->oobbuf))
1666                 return -EOPNOTSUPP;
1667
1668         if (ops->stats)
1669                 memset(ops->stats, 0, sizeof(*ops->stats));
1670
1671         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
1672                 ret_code = mtd_io_emulated_slc(mtd, from, true, ops);
1673         else
1674                 ret_code = mtd_read_oob_std(mtd, from, ops);
1675
1676         mtd_update_ecc_stats(mtd, master, &old_stats);
1677
1678         /*
1679          * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
1680          * similar to mtd->_read(), returning a non-negative integer
1681          * representing max bitflips. In other cases, mtd->_read_oob() may
1682          * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
1683          */
1684         if (unlikely(ret_code < 0))
1685                 return ret_code;
1686         if (mtd->ecc_strength == 0)
1687                 return 0;       /* device lacks ecc */
1688         if (ops->stats)
1689                 ops->stats->max_bitflips = ret_code;
1690         return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1691 }
1692 EXPORT_SYMBOL_GPL(mtd_read_oob);
1693
1694 int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1695                                 struct mtd_oob_ops *ops)
1696 {
1697         struct mtd_info *master = mtd_get_master(mtd);
1698         int ret;
1699
1700         ops->retlen = ops->oobretlen = 0;
1701
1702         if (!(mtd->flags & MTD_WRITEABLE))
1703                 return -EROFS;
1704
1705         ret = mtd_check_oob_ops(mtd, to, ops);
1706         if (ret)
1707                 return ret;
1708
1709         ledtrig_mtd_activity();
1710
1711         /* Check the validity of a potential fallback on mtd->_write */
1712         if (!master->_write_oob && (!master->_write || ops->oobbuf))
1713                 return -EOPNOTSUPP;
1714
1715         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
1716                 return mtd_io_emulated_slc(mtd, to, false, ops);
1717
1718         return mtd_write_oob_std(mtd, to, ops);
1719 }
1720 EXPORT_SYMBOL_GPL(mtd_write_oob);
1721
1722 /**
1723  * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
1724  * @mtd: MTD device structure
1725  * @section: ECC section. Depending on the layout you may have all the ECC
1726  *           bytes stored in a single contiguous section, or one section
1727  *           per ECC chunk (and sometime several sections for a single ECC
1728  *           ECC chunk)
1729  * @oobecc: OOB region struct filled with the appropriate ECC position
1730  *          information
1731  *
1732  * This function returns ECC section information in the OOB area. If you want
1733  * to get all the ECC bytes information, then you should call
1734  * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
1735  *
1736  * Returns zero on success, a negative error code otherwise.
1737  */
1738 int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1739                       struct mtd_oob_region *oobecc)
1740 {
1741         struct mtd_info *master = mtd_get_master(mtd);
1742
1743         memset(oobecc, 0, sizeof(*oobecc));
1744
1745         if (!master || section < 0)
1746                 return -EINVAL;
1747
1748         if (!master->ooblayout || !master->ooblayout->ecc)
1749                 return -ENOTSUPP;
1750
1751         return master->ooblayout->ecc(master, section, oobecc);
1752 }
1753 EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1754
1755 /**
1756  * mtd_ooblayout_free - Get the OOB region definition of a specific free
1757  *                      section
1758  * @mtd: MTD device structure
1759  * @section: Free section you are interested in. Depending on the layout
1760  *           you may have all the free bytes stored in a single contiguous
1761  *           section, or one section per ECC chunk plus an extra section
1762  *           for the remaining bytes (or other funky layout).
1763  * @oobfree: OOB region struct filled with the appropriate free position
1764  *           information
1765  *
1766  * This function returns free bytes position in the OOB area. If you want
1767  * to get all the free bytes information, then you should call
1768  * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
1769  *
1770  * Returns zero on success, a negative error code otherwise.
1771  */
1772 int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1773                        struct mtd_oob_region *oobfree)
1774 {
1775         struct mtd_info *master = mtd_get_master(mtd);
1776
1777         memset(oobfree, 0, sizeof(*oobfree));
1778
1779         if (!master || section < 0)
1780                 return -EINVAL;
1781
1782         if (!master->ooblayout || !master->ooblayout->free)
1783                 return -ENOTSUPP;
1784
1785         return master->ooblayout->free(master, section, oobfree);
1786 }
1787 EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1788
1789 /**
1790  * mtd_ooblayout_find_region - Find the region attached to a specific byte
1791  * @mtd: mtd info structure
1792  * @byte: the byte we are searching for
1793  * @sectionp: pointer where the section id will be stored
1794  * @oobregion: used to retrieve the ECC position
1795  * @iter: iterator function. Should be either mtd_ooblayout_free or
1796  *        mtd_ooblayout_ecc depending on the region type you're searching for
1797  *
1798  * This function returns the section id and oobregion information of a
1799  * specific byte. For example, say you want to know where the 4th ECC byte is
1800  * stored, you'll use:
1801  *
1802  * mtd_ooblayout_find_region(mtd, 3, &section, &oobregion, mtd_ooblayout_ecc);
1803  *
1804  * Returns zero on success, a negative error code otherwise.
1805  */
1806 static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
1807                                 int *sectionp, struct mtd_oob_region *oobregion,
1808                                 int (*iter)(struct mtd_info *,
1809                                             int section,
1810                                             struct mtd_oob_region *oobregion))
1811 {
1812         int pos = 0, ret, section = 0;
1813
1814         memset(oobregion, 0, sizeof(*oobregion));
1815
1816         while (1) {
1817                 ret = iter(mtd, section, oobregion);
1818                 if (ret)
1819                         return ret;
1820
1821                 if (pos + oobregion->length > byte)
1822                         break;
1823
1824                 pos += oobregion->length;
1825                 section++;
1826         }
1827
1828         /*
1829          * Adjust region info to make it start at the beginning at the
1830          * 'start' ECC byte.
1831          */
1832         oobregion->offset += byte - pos;
1833         oobregion->length -= byte - pos;
1834         *sectionp = section;
1835
1836         return 0;
1837 }
1838
1839 /**
1840  * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
1841  *                                ECC byte
1842  * @mtd: mtd info structure
1843  * @eccbyte: the byte we are searching for
1844  * @section: pointer where the section id will be stored
1845  * @oobregion: OOB region information
1846  *
1847  * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
1848  * byte.
1849  *
1850  * Returns zero on success, a negative error code otherwise.
1851  */
1852 int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
1853                                  int *section,
1854                                  struct mtd_oob_region *oobregion)
1855 {
1856         return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
1857                                          mtd_ooblayout_ecc);
1858 }
1859 EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
1860
1861 /**
1862  * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
1863  * @mtd: mtd info structure
1864  * @buf: destination buffer to store OOB bytes
1865  * @oobbuf: OOB buffer
1866  * @start: first byte to retrieve
1867  * @nbytes: number of bytes to retrieve
1868  * @iter: section iterator
1869  *
1870  * Extract bytes attached to a specific category (ECC or free)
1871  * from the OOB buffer and copy them into buf.
1872  *
1873  * Returns zero on success, a negative error code otherwise.
1874  */
1875 static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
1876                                 const u8 *oobbuf, int start, int nbytes,
1877                                 int (*iter)(struct mtd_info *,
1878                                             int section,
1879                                             struct mtd_oob_region *oobregion))
1880 {
1881         struct mtd_oob_region oobregion;
1882         int section, ret;
1883
1884         ret = mtd_ooblayout_find_region(mtd, start, &section,
1885                                         &oobregion, iter);
1886
1887         while (!ret) {
1888                 int cnt;
1889
1890                 cnt = min_t(int, nbytes, oobregion.length);
1891                 memcpy(buf, oobbuf + oobregion.offset, cnt);
1892                 buf += cnt;
1893                 nbytes -= cnt;
1894
1895                 if (!nbytes)
1896                         break;
1897
1898                 ret = iter(mtd, ++section, &oobregion);
1899         }
1900
1901         return ret;
1902 }
1903
1904 /**
1905  * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
1906  * @mtd: mtd info structure
1907  * @buf: source buffer to get OOB bytes from
1908  * @oobbuf: OOB buffer
1909  * @start: first OOB byte to set
1910  * @nbytes: number of OOB bytes to set
1911  * @iter: section iterator
1912  *
1913  * Fill the OOB buffer with data provided in buf. The category (ECC or free)
1914  * is selected by passing the appropriate iterator.
1915  *
1916  * Returns zero on success, a negative error code otherwise.
1917  */
1918 static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
1919                                 u8 *oobbuf, int start, int nbytes,
1920                                 int (*iter)(struct mtd_info *,
1921                                             int section,
1922                                             struct mtd_oob_region *oobregion))
1923 {
1924         struct mtd_oob_region oobregion;
1925         int section, ret;
1926
1927         ret = mtd_ooblayout_find_region(mtd, start, &section,
1928                                         &oobregion, iter);
1929
1930         while (!ret) {
1931                 int cnt;
1932
1933                 cnt = min_t(int, nbytes, oobregion.length);
1934                 memcpy(oobbuf + oobregion.offset, buf, cnt);
1935                 buf += cnt;
1936                 nbytes -= cnt;
1937
1938                 if (!nbytes)
1939                         break;
1940
1941                 ret = iter(mtd, ++section, &oobregion);
1942         }
1943
1944         return ret;
1945 }
1946
1947 /**
1948  * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
1949  * @mtd: mtd info structure
1950  * @iter: category iterator
1951  *
1952  * Count the number of bytes in a given category.
1953  *
1954  * Returns a positive value on success, a negative error code otherwise.
1955  */
1956 static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
1957                                 int (*iter)(struct mtd_info *,
1958                                             int section,
1959                                             struct mtd_oob_region *oobregion))
1960 {
1961         struct mtd_oob_region oobregion;
1962         int section = 0, ret, nbytes = 0;
1963
1964         while (1) {
1965                 ret = iter(mtd, section++, &oobregion);
1966                 if (ret) {
1967                         if (ret == -ERANGE)
1968                                 ret = nbytes;
1969                         break;
1970                 }
1971
1972                 nbytes += oobregion.length;
1973         }
1974
1975         return ret;
1976 }
1977
1978 /**
1979  * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
1980  * @mtd: mtd info structure
1981  * @eccbuf: destination buffer to store ECC bytes
1982  * @oobbuf: OOB buffer
1983  * @start: first ECC byte to retrieve
1984  * @nbytes: number of ECC bytes to retrieve
1985  *
1986  * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
1987  *
1988  * Returns zero on success, a negative error code otherwise.
1989  */
1990 int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
1991                                const u8 *oobbuf, int start, int nbytes)
1992 {
1993         return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1994                                        mtd_ooblayout_ecc);
1995 }
1996 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
1997
1998 /**
1999  * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
2000  * @mtd: mtd info structure
2001  * @eccbuf: source buffer to get ECC bytes from
2002  * @oobbuf: OOB buffer
2003  * @start: first ECC byte to set
2004  * @nbytes: number of ECC bytes to set
2005  *
2006  * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
2007  *
2008  * Returns zero on success, a negative error code otherwise.
2009  */
2010 int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
2011                                u8 *oobbuf, int start, int nbytes)
2012 {
2013         return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
2014                                        mtd_ooblayout_ecc);
2015 }
2016 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
2017
2018 /**
2019  * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
2020  * @mtd: mtd info structure
2021  * @databuf: destination buffer to store ECC bytes
2022  * @oobbuf: OOB buffer
2023  * @start: first ECC byte to retrieve
2024  * @nbytes: number of ECC bytes to retrieve
2025  *
2026  * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
2027  *
2028  * Returns zero on success, a negative error code otherwise.
2029  */
2030 int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
2031                                 const u8 *oobbuf, int start, int nbytes)
2032 {
2033         return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
2034                                        mtd_ooblayout_free);
2035 }
2036 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
2037
2038 /**
2039  * mtd_ooblayout_set_databytes - set data bytes into the oob buffer
2040  * @mtd: mtd info structure
2041  * @databuf: source buffer to get data bytes from
2042  * @oobbuf: OOB buffer
2043  * @start: first ECC byte to set
2044  * @nbytes: number of ECC bytes to set
2045  *
2046  * Works like mtd_ooblayout_set_bytes(), except it acts on free bytes.
2047  *
2048  * Returns zero on success, a negative error code otherwise.
2049  */
2050 int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
2051                                 u8 *oobbuf, int start, int nbytes)
2052 {
2053         return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
2054                                        mtd_ooblayout_free);
2055 }
2056 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
2057
2058 /**
2059  * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
2060  * @mtd: mtd info structure
2061  *
2062  * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
2063  *
2064  * Returns zero on success, a negative error code otherwise.
2065  */
2066 int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
2067 {
2068         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
2069 }
2070 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
2071
2072 /**
2073  * mtd_ooblayout_count_eccbytes - count the number of ECC bytes in OOB
2074  * @mtd: mtd info structure
2075  *
2076  * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
2077  *
2078  * Returns zero on success, a negative error code otherwise.
2079  */
2080 int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
2081 {
2082         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
2083 }
2084 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
2085
2086 /*
2087  * Method to access the protection register area, present in some flash
2088  * devices. The user data is one time programmable but the factory data is read
2089  * only.
2090  */
2091 int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
2092                            struct otp_info *buf)
2093 {
2094         struct mtd_info *master = mtd_get_master(mtd);
2095
2096         if (!master->_get_fact_prot_info)
2097                 return -EOPNOTSUPP;
2098         if (!len)
2099                 return 0;
2100         return master->_get_fact_prot_info(master, len, retlen, buf);
2101 }
2102 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
2103
2104 int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
2105                            size_t *retlen, u_char *buf)
2106 {
2107         struct mtd_info *master = mtd_get_master(mtd);
2108
2109         *retlen = 0;
2110         if (!master->_read_fact_prot_reg)
2111                 return -EOPNOTSUPP;
2112         if (!len)
2113                 return 0;
2114         return master->_read_fact_prot_reg(master, from, len, retlen, buf);
2115 }
2116 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
2117
2118 int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
2119                            struct otp_info *buf)
2120 {
2121         struct mtd_info *master = mtd_get_master(mtd);
2122
2123         if (!master->_get_user_prot_info)
2124                 return -EOPNOTSUPP;
2125         if (!len)
2126                 return 0;
2127         return master->_get_user_prot_info(master, len, retlen, buf);
2128 }
2129 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
2130
2131 int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
2132                            size_t *retlen, u_char *buf)
2133 {
2134         struct mtd_info *master = mtd_get_master(mtd);
2135
2136         *retlen = 0;
2137         if (!master->_read_user_prot_reg)
2138                 return -EOPNOTSUPP;
2139         if (!len)
2140                 return 0;
2141         return master->_read_user_prot_reg(master, from, len, retlen, buf);
2142 }
2143 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
2144
2145 int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
2146                             size_t *retlen, const u_char *buf)
2147 {
2148         struct mtd_info *master = mtd_get_master(mtd);
2149         int ret;
2150
2151         *retlen = 0;
2152         if (!master->_write_user_prot_reg)
2153                 return -EOPNOTSUPP;
2154         if (!len)
2155                 return 0;
2156         ret = master->_write_user_prot_reg(master, to, len, retlen, buf);
2157         if (ret)
2158                 return ret;
2159
2160         /*
2161          * If no data could be written at all, we are out of memory and
2162          * must return -ENOSPC.
2163          */
2164         return (*retlen) ? 0 : -ENOSPC;
2165 }
2166 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);
2167
2168 int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
2169 {
2170         struct mtd_info *master = mtd_get_master(mtd);
2171
2172         if (!master->_lock_user_prot_reg)
2173                 return -EOPNOTSUPP;
2174         if (!len)
2175                 return 0;
2176         return master->_lock_user_prot_reg(master, from, len);
2177 }
2178 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
2179
2180 int mtd_erase_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
2181 {
2182         struct mtd_info *master = mtd_get_master(mtd);
2183
2184         if (!master->_erase_user_prot_reg)
2185                 return -EOPNOTSUPP;
2186         if (!len)
2187                 return 0;
2188         return master->_erase_user_prot_reg(master, from, len);
2189 }
2190 EXPORT_SYMBOL_GPL(mtd_erase_user_prot_reg);
2191
2192 /* Chip-supported device locking */
2193 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2194 {
2195         struct mtd_info *master = mtd_get_master(mtd);
2196
2197         if (!master->_lock)
2198                 return -EOPNOTSUPP;
2199         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
2200                 return -EINVAL;
2201         if (!len)
2202                 return 0;
2203
2204         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
2205                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2206                 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
2207         }
2208
2209         return master->_lock(master, mtd_get_master_ofs(mtd, ofs), len);
2210 }
2211 EXPORT_SYMBOL_GPL(mtd_lock);
2212
2213 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2214 {
2215         struct mtd_info *master = mtd_get_master(mtd);
2216
2217         if (!master->_unlock)
2218                 return -EOPNOTSUPP;
2219         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
2220                 return -EINVAL;
2221         if (!len)
2222                 return 0;
2223
2224         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
2225                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2226                 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
2227         }
2228
2229         return master->_unlock(master, mtd_get_master_ofs(mtd, ofs), len);
2230 }
2231 EXPORT_SYMBOL_GPL(mtd_unlock);
2232
2233 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2234 {
2235         struct mtd_info *master = mtd_get_master(mtd);
2236
2237         if (!master->_is_locked)
2238                 return -EOPNOTSUPP;
2239         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
2240                 return -EINVAL;
2241         if (!len)
2242                 return 0;
2243
2244         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
2245                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2246                 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
2247         }
2248
2249         return master->_is_locked(master, mtd_get_master_ofs(mtd, ofs), len);
2250 }
2251 EXPORT_SYMBOL_GPL(mtd_is_locked);
2252
2253 int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
2254 {
2255         struct mtd_info *master = mtd_get_master(mtd);
2256
2257         if (ofs < 0 || ofs >= mtd->size)
2258                 return -EINVAL;
2259         if (!master->_block_isreserved)
2260                 return 0;
2261
2262         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2263                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2264
2265         return master->_block_isreserved(master, mtd_get_master_ofs(mtd, ofs));
2266 }
2267 EXPORT_SYMBOL_GPL(mtd_block_isreserved);
2268
2269 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
2270 {
2271         struct mtd_info *master = mtd_get_master(mtd);
2272
2273         if (ofs < 0 || ofs >= mtd->size)
2274                 return -EINVAL;
2275         if (!master->_block_isbad)
2276                 return 0;
2277
2278         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2279                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2280
2281         return master->_block_isbad(master, mtd_get_master_ofs(mtd, ofs));
2282 }
2283 EXPORT_SYMBOL_GPL(mtd_block_isbad);
2284
2285 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
2286 {
2287         struct mtd_info *master = mtd_get_master(mtd);
2288         int ret;
2289
2290         if (!master->_block_markbad)
2291                 return -EOPNOTSUPP;
2292         if (ofs < 0 || ofs >= mtd->size)
2293                 return -EINVAL;
2294         if (!(mtd->flags & MTD_WRITEABLE))
2295                 return -EROFS;
2296
2297         if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2298                 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2299
2300         ret = master->_block_markbad(master, mtd_get_master_ofs(mtd, ofs));
2301         if (ret)
2302                 return ret;
2303
2304         while (mtd->parent) {
2305                 mtd->ecc_stats.badblocks++;
2306                 mtd = mtd->parent;
2307         }
2308
2309         return 0;
2310 }
2311 EXPORT_SYMBOL_GPL(mtd_block_markbad);
2312
2313 /*
2314  * default_mtd_writev - the default writev method
2315  * @mtd: mtd device description object pointer
2316  * @vecs: the vectors to write
2317  * @count: count of vectors in @vecs
2318  * @to: the MTD device offset to write to
2319  * @retlen: on exit contains the count of bytes written to the MTD device.
2320  *
2321  * This function returns zero in case of success and a negative error code in
2322  * case of failure.
2323  */
2324 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
2325                               unsigned long count, loff_t to, size_t *retlen)
2326 {
2327         unsigned long i;
2328         size_t totlen = 0, thislen;
2329         int ret = 0;
2330
2331         for (i = 0; i < count; i++) {
2332                 if (!vecs[i].iov_len)
2333                         continue;
2334                 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
2335                                 vecs[i].iov_base);
2336                 totlen += thislen;
2337                 if (ret || thislen != vecs[i].iov_len)
2338                         break;
2339                 to += vecs[i].iov_len;
2340         }
2341         *retlen = totlen;
2342         return ret;
2343 }
2344
2345 /*
2346  * mtd_writev - the vector-based MTD write method
2347  * @mtd: mtd device description object pointer
2348  * @vecs: the vectors to write
2349  * @count: count of vectors in @vecs
2350  * @to: the MTD device offset to write to
2351  * @retlen: on exit contains the count of bytes written to the MTD device.
2352  *
2353  * This function returns zero in case of success and a negative error code in
2354  * case of failure.
2355  */
2356 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
2357                unsigned long count, loff_t to, size_t *retlen)
2358 {
2359         struct mtd_info *master = mtd_get_master(mtd);
2360
2361         *retlen = 0;
2362         if (!(mtd->flags & MTD_WRITEABLE))
2363                 return -EROFS;
2364
2365         if (!master->_writev)
2366                 return default_mtd_writev(mtd, vecs, count, to, retlen);
2367
2368         return master->_writev(master, vecs, count,
2369                                mtd_get_master_ofs(mtd, to), retlen);
2370 }
2371 EXPORT_SYMBOL_GPL(mtd_writev);
2372
2373 /**
2374  * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
2375  * @mtd: mtd device description object pointer
2376  * @size: a pointer to the ideal or maximum size of the allocation, points
2377  *        to the actual allocation size on success.
2378  *
2379  * This routine attempts to allocate a contiguous kernel buffer up to
2380  * the specified size, backing off the size of the request exponentially
2381  * until the request succeeds or until the allocation size falls below
2382  * the system page size. This attempts to make sure it does not adversely
2383  * impact system performance, so when allocating more than one page, we
2384  * ask the memory allocator to avoid re-trying, swapping, writing back
2385  * or performing I/O.
2386  *
2387  * Note, this function also makes sure that the allocated buffer is aligned to
2388  * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
2389  *
2390  * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
2391  * to handle smaller (i.e. degraded) buffer allocations under low- or
2392  * fragmented-memory situations where such reduced allocations, from a
2393  * requested ideal, are allowed.
2394  *
2395  * Returns a pointer to the allocated buffer on success; otherwise, NULL.
2396  */
2397 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
2398 {
2399         gfp_t flags = __GFP_NOWARN | __GFP_DIRECT_RECLAIM | __GFP_NORETRY;
2400         size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
2401         void *kbuf;
2402
2403         *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
2404
2405         while (*size > min_alloc) {
2406                 kbuf = kmalloc(*size, flags);
2407                 if (kbuf)
2408                         return kbuf;
2409
2410                 *size >>= 1;
2411                 *size = ALIGN(*size, mtd->writesize);
2412         }
2413
2414         /*
2415          * For the last resort allocation allow 'kmalloc()' to do all sorts of
2416          * things (write-back, dropping caches, etc) by using GFP_KERNEL.
2417          */
2418         return kmalloc(*size, GFP_KERNEL);
2419 }
2420 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
2421
2422 #ifdef CONFIG_PROC_FS
2423
2424 /*====================================================================*/
2425 /* Support for /proc/mtd */
2426
2427 static int mtd_proc_show(struct seq_file *m, void *v)
2428 {
2429         struct mtd_info *mtd;
2430
2431         seq_puts(m, "dev:    size   erasesize  name\n");
2432         mutex_lock(&mtd_table_mutex);
2433         mtd_for_each_device(mtd) {
2434                 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
2435                            mtd->index, (unsigned long long)mtd->size,
2436                            mtd->erasesize, mtd->name);
2437         }
2438         mutex_unlock(&mtd_table_mutex);
2439         return 0;
2440 }
2441 #endif /* CONFIG_PROC_FS */
2442
2443 /*====================================================================*/
2444 /* Init code */
2445
2446 static struct backing_dev_info * __init mtd_bdi_init(const char *name)
2447 {
2448         struct backing_dev_info *bdi;
2449         int ret;
2450
2451         bdi = bdi_alloc(NUMA_NO_NODE);
2452         if (!bdi)
2453                 return ERR_PTR(-ENOMEM);
2454         bdi->ra_pages = 0;
2455         bdi->io_pages = 0;
2456
2457         /*
2458          * We put '-0' suffix to the name to get the same name format as we
2459          * used to get. Since this is called only once, we get a unique name.
2460          */
2461         ret = bdi_register(bdi, "%.28s-0", name);
2462         if (ret)
2463                 bdi_put(bdi);
2464
2465         return ret ? ERR_PTR(ret) : bdi;
2466 }
2467
2468 static struct proc_dir_entry *proc_mtd;
2469
2470 static int __init init_mtd(void)
2471 {
2472         int ret;
2473
2474         ret = class_register(&mtd_class);
2475         if (ret)
2476                 goto err_reg;
2477
2478         mtd_bdi = mtd_bdi_init("mtd");
2479         if (IS_ERR(mtd_bdi)) {
2480                 ret = PTR_ERR(mtd_bdi);
2481                 goto err_bdi;
2482         }
2483
2484         proc_mtd = proc_create_single("mtd", 0, NULL, mtd_proc_show);
2485
2486         ret = init_mtdchar();
2487         if (ret)
2488                 goto out_procfs;
2489
2490         dfs_dir_mtd = debugfs_create_dir("mtd", NULL);
2491         debugfs_create_bool("expert_analysis_mode", 0600, dfs_dir_mtd,
2492                             &mtd_expert_analysis_mode);
2493
2494         return 0;
2495
2496 out_procfs:
2497         if (proc_mtd)
2498                 remove_proc_entry("mtd", NULL);
2499         bdi_unregister(mtd_bdi);
2500         bdi_put(mtd_bdi);
2501 err_bdi:
2502         class_unregister(&mtd_class);
2503 err_reg:
2504         pr_err("Error registering mtd class or bdi: %d\n", ret);
2505         return ret;
2506 }
2507
2508 static void __exit cleanup_mtd(void)
2509 {
2510         debugfs_remove_recursive(dfs_dir_mtd);
2511         cleanup_mtdchar();
2512         if (proc_mtd)
2513                 remove_proc_entry("mtd", NULL);
2514         class_unregister(&mtd_class);
2515         bdi_unregister(mtd_bdi);
2516         bdi_put(mtd_bdi);
2517         idr_destroy(&mtd_idr);
2518 }
2519
2520 module_init(init_mtd);
2521 module_exit(cleanup_mtd);
2522
2523 MODULE_LICENSE("GPL");
2524 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
2525 MODULE_DESCRIPTION("Core MTD registration and access routines");