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