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/proc_fs.h> 36 #include <linux/idr.h> 37 #include <linux/backing-dev.h> 38 #include <linux/gfp.h> 39 #include <linux/slab.h> 40 41 #include <linux/mtd/mtd.h> 42 #include <linux/mtd/partitions.h> 43 44 #include "mtdcore.h" 45 46 /* 47 * backing device capabilities for non-mappable devices (such as NAND flash) 48 * - permits private mappings, copies are taken of the data 49 */ 50 static struct backing_dev_info mtd_bdi_unmappable = { 51 .capabilities = BDI_CAP_MAP_COPY, 52 }; 53 54 /* 55 * backing device capabilities for R/O mappable devices (such as ROM) 56 * - permits private mappings, copies are taken of the data 57 * - permits non-writable shared mappings 58 */ 59 static struct backing_dev_info mtd_bdi_ro_mappable = { 60 .capabilities = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT | 61 BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP), 62 }; 63 64 /* 65 * backing device capabilities for writable mappable devices (such as RAM) 66 * - permits private mappings, copies are taken of the data 67 * - permits non-writable shared mappings 68 */ 69 static struct backing_dev_info mtd_bdi_rw_mappable = { 70 .capabilities = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT | 71 BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP | 72 BDI_CAP_WRITE_MAP), 73 }; 74 75 static int mtd_cls_suspend(struct device *dev, pm_message_t state); 76 static int mtd_cls_resume(struct device *dev); 77 78 static struct class mtd_class = { 79 .name = "mtd", 80 .owner = THIS_MODULE, 81 .suspend = mtd_cls_suspend, 82 .resume = mtd_cls_resume, 83 }; 84 85 static DEFINE_IDR(mtd_idr); 86 87 /* These are exported solely for the purpose of mtd_blkdevs.c. You 88 should not use them for _anything_ else */ 89 DEFINE_MUTEX(mtd_table_mutex); 90 EXPORT_SYMBOL_GPL(mtd_table_mutex); 91 92 struct mtd_info *__mtd_next_device(int i) 93 { 94 return idr_get_next(&mtd_idr, &i); 95 } 96 EXPORT_SYMBOL_GPL(__mtd_next_device); 97 98 static LIST_HEAD(mtd_notifiers); 99 100 101 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2) 102 103 /* REVISIT once MTD uses the driver model better, whoever allocates 104 * the mtd_info will probably want to use the release() hook... 105 */ 106 static void mtd_release(struct device *dev) 107 { 108 struct mtd_info __maybe_unused *mtd = dev_get_drvdata(dev); 109 dev_t index = MTD_DEVT(mtd->index); 110 111 /* remove /dev/mtdXro node if needed */ 112 if (index) 113 device_destroy(&mtd_class, index + 1); 114 } 115 116 static int mtd_cls_suspend(struct device *dev, pm_message_t state) 117 { 118 struct mtd_info *mtd = dev_get_drvdata(dev); 119 120 return mtd ? mtd_suspend(mtd) : 0; 121 } 122 123 static int mtd_cls_resume(struct device *dev) 124 { 125 struct mtd_info *mtd = dev_get_drvdata(dev); 126 127 if (mtd) 128 mtd_resume(mtd); 129 return 0; 130 } 131 132 static ssize_t mtd_type_show(struct device *dev, 133 struct device_attribute *attr, char *buf) 134 { 135 struct mtd_info *mtd = dev_get_drvdata(dev); 136 char *type; 137 138 switch (mtd->type) { 139 case MTD_ABSENT: 140 type = "absent"; 141 break; 142 case MTD_RAM: 143 type = "ram"; 144 break; 145 case MTD_ROM: 146 type = "rom"; 147 break; 148 case MTD_NORFLASH: 149 type = "nor"; 150 break; 151 case MTD_NANDFLASH: 152 type = "nand"; 153 break; 154 case MTD_DATAFLASH: 155 type = "dataflash"; 156 break; 157 case MTD_UBIVOLUME: 158 type = "ubi"; 159 break; 160 case MTD_MLCNANDFLASH: 161 type = "mlc-nand"; 162 break; 163 default: 164 type = "unknown"; 165 } 166 167 return snprintf(buf, PAGE_SIZE, "%s\n", type); 168 } 169 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL); 170 171 static ssize_t mtd_flags_show(struct device *dev, 172 struct device_attribute *attr, char *buf) 173 { 174 struct mtd_info *mtd = dev_get_drvdata(dev); 175 176 return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags); 177 178 } 179 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL); 180 181 static ssize_t mtd_size_show(struct device *dev, 182 struct device_attribute *attr, char *buf) 183 { 184 struct mtd_info *mtd = dev_get_drvdata(dev); 185 186 return snprintf(buf, PAGE_SIZE, "%llu\n", 187 (unsigned long long)mtd->size); 188 189 } 190 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL); 191 192 static ssize_t mtd_erasesize_show(struct device *dev, 193 struct device_attribute *attr, char *buf) 194 { 195 struct mtd_info *mtd = dev_get_drvdata(dev); 196 197 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize); 198 199 } 200 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL); 201 202 static ssize_t mtd_writesize_show(struct device *dev, 203 struct device_attribute *attr, char *buf) 204 { 205 struct mtd_info *mtd = dev_get_drvdata(dev); 206 207 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize); 208 209 } 210 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL); 211 212 static ssize_t mtd_subpagesize_show(struct device *dev, 213 struct device_attribute *attr, char *buf) 214 { 215 struct mtd_info *mtd = dev_get_drvdata(dev); 216 unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft; 217 218 return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize); 219 220 } 221 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL); 222 223 static ssize_t mtd_oobsize_show(struct device *dev, 224 struct device_attribute *attr, char *buf) 225 { 226 struct mtd_info *mtd = dev_get_drvdata(dev); 227 228 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize); 229 230 } 231 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL); 232 233 static ssize_t mtd_numeraseregions_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, "%u\n", mtd->numeraseregions); 239 240 } 241 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show, 242 NULL); 243 244 static ssize_t mtd_name_show(struct device *dev, 245 struct device_attribute *attr, char *buf) 246 { 247 struct mtd_info *mtd = dev_get_drvdata(dev); 248 249 return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name); 250 251 } 252 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL); 253 254 static ssize_t mtd_ecc_strength_show(struct device *dev, 255 struct device_attribute *attr, char *buf) 256 { 257 struct mtd_info *mtd = dev_get_drvdata(dev); 258 259 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_strength); 260 } 261 static DEVICE_ATTR(ecc_strength, S_IRUGO, mtd_ecc_strength_show, NULL); 262 263 static ssize_t mtd_bitflip_threshold_show(struct device *dev, 264 struct device_attribute *attr, 265 char *buf) 266 { 267 struct mtd_info *mtd = dev_get_drvdata(dev); 268 269 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->bitflip_threshold); 270 } 271 272 static ssize_t mtd_bitflip_threshold_store(struct device *dev, 273 struct device_attribute *attr, 274 const char *buf, size_t count) 275 { 276 struct mtd_info *mtd = dev_get_drvdata(dev); 277 unsigned int bitflip_threshold; 278 int retval; 279 280 retval = kstrtouint(buf, 0, &bitflip_threshold); 281 if (retval) 282 return retval; 283 284 mtd->bitflip_threshold = bitflip_threshold; 285 return count; 286 } 287 static DEVICE_ATTR(bitflip_threshold, S_IRUGO | S_IWUSR, 288 mtd_bitflip_threshold_show, 289 mtd_bitflip_threshold_store); 290 291 static ssize_t mtd_ecc_step_size_show(struct device *dev, 292 struct device_attribute *attr, char *buf) 293 { 294 struct mtd_info *mtd = dev_get_drvdata(dev); 295 296 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_step_size); 297 298 } 299 static DEVICE_ATTR(ecc_step_size, S_IRUGO, mtd_ecc_step_size_show, NULL); 300 301 static struct attribute *mtd_attrs[] = { 302 &dev_attr_type.attr, 303 &dev_attr_flags.attr, 304 &dev_attr_size.attr, 305 &dev_attr_erasesize.attr, 306 &dev_attr_writesize.attr, 307 &dev_attr_subpagesize.attr, 308 &dev_attr_oobsize.attr, 309 &dev_attr_numeraseregions.attr, 310 &dev_attr_name.attr, 311 &dev_attr_ecc_strength.attr, 312 &dev_attr_ecc_step_size.attr, 313 &dev_attr_bitflip_threshold.attr, 314 NULL, 315 }; 316 317 static struct attribute_group mtd_group = { 318 .attrs = mtd_attrs, 319 }; 320 321 static const struct attribute_group *mtd_groups[] = { 322 &mtd_group, 323 NULL, 324 }; 325 326 static struct device_type mtd_devtype = { 327 .name = "mtd", 328 .groups = mtd_groups, 329 .release = mtd_release, 330 }; 331 332 /** 333 * add_mtd_device - register an MTD device 334 * @mtd: pointer to new MTD device info structure 335 * 336 * Add a device to the list of MTD devices present in the system, and 337 * notify each currently active MTD 'user' of its arrival. Returns 338 * zero on success or 1 on failure, which currently will only happen 339 * if there is insufficient memory or a sysfs error. 340 */ 341 342 int add_mtd_device(struct mtd_info *mtd) 343 { 344 struct mtd_notifier *not; 345 int i, error; 346 347 if (!mtd->backing_dev_info) { 348 switch (mtd->type) { 349 case MTD_RAM: 350 mtd->backing_dev_info = &mtd_bdi_rw_mappable; 351 break; 352 case MTD_ROM: 353 mtd->backing_dev_info = &mtd_bdi_ro_mappable; 354 break; 355 default: 356 mtd->backing_dev_info = &mtd_bdi_unmappable; 357 break; 358 } 359 } 360 361 BUG_ON(mtd->writesize == 0); 362 mutex_lock(&mtd_table_mutex); 363 364 i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL); 365 if (i < 0) 366 goto fail_locked; 367 368 mtd->index = i; 369 mtd->usecount = 0; 370 371 /* default value if not set by driver */ 372 if (mtd->bitflip_threshold == 0) 373 mtd->bitflip_threshold = mtd->ecc_strength; 374 375 if (is_power_of_2(mtd->erasesize)) 376 mtd->erasesize_shift = ffs(mtd->erasesize) - 1; 377 else 378 mtd->erasesize_shift = 0; 379 380 if (is_power_of_2(mtd->writesize)) 381 mtd->writesize_shift = ffs(mtd->writesize) - 1; 382 else 383 mtd->writesize_shift = 0; 384 385 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1; 386 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1; 387 388 /* Some chips always power up locked. Unlock them now */ 389 if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) { 390 error = mtd_unlock(mtd, 0, mtd->size); 391 if (error && error != -EOPNOTSUPP) 392 printk(KERN_WARNING 393 "%s: unlock failed, writes may not work\n", 394 mtd->name); 395 } 396 397 /* Caller should have set dev.parent to match the 398 * physical device. 399 */ 400 mtd->dev.type = &mtd_devtype; 401 mtd->dev.class = &mtd_class; 402 mtd->dev.devt = MTD_DEVT(i); 403 dev_set_name(&mtd->dev, "mtd%d", i); 404 dev_set_drvdata(&mtd->dev, mtd); 405 if (device_register(&mtd->dev) != 0) 406 goto fail_added; 407 408 if (MTD_DEVT(i)) 409 device_create(&mtd_class, mtd->dev.parent, 410 MTD_DEVT(i) + 1, 411 NULL, "mtd%dro", i); 412 413 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name); 414 /* No need to get a refcount on the module containing 415 the notifier, since we hold the mtd_table_mutex */ 416 list_for_each_entry(not, &mtd_notifiers, list) 417 not->add(mtd); 418 419 mutex_unlock(&mtd_table_mutex); 420 /* We _know_ we aren't being removed, because 421 our caller is still holding us here. So none 422 of this try_ nonsense, and no bitching about it 423 either. :) */ 424 __module_get(THIS_MODULE); 425 return 0; 426 427 fail_added: 428 idr_remove(&mtd_idr, i); 429 fail_locked: 430 mutex_unlock(&mtd_table_mutex); 431 return 1; 432 } 433 434 /** 435 * del_mtd_device - unregister an MTD device 436 * @mtd: pointer to MTD device info structure 437 * 438 * Remove a device from the list of MTD devices present in the system, 439 * and notify each currently active MTD 'user' of its departure. 440 * Returns zero on success or 1 on failure, which currently will happen 441 * if the requested device does not appear to be present in the list. 442 */ 443 444 int del_mtd_device(struct mtd_info *mtd) 445 { 446 int ret; 447 struct mtd_notifier *not; 448 449 mutex_lock(&mtd_table_mutex); 450 451 if (idr_find(&mtd_idr, mtd->index) != mtd) { 452 ret = -ENODEV; 453 goto out_error; 454 } 455 456 /* No need to get a refcount on the module containing 457 the notifier, since we hold the mtd_table_mutex */ 458 list_for_each_entry(not, &mtd_notifiers, list) 459 not->remove(mtd); 460 461 if (mtd->usecount) { 462 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n", 463 mtd->index, mtd->name, mtd->usecount); 464 ret = -EBUSY; 465 } else { 466 device_unregister(&mtd->dev); 467 468 idr_remove(&mtd_idr, mtd->index); 469 470 module_put(THIS_MODULE); 471 ret = 0; 472 } 473 474 out_error: 475 mutex_unlock(&mtd_table_mutex); 476 return ret; 477 } 478 479 /** 480 * mtd_device_parse_register - parse partitions and register an MTD device. 481 * 482 * @mtd: the MTD device to register 483 * @types: the list of MTD partition probes to try, see 484 * 'parse_mtd_partitions()' for more information 485 * @parser_data: MTD partition parser-specific data 486 * @parts: fallback partition information to register, if parsing fails; 487 * only valid if %nr_parts > %0 488 * @nr_parts: the number of partitions in parts, if zero then the full 489 * MTD device is registered if no partition info is found 490 * 491 * This function aggregates MTD partitions parsing (done by 492 * 'parse_mtd_partitions()') and MTD device and partitions registering. It 493 * basically follows the most common pattern found in many MTD drivers: 494 * 495 * * It first tries to probe partitions on MTD device @mtd using parsers 496 * specified in @types (if @types is %NULL, then the default list of parsers 497 * is used, see 'parse_mtd_partitions()' for more information). If none are 498 * found this functions tries to fallback to information specified in 499 * @parts/@nr_parts. 500 * * If any partitioning info was found, this function registers the found 501 * partitions. 502 * * If no partitions were found this function just registers the MTD device 503 * @mtd and exits. 504 * 505 * Returns zero in case of success and a negative error code in case of failure. 506 */ 507 int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types, 508 struct mtd_part_parser_data *parser_data, 509 const struct mtd_partition *parts, 510 int nr_parts) 511 { 512 int err; 513 struct mtd_partition *real_parts; 514 515 err = parse_mtd_partitions(mtd, types, &real_parts, parser_data); 516 if (err <= 0 && nr_parts && parts) { 517 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts, 518 GFP_KERNEL); 519 if (!real_parts) 520 err = -ENOMEM; 521 else 522 err = nr_parts; 523 } 524 525 if (err > 0) { 526 err = add_mtd_partitions(mtd, real_parts, err); 527 kfree(real_parts); 528 } else if (err == 0) { 529 err = add_mtd_device(mtd); 530 if (err == 1) 531 err = -ENODEV; 532 } 533 534 return err; 535 } 536 EXPORT_SYMBOL_GPL(mtd_device_parse_register); 537 538 /** 539 * mtd_device_unregister - unregister an existing MTD device. 540 * 541 * @master: the MTD device to unregister. This will unregister both the master 542 * and any partitions if registered. 543 */ 544 int mtd_device_unregister(struct mtd_info *master) 545 { 546 int err; 547 548 err = del_mtd_partitions(master); 549 if (err) 550 return err; 551 552 if (!device_is_registered(&master->dev)) 553 return 0; 554 555 return del_mtd_device(master); 556 } 557 EXPORT_SYMBOL_GPL(mtd_device_unregister); 558 559 /** 560 * register_mtd_user - register a 'user' of MTD devices. 561 * @new: pointer to notifier info structure 562 * 563 * Registers a pair of callbacks function to be called upon addition 564 * or removal of MTD devices. Causes the 'add' callback to be immediately 565 * invoked for each MTD device currently present in the system. 566 */ 567 void register_mtd_user (struct mtd_notifier *new) 568 { 569 struct mtd_info *mtd; 570 571 mutex_lock(&mtd_table_mutex); 572 573 list_add(&new->list, &mtd_notifiers); 574 575 __module_get(THIS_MODULE); 576 577 mtd_for_each_device(mtd) 578 new->add(mtd); 579 580 mutex_unlock(&mtd_table_mutex); 581 } 582 EXPORT_SYMBOL_GPL(register_mtd_user); 583 584 /** 585 * unregister_mtd_user - unregister a 'user' of MTD devices. 586 * @old: pointer to notifier info structure 587 * 588 * Removes a callback function pair from the list of 'users' to be 589 * notified upon addition or removal of MTD devices. Causes the 590 * 'remove' callback to be immediately invoked for each MTD device 591 * currently present in the system. 592 */ 593 int unregister_mtd_user (struct mtd_notifier *old) 594 { 595 struct mtd_info *mtd; 596 597 mutex_lock(&mtd_table_mutex); 598 599 module_put(THIS_MODULE); 600 601 mtd_for_each_device(mtd) 602 old->remove(mtd); 603 604 list_del(&old->list); 605 mutex_unlock(&mtd_table_mutex); 606 return 0; 607 } 608 EXPORT_SYMBOL_GPL(unregister_mtd_user); 609 610 /** 611 * get_mtd_device - obtain a validated handle for an MTD device 612 * @mtd: last known address of the required MTD device 613 * @num: internal device number of the required MTD device 614 * 615 * Given a number and NULL address, return the num'th entry in the device 616 * table, if any. Given an address and num == -1, search the device table 617 * for a device with that address and return if it's still present. Given 618 * both, return the num'th driver only if its address matches. Return 619 * error code if not. 620 */ 621 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num) 622 { 623 struct mtd_info *ret = NULL, *other; 624 int err = -ENODEV; 625 626 mutex_lock(&mtd_table_mutex); 627 628 if (num == -1) { 629 mtd_for_each_device(other) { 630 if (other == mtd) { 631 ret = mtd; 632 break; 633 } 634 } 635 } else if (num >= 0) { 636 ret = idr_find(&mtd_idr, num); 637 if (mtd && mtd != ret) 638 ret = NULL; 639 } 640 641 if (!ret) { 642 ret = ERR_PTR(err); 643 goto out; 644 } 645 646 err = __get_mtd_device(ret); 647 if (err) 648 ret = ERR_PTR(err); 649 out: 650 mutex_unlock(&mtd_table_mutex); 651 return ret; 652 } 653 EXPORT_SYMBOL_GPL(get_mtd_device); 654 655 656 int __get_mtd_device(struct mtd_info *mtd) 657 { 658 int err; 659 660 if (!try_module_get(mtd->owner)) 661 return -ENODEV; 662 663 if (mtd->_get_device) { 664 err = mtd->_get_device(mtd); 665 666 if (err) { 667 module_put(mtd->owner); 668 return err; 669 } 670 } 671 mtd->usecount++; 672 return 0; 673 } 674 EXPORT_SYMBOL_GPL(__get_mtd_device); 675 676 /** 677 * get_mtd_device_nm - obtain a validated handle for an MTD device by 678 * device name 679 * @name: MTD device name to open 680 * 681 * This function returns MTD device description structure in case of 682 * success and an error code in case of failure. 683 */ 684 struct mtd_info *get_mtd_device_nm(const char *name) 685 { 686 int err = -ENODEV; 687 struct mtd_info *mtd = NULL, *other; 688 689 mutex_lock(&mtd_table_mutex); 690 691 mtd_for_each_device(other) { 692 if (!strcmp(name, other->name)) { 693 mtd = other; 694 break; 695 } 696 } 697 698 if (!mtd) 699 goto out_unlock; 700 701 err = __get_mtd_device(mtd); 702 if (err) 703 goto out_unlock; 704 705 mutex_unlock(&mtd_table_mutex); 706 return mtd; 707 708 out_unlock: 709 mutex_unlock(&mtd_table_mutex); 710 return ERR_PTR(err); 711 } 712 EXPORT_SYMBOL_GPL(get_mtd_device_nm); 713 714 void put_mtd_device(struct mtd_info *mtd) 715 { 716 mutex_lock(&mtd_table_mutex); 717 __put_mtd_device(mtd); 718 mutex_unlock(&mtd_table_mutex); 719 720 } 721 EXPORT_SYMBOL_GPL(put_mtd_device); 722 723 void __put_mtd_device(struct mtd_info *mtd) 724 { 725 --mtd->usecount; 726 BUG_ON(mtd->usecount < 0); 727 728 if (mtd->_put_device) 729 mtd->_put_device(mtd); 730 731 module_put(mtd->owner); 732 } 733 EXPORT_SYMBOL_GPL(__put_mtd_device); 734 735 /* 736 * Erase is an asynchronous operation. Device drivers are supposed 737 * to call instr->callback() whenever the operation completes, even 738 * if it completes with a failure. 739 * Callers are supposed to pass a callback function and wait for it 740 * to be called before writing to the block. 741 */ 742 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 743 { 744 if (instr->addr > mtd->size || instr->len > mtd->size - instr->addr) 745 return -EINVAL; 746 if (!(mtd->flags & MTD_WRITEABLE)) 747 return -EROFS; 748 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 749 if (!instr->len) { 750 instr->state = MTD_ERASE_DONE; 751 mtd_erase_callback(instr); 752 return 0; 753 } 754 return mtd->_erase(mtd, instr); 755 } 756 EXPORT_SYMBOL_GPL(mtd_erase); 757 758 /* 759 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL. 760 */ 761 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 762 void **virt, resource_size_t *phys) 763 { 764 *retlen = 0; 765 *virt = NULL; 766 if (phys) 767 *phys = 0; 768 if (!mtd->_point) 769 return -EOPNOTSUPP; 770 if (from < 0 || from > mtd->size || len > mtd->size - from) 771 return -EINVAL; 772 if (!len) 773 return 0; 774 return mtd->_point(mtd, from, len, retlen, virt, phys); 775 } 776 EXPORT_SYMBOL_GPL(mtd_point); 777 778 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ 779 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 780 { 781 if (!mtd->_point) 782 return -EOPNOTSUPP; 783 if (from < 0 || from > mtd->size || len > mtd->size - from) 784 return -EINVAL; 785 if (!len) 786 return 0; 787 return mtd->_unpoint(mtd, from, len); 788 } 789 EXPORT_SYMBOL_GPL(mtd_unpoint); 790 791 /* 792 * Allow NOMMU mmap() to directly map the device (if not NULL) 793 * - return the address to which the offset maps 794 * - return -ENOSYS to indicate refusal to do the mapping 795 */ 796 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 797 unsigned long offset, unsigned long flags) 798 { 799 if (!mtd->_get_unmapped_area) 800 return -EOPNOTSUPP; 801 if (offset > mtd->size || len > mtd->size - offset) 802 return -EINVAL; 803 return mtd->_get_unmapped_area(mtd, len, offset, flags); 804 } 805 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area); 806 807 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 808 u_char *buf) 809 { 810 int ret_code; 811 *retlen = 0; 812 if (from < 0 || from > mtd->size || len > mtd->size - from) 813 return -EINVAL; 814 if (!len) 815 return 0; 816 817 /* 818 * In the absence of an error, drivers return a non-negative integer 819 * representing the maximum number of bitflips that were corrected on 820 * any one ecc region (if applicable; zero otherwise). 821 */ 822 ret_code = mtd->_read(mtd, from, len, retlen, buf); 823 if (unlikely(ret_code < 0)) 824 return ret_code; 825 if (mtd->ecc_strength == 0) 826 return 0; /* device lacks ecc */ 827 return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0; 828 } 829 EXPORT_SYMBOL_GPL(mtd_read); 830 831 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 832 const u_char *buf) 833 { 834 *retlen = 0; 835 if (to < 0 || to > mtd->size || len > mtd->size - to) 836 return -EINVAL; 837 if (!mtd->_write || !(mtd->flags & MTD_WRITEABLE)) 838 return -EROFS; 839 if (!len) 840 return 0; 841 return mtd->_write(mtd, to, len, retlen, buf); 842 } 843 EXPORT_SYMBOL_GPL(mtd_write); 844 845 /* 846 * In blackbox flight recorder like scenarios we want to make successful writes 847 * in interrupt context. panic_write() is only intended to be called when its 848 * known the kernel is about to panic and we need the write to succeed. Since 849 * the kernel is not going to be running for much longer, this function can 850 * break locks and delay to ensure the write succeeds (but not sleep). 851 */ 852 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 853 const u_char *buf) 854 { 855 *retlen = 0; 856 if (!mtd->_panic_write) 857 return -EOPNOTSUPP; 858 if (to < 0 || to > mtd->size || len > mtd->size - to) 859 return -EINVAL; 860 if (!(mtd->flags & MTD_WRITEABLE)) 861 return -EROFS; 862 if (!len) 863 return 0; 864 return mtd->_panic_write(mtd, to, len, retlen, buf); 865 } 866 EXPORT_SYMBOL_GPL(mtd_panic_write); 867 868 int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops) 869 { 870 int ret_code; 871 ops->retlen = ops->oobretlen = 0; 872 if (!mtd->_read_oob) 873 return -EOPNOTSUPP; 874 /* 875 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics 876 * similar to mtd->_read(), returning a non-negative integer 877 * representing max bitflips. In other cases, mtd->_read_oob() may 878 * return -EUCLEAN. In all cases, perform similar logic to mtd_read(). 879 */ 880 ret_code = mtd->_read_oob(mtd, from, ops); 881 if (unlikely(ret_code < 0)) 882 return ret_code; 883 if (mtd->ecc_strength == 0) 884 return 0; /* device lacks ecc */ 885 return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0; 886 } 887 EXPORT_SYMBOL_GPL(mtd_read_oob); 888 889 /* 890 * Method to access the protection register area, present in some flash 891 * devices. The user data is one time programmable but the factory data is read 892 * only. 893 */ 894 int mtd_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf, 895 size_t len) 896 { 897 if (!mtd->_get_fact_prot_info) 898 return -EOPNOTSUPP; 899 if (!len) 900 return 0; 901 return mtd->_get_fact_prot_info(mtd, buf, len); 902 } 903 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info); 904 905 int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 906 size_t *retlen, u_char *buf) 907 { 908 *retlen = 0; 909 if (!mtd->_read_fact_prot_reg) 910 return -EOPNOTSUPP; 911 if (!len) 912 return 0; 913 return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf); 914 } 915 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg); 916 917 int mtd_get_user_prot_info(struct mtd_info *mtd, struct otp_info *buf, 918 size_t len) 919 { 920 if (!mtd->_get_user_prot_info) 921 return -EOPNOTSUPP; 922 if (!len) 923 return 0; 924 return mtd->_get_user_prot_info(mtd, buf, len); 925 } 926 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info); 927 928 int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 929 size_t *retlen, u_char *buf) 930 { 931 *retlen = 0; 932 if (!mtd->_read_user_prot_reg) 933 return -EOPNOTSUPP; 934 if (!len) 935 return 0; 936 return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf); 937 } 938 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg); 939 940 int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len, 941 size_t *retlen, u_char *buf) 942 { 943 *retlen = 0; 944 if (!mtd->_write_user_prot_reg) 945 return -EOPNOTSUPP; 946 if (!len) 947 return 0; 948 return mtd->_write_user_prot_reg(mtd, to, len, retlen, buf); 949 } 950 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg); 951 952 int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len) 953 { 954 if (!mtd->_lock_user_prot_reg) 955 return -EOPNOTSUPP; 956 if (!len) 957 return 0; 958 return mtd->_lock_user_prot_reg(mtd, from, len); 959 } 960 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg); 961 962 /* Chip-supported device locking */ 963 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 964 { 965 if (!mtd->_lock) 966 return -EOPNOTSUPP; 967 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 968 return -EINVAL; 969 if (!len) 970 return 0; 971 return mtd->_lock(mtd, ofs, len); 972 } 973 EXPORT_SYMBOL_GPL(mtd_lock); 974 975 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 976 { 977 if (!mtd->_unlock) 978 return -EOPNOTSUPP; 979 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 980 return -EINVAL; 981 if (!len) 982 return 0; 983 return mtd->_unlock(mtd, ofs, len); 984 } 985 EXPORT_SYMBOL_GPL(mtd_unlock); 986 987 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 988 { 989 if (!mtd->_is_locked) 990 return -EOPNOTSUPP; 991 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 992 return -EINVAL; 993 if (!len) 994 return 0; 995 return mtd->_is_locked(mtd, ofs, len); 996 } 997 EXPORT_SYMBOL_GPL(mtd_is_locked); 998 999 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs) 1000 { 1001 if (!mtd->_block_isbad) 1002 return 0; 1003 if (ofs < 0 || ofs > mtd->size) 1004 return -EINVAL; 1005 return mtd->_block_isbad(mtd, ofs); 1006 } 1007 EXPORT_SYMBOL_GPL(mtd_block_isbad); 1008 1009 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs) 1010 { 1011 if (!mtd->_block_markbad) 1012 return -EOPNOTSUPP; 1013 if (ofs < 0 || ofs > mtd->size) 1014 return -EINVAL; 1015 if (!(mtd->flags & MTD_WRITEABLE)) 1016 return -EROFS; 1017 return mtd->_block_markbad(mtd, ofs); 1018 } 1019 EXPORT_SYMBOL_GPL(mtd_block_markbad); 1020 1021 /* 1022 * default_mtd_writev - the default writev method 1023 * @mtd: mtd device description object pointer 1024 * @vecs: the vectors to write 1025 * @count: count of vectors in @vecs 1026 * @to: the MTD device offset to write to 1027 * @retlen: on exit contains the count of bytes written to the MTD device. 1028 * 1029 * This function returns zero in case of success and a negative error code in 1030 * case of failure. 1031 */ 1032 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 1033 unsigned long count, loff_t to, size_t *retlen) 1034 { 1035 unsigned long i; 1036 size_t totlen = 0, thislen; 1037 int ret = 0; 1038 1039 for (i = 0; i < count; i++) { 1040 if (!vecs[i].iov_len) 1041 continue; 1042 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen, 1043 vecs[i].iov_base); 1044 totlen += thislen; 1045 if (ret || thislen != vecs[i].iov_len) 1046 break; 1047 to += vecs[i].iov_len; 1048 } 1049 *retlen = totlen; 1050 return ret; 1051 } 1052 1053 /* 1054 * mtd_writev - the vector-based MTD write method 1055 * @mtd: mtd device description object pointer 1056 * @vecs: the vectors to write 1057 * @count: count of vectors in @vecs 1058 * @to: the MTD device offset to write to 1059 * @retlen: on exit contains the count of bytes written to the MTD device. 1060 * 1061 * This function returns zero in case of success and a negative error code in 1062 * case of failure. 1063 */ 1064 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 1065 unsigned long count, loff_t to, size_t *retlen) 1066 { 1067 *retlen = 0; 1068 if (!(mtd->flags & MTD_WRITEABLE)) 1069 return -EROFS; 1070 if (!mtd->_writev) 1071 return default_mtd_writev(mtd, vecs, count, to, retlen); 1072 return mtd->_writev(mtd, vecs, count, to, retlen); 1073 } 1074 EXPORT_SYMBOL_GPL(mtd_writev); 1075 1076 /** 1077 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size 1078 * @mtd: mtd device description object pointer 1079 * @size: a pointer to the ideal or maximum size of the allocation, points 1080 * to the actual allocation size on success. 1081 * 1082 * This routine attempts to allocate a contiguous kernel buffer up to 1083 * the specified size, backing off the size of the request exponentially 1084 * until the request succeeds or until the allocation size falls below 1085 * the system page size. This attempts to make sure it does not adversely 1086 * impact system performance, so when allocating more than one page, we 1087 * ask the memory allocator to avoid re-trying, swapping, writing back 1088 * or performing I/O. 1089 * 1090 * Note, this function also makes sure that the allocated buffer is aligned to 1091 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value. 1092 * 1093 * This is called, for example by mtd_{read,write} and jffs2_scan_medium, 1094 * to handle smaller (i.e. degraded) buffer allocations under low- or 1095 * fragmented-memory situations where such reduced allocations, from a 1096 * requested ideal, are allowed. 1097 * 1098 * Returns a pointer to the allocated buffer on success; otherwise, NULL. 1099 */ 1100 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size) 1101 { 1102 gfp_t flags = __GFP_NOWARN | __GFP_WAIT | 1103 __GFP_NORETRY | __GFP_NO_KSWAPD; 1104 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE); 1105 void *kbuf; 1106 1107 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE); 1108 1109 while (*size > min_alloc) { 1110 kbuf = kmalloc(*size, flags); 1111 if (kbuf) 1112 return kbuf; 1113 1114 *size >>= 1; 1115 *size = ALIGN(*size, mtd->writesize); 1116 } 1117 1118 /* 1119 * For the last resort allocation allow 'kmalloc()' to do all sorts of 1120 * things (write-back, dropping caches, etc) by using GFP_KERNEL. 1121 */ 1122 return kmalloc(*size, GFP_KERNEL); 1123 } 1124 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to); 1125 1126 #ifdef CONFIG_PROC_FS 1127 1128 /*====================================================================*/ 1129 /* Support for /proc/mtd */ 1130 1131 static int mtd_proc_show(struct seq_file *m, void *v) 1132 { 1133 struct mtd_info *mtd; 1134 1135 seq_puts(m, "dev: size erasesize name\n"); 1136 mutex_lock(&mtd_table_mutex); 1137 mtd_for_each_device(mtd) { 1138 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n", 1139 mtd->index, (unsigned long long)mtd->size, 1140 mtd->erasesize, mtd->name); 1141 } 1142 mutex_unlock(&mtd_table_mutex); 1143 return 0; 1144 } 1145 1146 static int mtd_proc_open(struct inode *inode, struct file *file) 1147 { 1148 return single_open(file, mtd_proc_show, NULL); 1149 } 1150 1151 static const struct file_operations mtd_proc_ops = { 1152 .open = mtd_proc_open, 1153 .read = seq_read, 1154 .llseek = seq_lseek, 1155 .release = single_release, 1156 }; 1157 #endif /* CONFIG_PROC_FS */ 1158 1159 /*====================================================================*/ 1160 /* Init code */ 1161 1162 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name) 1163 { 1164 int ret; 1165 1166 ret = bdi_init(bdi); 1167 if (!ret) 1168 ret = bdi_register(bdi, NULL, "%s", name); 1169 1170 if (ret) 1171 bdi_destroy(bdi); 1172 1173 return ret; 1174 } 1175 1176 static struct proc_dir_entry *proc_mtd; 1177 1178 static int __init init_mtd(void) 1179 { 1180 int ret; 1181 1182 ret = class_register(&mtd_class); 1183 if (ret) 1184 goto err_reg; 1185 1186 ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap"); 1187 if (ret) 1188 goto err_bdi1; 1189 1190 ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap"); 1191 if (ret) 1192 goto err_bdi2; 1193 1194 ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap"); 1195 if (ret) 1196 goto err_bdi3; 1197 1198 proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops); 1199 1200 ret = init_mtdchar(); 1201 if (ret) 1202 goto out_procfs; 1203 1204 return 0; 1205 1206 out_procfs: 1207 if (proc_mtd) 1208 remove_proc_entry("mtd", NULL); 1209 err_bdi3: 1210 bdi_destroy(&mtd_bdi_ro_mappable); 1211 err_bdi2: 1212 bdi_destroy(&mtd_bdi_unmappable); 1213 err_bdi1: 1214 class_unregister(&mtd_class); 1215 err_reg: 1216 pr_err("Error registering mtd class or bdi: %d\n", ret); 1217 return ret; 1218 } 1219 1220 static void __exit cleanup_mtd(void) 1221 { 1222 cleanup_mtdchar(); 1223 if (proc_mtd) 1224 remove_proc_entry("mtd", NULL); 1225 class_unregister(&mtd_class); 1226 bdi_destroy(&mtd_bdi_unmappable); 1227 bdi_destroy(&mtd_bdi_ro_mappable); 1228 bdi_destroy(&mtd_bdi_rw_mappable); 1229 } 1230 1231 module_init(init_mtd); 1232 module_exit(cleanup_mtd); 1233 1234 MODULE_LICENSE("GPL"); 1235 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 1236 MODULE_DESCRIPTION("Core MTD registration and access routines"); 1237