drivers/mtd/mtdcore.c

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