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 ATTRIBUTE_GROUPS(mtd); 317 318 static struct device_type mtd_devtype = { 319 .name = "mtd", 320 .groups = mtd_groups, 321 .release = mtd_release, 322 }; 323 324 /** 325 * add_mtd_device - register an MTD device 326 * @mtd: pointer to new MTD device info structure 327 * 328 * Add a device to the list of MTD devices present in the system, and 329 * notify each currently active MTD 'user' of its arrival. Returns 330 * zero on success or 1 on failure, which currently will only happen 331 * if there is insufficient memory or a sysfs error. 332 */ 333 334 int add_mtd_device(struct mtd_info *mtd) 335 { 336 struct mtd_notifier *not; 337 int i, error; 338 339 if (!mtd->backing_dev_info) { 340 switch (mtd->type) { 341 case MTD_RAM: 342 mtd->backing_dev_info = &mtd_bdi_rw_mappable; 343 break; 344 case MTD_ROM: 345 mtd->backing_dev_info = &mtd_bdi_ro_mappable; 346 break; 347 default: 348 mtd->backing_dev_info = &mtd_bdi_unmappable; 349 break; 350 } 351 } 352 353 BUG_ON(mtd->writesize == 0); 354 mutex_lock(&mtd_table_mutex); 355 356 i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL); 357 if (i < 0) 358 goto fail_locked; 359 360 mtd->index = i; 361 mtd->usecount = 0; 362 363 /* default value if not set by driver */ 364 if (mtd->bitflip_threshold == 0) 365 mtd->bitflip_threshold = mtd->ecc_strength; 366 367 if (is_power_of_2(mtd->erasesize)) 368 mtd->erasesize_shift = ffs(mtd->erasesize) - 1; 369 else 370 mtd->erasesize_shift = 0; 371 372 if (is_power_of_2(mtd->writesize)) 373 mtd->writesize_shift = ffs(mtd->writesize) - 1; 374 else 375 mtd->writesize_shift = 0; 376 377 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1; 378 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1; 379 380 /* Some chips always power up locked. Unlock them now */ 381 if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) { 382 error = mtd_unlock(mtd, 0, mtd->size); 383 if (error && error != -EOPNOTSUPP) 384 printk(KERN_WARNING 385 "%s: unlock failed, writes may not work\n", 386 mtd->name); 387 } 388 389 /* Caller should have set dev.parent to match the 390 * physical device. 391 */ 392 mtd->dev.type = &mtd_devtype; 393 mtd->dev.class = &mtd_class; 394 mtd->dev.devt = MTD_DEVT(i); 395 dev_set_name(&mtd->dev, "mtd%d", i); 396 dev_set_drvdata(&mtd->dev, mtd); 397 if (device_register(&mtd->dev) != 0) 398 goto fail_added; 399 400 if (MTD_DEVT(i)) 401 device_create(&mtd_class, mtd->dev.parent, 402 MTD_DEVT(i) + 1, 403 NULL, "mtd%dro", i); 404 405 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name); 406 /* No need to get a refcount on the module containing 407 the notifier, since we hold the mtd_table_mutex */ 408 list_for_each_entry(not, &mtd_notifiers, list) 409 not->add(mtd); 410 411 mutex_unlock(&mtd_table_mutex); 412 /* We _know_ we aren't being removed, because 413 our caller is still holding us here. So none 414 of this try_ nonsense, and no bitching about it 415 either. :) */ 416 __module_get(THIS_MODULE); 417 return 0; 418 419 fail_added: 420 idr_remove(&mtd_idr, i); 421 fail_locked: 422 mutex_unlock(&mtd_table_mutex); 423 return 1; 424 } 425 426 /** 427 * del_mtd_device - unregister an MTD device 428 * @mtd: pointer to MTD device info structure 429 * 430 * Remove a device from the list of MTD devices present in the system, 431 * and notify each currently active MTD 'user' of its departure. 432 * Returns zero on success or 1 on failure, which currently will happen 433 * if the requested device does not appear to be present in the list. 434 */ 435 436 int del_mtd_device(struct mtd_info *mtd) 437 { 438 int ret; 439 struct mtd_notifier *not; 440 441 mutex_lock(&mtd_table_mutex); 442 443 if (idr_find(&mtd_idr, mtd->index) != mtd) { 444 ret = -ENODEV; 445 goto out_error; 446 } 447 448 /* No need to get a refcount on the module containing 449 the notifier, since we hold the mtd_table_mutex */ 450 list_for_each_entry(not, &mtd_notifiers, list) 451 not->remove(mtd); 452 453 if (mtd->usecount) { 454 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n", 455 mtd->index, mtd->name, mtd->usecount); 456 ret = -EBUSY; 457 } else { 458 device_unregister(&mtd->dev); 459 460 idr_remove(&mtd_idr, mtd->index); 461 462 module_put(THIS_MODULE); 463 ret = 0; 464 } 465 466 out_error: 467 mutex_unlock(&mtd_table_mutex); 468 return ret; 469 } 470 471 /** 472 * mtd_device_parse_register - parse partitions and register an MTD device. 473 * 474 * @mtd: the MTD device to register 475 * @types: the list of MTD partition probes to try, see 476 * 'parse_mtd_partitions()' for more information 477 * @parser_data: MTD partition parser-specific data 478 * @parts: fallback partition information to register, if parsing fails; 479 * only valid if %nr_parts > %0 480 * @nr_parts: the number of partitions in parts, if zero then the full 481 * MTD device is registered if no partition info is found 482 * 483 * This function aggregates MTD partitions parsing (done by 484 * 'parse_mtd_partitions()') and MTD device and partitions registering. It 485 * basically follows the most common pattern found in many MTD drivers: 486 * 487 * * It first tries to probe partitions on MTD device @mtd using parsers 488 * specified in @types (if @types is %NULL, then the default list of parsers 489 * is used, see 'parse_mtd_partitions()' for more information). If none are 490 * found this functions tries to fallback to information specified in 491 * @parts/@nr_parts. 492 * * If any partitioning info was found, this function registers the found 493 * partitions. 494 * * If no partitions were found this function just registers the MTD device 495 * @mtd and exits. 496 * 497 * Returns zero in case of success and a negative error code in case of failure. 498 */ 499 int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types, 500 struct mtd_part_parser_data *parser_data, 501 const struct mtd_partition *parts, 502 int nr_parts) 503 { 504 int err; 505 struct mtd_partition *real_parts; 506 507 err = parse_mtd_partitions(mtd, types, &real_parts, parser_data); 508 if (err <= 0 && nr_parts && parts) { 509 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts, 510 GFP_KERNEL); 511 if (!real_parts) 512 err = -ENOMEM; 513 else 514 err = nr_parts; 515 } 516 517 if (err > 0) { 518 err = add_mtd_partitions(mtd, real_parts, err); 519 kfree(real_parts); 520 } else if (err == 0) { 521 err = add_mtd_device(mtd); 522 if (err == 1) 523 err = -ENODEV; 524 } 525 526 return err; 527 } 528 EXPORT_SYMBOL_GPL(mtd_device_parse_register); 529 530 /** 531 * mtd_device_unregister - unregister an existing MTD device. 532 * 533 * @master: the MTD device to unregister. This will unregister both the master 534 * and any partitions if registered. 535 */ 536 int mtd_device_unregister(struct mtd_info *master) 537 { 538 int err; 539 540 err = del_mtd_partitions(master); 541 if (err) 542 return err; 543 544 if (!device_is_registered(&master->dev)) 545 return 0; 546 547 return del_mtd_device(master); 548 } 549 EXPORT_SYMBOL_GPL(mtd_device_unregister); 550 551 /** 552 * register_mtd_user - register a 'user' of MTD devices. 553 * @new: pointer to notifier info structure 554 * 555 * Registers a pair of callbacks function to be called upon addition 556 * or removal of MTD devices. Causes the 'add' callback to be immediately 557 * invoked for each MTD device currently present in the system. 558 */ 559 void register_mtd_user (struct mtd_notifier *new) 560 { 561 struct mtd_info *mtd; 562 563 mutex_lock(&mtd_table_mutex); 564 565 list_add(&new->list, &mtd_notifiers); 566 567 __module_get(THIS_MODULE); 568 569 mtd_for_each_device(mtd) 570 new->add(mtd); 571 572 mutex_unlock(&mtd_table_mutex); 573 } 574 EXPORT_SYMBOL_GPL(register_mtd_user); 575 576 /** 577 * unregister_mtd_user - unregister a 'user' of MTD devices. 578 * @old: pointer to notifier info structure 579 * 580 * Removes a callback function pair from the list of 'users' to be 581 * notified upon addition or removal of MTD devices. Causes the 582 * 'remove' callback to be immediately invoked for each MTD device 583 * currently present in the system. 584 */ 585 int unregister_mtd_user (struct mtd_notifier *old) 586 { 587 struct mtd_info *mtd; 588 589 mutex_lock(&mtd_table_mutex); 590 591 module_put(THIS_MODULE); 592 593 mtd_for_each_device(mtd) 594 old->remove(mtd); 595 596 list_del(&old->list); 597 mutex_unlock(&mtd_table_mutex); 598 return 0; 599 } 600 EXPORT_SYMBOL_GPL(unregister_mtd_user); 601 602 /** 603 * get_mtd_device - obtain a validated handle for an MTD device 604 * @mtd: last known address of the required MTD device 605 * @num: internal device number of the required MTD device 606 * 607 * Given a number and NULL address, return the num'th entry in the device 608 * table, if any. Given an address and num == -1, search the device table 609 * for a device with that address and return if it's still present. Given 610 * both, return the num'th driver only if its address matches. Return 611 * error code if not. 612 */ 613 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num) 614 { 615 struct mtd_info *ret = NULL, *other; 616 int err = -ENODEV; 617 618 mutex_lock(&mtd_table_mutex); 619 620 if (num == -1) { 621 mtd_for_each_device(other) { 622 if (other == mtd) { 623 ret = mtd; 624 break; 625 } 626 } 627 } else if (num >= 0) { 628 ret = idr_find(&mtd_idr, num); 629 if (mtd && mtd != ret) 630 ret = NULL; 631 } 632 633 if (!ret) { 634 ret = ERR_PTR(err); 635 goto out; 636 } 637 638 err = __get_mtd_device(ret); 639 if (err) 640 ret = ERR_PTR(err); 641 out: 642 mutex_unlock(&mtd_table_mutex); 643 return ret; 644 } 645 EXPORT_SYMBOL_GPL(get_mtd_device); 646 647 648 int __get_mtd_device(struct mtd_info *mtd) 649 { 650 int err; 651 652 if (!try_module_get(mtd->owner)) 653 return -ENODEV; 654 655 if (mtd->_get_device) { 656 err = mtd->_get_device(mtd); 657 658 if (err) { 659 module_put(mtd->owner); 660 return err; 661 } 662 } 663 mtd->usecount++; 664 return 0; 665 } 666 EXPORT_SYMBOL_GPL(__get_mtd_device); 667 668 /** 669 * get_mtd_device_nm - obtain a validated handle for an MTD device by 670 * device name 671 * @name: MTD device name to open 672 * 673 * This function returns MTD device description structure in case of 674 * success and an error code in case of failure. 675 */ 676 struct mtd_info *get_mtd_device_nm(const char *name) 677 { 678 int err = -ENODEV; 679 struct mtd_info *mtd = NULL, *other; 680 681 mutex_lock(&mtd_table_mutex); 682 683 mtd_for_each_device(other) { 684 if (!strcmp(name, other->name)) { 685 mtd = other; 686 break; 687 } 688 } 689 690 if (!mtd) 691 goto out_unlock; 692 693 err = __get_mtd_device(mtd); 694 if (err) 695 goto out_unlock; 696 697 mutex_unlock(&mtd_table_mutex); 698 return mtd; 699 700 out_unlock: 701 mutex_unlock(&mtd_table_mutex); 702 return ERR_PTR(err); 703 } 704 EXPORT_SYMBOL_GPL(get_mtd_device_nm); 705 706 void put_mtd_device(struct mtd_info *mtd) 707 { 708 mutex_lock(&mtd_table_mutex); 709 __put_mtd_device(mtd); 710 mutex_unlock(&mtd_table_mutex); 711 712 } 713 EXPORT_SYMBOL_GPL(put_mtd_device); 714 715 void __put_mtd_device(struct mtd_info *mtd) 716 { 717 --mtd->usecount; 718 BUG_ON(mtd->usecount < 0); 719 720 if (mtd->_put_device) 721 mtd->_put_device(mtd); 722 723 module_put(mtd->owner); 724 } 725 EXPORT_SYMBOL_GPL(__put_mtd_device); 726 727 /* 728 * Erase is an asynchronous operation. Device drivers are supposed 729 * to call instr->callback() whenever the operation completes, even 730 * if it completes with a failure. 731 * Callers are supposed to pass a callback function and wait for it 732 * to be called before writing to the block. 733 */ 734 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 735 { 736 if (instr->addr > mtd->size || instr->len > mtd->size - instr->addr) 737 return -EINVAL; 738 if (!(mtd->flags & MTD_WRITEABLE)) 739 return -EROFS; 740 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 741 if (!instr->len) { 742 instr->state = MTD_ERASE_DONE; 743 mtd_erase_callback(instr); 744 return 0; 745 } 746 return mtd->_erase(mtd, instr); 747 } 748 EXPORT_SYMBOL_GPL(mtd_erase); 749 750 /* 751 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL. 752 */ 753 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 754 void **virt, resource_size_t *phys) 755 { 756 *retlen = 0; 757 *virt = NULL; 758 if (phys) 759 *phys = 0; 760 if (!mtd->_point) 761 return -EOPNOTSUPP; 762 if (from < 0 || from > mtd->size || len > mtd->size - from) 763 return -EINVAL; 764 if (!len) 765 return 0; 766 return mtd->_point(mtd, from, len, retlen, virt, phys); 767 } 768 EXPORT_SYMBOL_GPL(mtd_point); 769 770 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ 771 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 772 { 773 if (!mtd->_point) 774 return -EOPNOTSUPP; 775 if (from < 0 || from > mtd->size || len > mtd->size - from) 776 return -EINVAL; 777 if (!len) 778 return 0; 779 return mtd->_unpoint(mtd, from, len); 780 } 781 EXPORT_SYMBOL_GPL(mtd_unpoint); 782 783 /* 784 * Allow NOMMU mmap() to directly map the device (if not NULL) 785 * - return the address to which the offset maps 786 * - return -ENOSYS to indicate refusal to do the mapping 787 */ 788 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 789 unsigned long offset, unsigned long flags) 790 { 791 if (!mtd->_get_unmapped_area) 792 return -EOPNOTSUPP; 793 if (offset > mtd->size || len > mtd->size - offset) 794 return -EINVAL; 795 return mtd->_get_unmapped_area(mtd, len, offset, flags); 796 } 797 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area); 798 799 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 800 u_char *buf) 801 { 802 int ret_code; 803 *retlen = 0; 804 if (from < 0 || from > mtd->size || len > mtd->size - from) 805 return -EINVAL; 806 if (!len) 807 return 0; 808 809 /* 810 * In the absence of an error, drivers return a non-negative integer 811 * representing the maximum number of bitflips that were corrected on 812 * any one ecc region (if applicable; zero otherwise). 813 */ 814 ret_code = mtd->_read(mtd, from, len, retlen, buf); 815 if (unlikely(ret_code < 0)) 816 return ret_code; 817 if (mtd->ecc_strength == 0) 818 return 0; /* device lacks ecc */ 819 return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0; 820 } 821 EXPORT_SYMBOL_GPL(mtd_read); 822 823 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 824 const u_char *buf) 825 { 826 *retlen = 0; 827 if (to < 0 || to > mtd->size || len > mtd->size - to) 828 return -EINVAL; 829 if (!mtd->_write || !(mtd->flags & MTD_WRITEABLE)) 830 return -EROFS; 831 if (!len) 832 return 0; 833 return mtd->_write(mtd, to, len, retlen, buf); 834 } 835 EXPORT_SYMBOL_GPL(mtd_write); 836 837 /* 838 * In blackbox flight recorder like scenarios we want to make successful writes 839 * in interrupt context. panic_write() is only intended to be called when its 840 * known the kernel is about to panic and we need the write to succeed. Since 841 * the kernel is not going to be running for much longer, this function can 842 * break locks and delay to ensure the write succeeds (but not sleep). 843 */ 844 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 845 const u_char *buf) 846 { 847 *retlen = 0; 848 if (!mtd->_panic_write) 849 return -EOPNOTSUPP; 850 if (to < 0 || to > mtd->size || len > mtd->size - to) 851 return -EINVAL; 852 if (!(mtd->flags & MTD_WRITEABLE)) 853 return -EROFS; 854 if (!len) 855 return 0; 856 return mtd->_panic_write(mtd, to, len, retlen, buf); 857 } 858 EXPORT_SYMBOL_GPL(mtd_panic_write); 859 860 int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops) 861 { 862 int ret_code; 863 ops->retlen = ops->oobretlen = 0; 864 if (!mtd->_read_oob) 865 return -EOPNOTSUPP; 866 /* 867 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics 868 * similar to mtd->_read(), returning a non-negative integer 869 * representing max bitflips. In other cases, mtd->_read_oob() may 870 * return -EUCLEAN. In all cases, perform similar logic to mtd_read(). 871 */ 872 ret_code = mtd->_read_oob(mtd, from, ops); 873 if (unlikely(ret_code < 0)) 874 return ret_code; 875 if (mtd->ecc_strength == 0) 876 return 0; /* device lacks ecc */ 877 return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0; 878 } 879 EXPORT_SYMBOL_GPL(mtd_read_oob); 880 881 /* 882 * Method to access the protection register area, present in some flash 883 * devices. The user data is one time programmable but the factory data is read 884 * only. 885 */ 886 int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen, 887 struct otp_info *buf) 888 { 889 if (!mtd->_get_fact_prot_info) 890 return -EOPNOTSUPP; 891 if (!len) 892 return 0; 893 return mtd->_get_fact_prot_info(mtd, len, retlen, buf); 894 } 895 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info); 896 897 int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 898 size_t *retlen, u_char *buf) 899 { 900 *retlen = 0; 901 if (!mtd->_read_fact_prot_reg) 902 return -EOPNOTSUPP; 903 if (!len) 904 return 0; 905 return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf); 906 } 907 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg); 908 909 int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen, 910 struct otp_info *buf) 911 { 912 if (!mtd->_get_user_prot_info) 913 return -EOPNOTSUPP; 914 if (!len) 915 return 0; 916 return mtd->_get_user_prot_info(mtd, len, retlen, buf); 917 } 918 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info); 919 920 int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 921 size_t *retlen, u_char *buf) 922 { 923 *retlen = 0; 924 if (!mtd->_read_user_prot_reg) 925 return -EOPNOTSUPP; 926 if (!len) 927 return 0; 928 return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf); 929 } 930 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg); 931 932 int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len, 933 size_t *retlen, u_char *buf) 934 { 935 int ret; 936 937 *retlen = 0; 938 if (!mtd->_write_user_prot_reg) 939 return -EOPNOTSUPP; 940 if (!len) 941 return 0; 942 ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf); 943 if (ret) 944 return ret; 945 946 /* 947 * If no data could be written at all, we are out of memory and 948 * must return -ENOSPC. 949 */ 950 return (*retlen) ? 0 : -ENOSPC; 951 } 952 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg); 953 954 int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len) 955 { 956 if (!mtd->_lock_user_prot_reg) 957 return -EOPNOTSUPP; 958 if (!len) 959 return 0; 960 return mtd->_lock_user_prot_reg(mtd, from, len); 961 } 962 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg); 963 964 /* Chip-supported device locking */ 965 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 966 { 967 if (!mtd->_lock) 968 return -EOPNOTSUPP; 969 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 970 return -EINVAL; 971 if (!len) 972 return 0; 973 return mtd->_lock(mtd, ofs, len); 974 } 975 EXPORT_SYMBOL_GPL(mtd_lock); 976 977 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 978 { 979 if (!mtd->_unlock) 980 return -EOPNOTSUPP; 981 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 982 return -EINVAL; 983 if (!len) 984 return 0; 985 return mtd->_unlock(mtd, ofs, len); 986 } 987 EXPORT_SYMBOL_GPL(mtd_unlock); 988 989 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 990 { 991 if (!mtd->_is_locked) 992 return -EOPNOTSUPP; 993 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 994 return -EINVAL; 995 if (!len) 996 return 0; 997 return mtd->_is_locked(mtd, ofs, len); 998 } 999 EXPORT_SYMBOL_GPL(mtd_is_locked); 1000 1001 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs) 1002 { 1003 if (!mtd->_block_isbad) 1004 return 0; 1005 if (ofs < 0 || ofs > mtd->size) 1006 return -EINVAL; 1007 return mtd->_block_isbad(mtd, ofs); 1008 } 1009 EXPORT_SYMBOL_GPL(mtd_block_isbad); 1010 1011 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs) 1012 { 1013 if (!mtd->_block_markbad) 1014 return -EOPNOTSUPP; 1015 if (ofs < 0 || ofs > mtd->size) 1016 return -EINVAL; 1017 if (!(mtd->flags & MTD_WRITEABLE)) 1018 return -EROFS; 1019 return mtd->_block_markbad(mtd, ofs); 1020 } 1021 EXPORT_SYMBOL_GPL(mtd_block_markbad); 1022 1023 /* 1024 * default_mtd_writev - the default writev method 1025 * @mtd: mtd device description object pointer 1026 * @vecs: the vectors to write 1027 * @count: count of vectors in @vecs 1028 * @to: the MTD device offset to write to 1029 * @retlen: on exit contains the count of bytes written to the MTD device. 1030 * 1031 * This function returns zero in case of success and a negative error code in 1032 * case of failure. 1033 */ 1034 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 1035 unsigned long count, loff_t to, size_t *retlen) 1036 { 1037 unsigned long i; 1038 size_t totlen = 0, thislen; 1039 int ret = 0; 1040 1041 for (i = 0; i < count; i++) { 1042 if (!vecs[i].iov_len) 1043 continue; 1044 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen, 1045 vecs[i].iov_base); 1046 totlen += thislen; 1047 if (ret || thislen != vecs[i].iov_len) 1048 break; 1049 to += vecs[i].iov_len; 1050 } 1051 *retlen = totlen; 1052 return ret; 1053 } 1054 1055 /* 1056 * mtd_writev - the vector-based MTD write method 1057 * @mtd: mtd device description object pointer 1058 * @vecs: the vectors to write 1059 * @count: count of vectors in @vecs 1060 * @to: the MTD device offset to write to 1061 * @retlen: on exit contains the count of bytes written to the MTD device. 1062 * 1063 * This function returns zero in case of success and a negative error code in 1064 * case of failure. 1065 */ 1066 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 1067 unsigned long count, loff_t to, size_t *retlen) 1068 { 1069 *retlen = 0; 1070 if (!(mtd->flags & MTD_WRITEABLE)) 1071 return -EROFS; 1072 if (!mtd->_writev) 1073 return default_mtd_writev(mtd, vecs, count, to, retlen); 1074 return mtd->_writev(mtd, vecs, count, to, retlen); 1075 } 1076 EXPORT_SYMBOL_GPL(mtd_writev); 1077 1078 /** 1079 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size 1080 * @mtd: mtd device description object pointer 1081 * @size: a pointer to the ideal or maximum size of the allocation, points 1082 * to the actual allocation size on success. 1083 * 1084 * This routine attempts to allocate a contiguous kernel buffer up to 1085 * the specified size, backing off the size of the request exponentially 1086 * until the request succeeds or until the allocation size falls below 1087 * the system page size. This attempts to make sure it does not adversely 1088 * impact system performance, so when allocating more than one page, we 1089 * ask the memory allocator to avoid re-trying, swapping, writing back 1090 * or performing I/O. 1091 * 1092 * Note, this function also makes sure that the allocated buffer is aligned to 1093 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value. 1094 * 1095 * This is called, for example by mtd_{read,write} and jffs2_scan_medium, 1096 * to handle smaller (i.e. degraded) buffer allocations under low- or 1097 * fragmented-memory situations where such reduced allocations, from a 1098 * requested ideal, are allowed. 1099 * 1100 * Returns a pointer to the allocated buffer on success; otherwise, NULL. 1101 */ 1102 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size) 1103 { 1104 gfp_t flags = __GFP_NOWARN | __GFP_WAIT | 1105 __GFP_NORETRY | __GFP_NO_KSWAPD; 1106 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE); 1107 void *kbuf; 1108 1109 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE); 1110 1111 while (*size > min_alloc) { 1112 kbuf = kmalloc(*size, flags); 1113 if (kbuf) 1114 return kbuf; 1115 1116 *size >>= 1; 1117 *size = ALIGN(*size, mtd->writesize); 1118 } 1119 1120 /* 1121 * For the last resort allocation allow 'kmalloc()' to do all sorts of 1122 * things (write-back, dropping caches, etc) by using GFP_KERNEL. 1123 */ 1124 return kmalloc(*size, GFP_KERNEL); 1125 } 1126 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to); 1127 1128 #ifdef CONFIG_PROC_FS 1129 1130 /*====================================================================*/ 1131 /* Support for /proc/mtd */ 1132 1133 static int mtd_proc_show(struct seq_file *m, void *v) 1134 { 1135 struct mtd_info *mtd; 1136 1137 seq_puts(m, "dev: size erasesize name\n"); 1138 mutex_lock(&mtd_table_mutex); 1139 mtd_for_each_device(mtd) { 1140 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n", 1141 mtd->index, (unsigned long long)mtd->size, 1142 mtd->erasesize, mtd->name); 1143 } 1144 mutex_unlock(&mtd_table_mutex); 1145 return 0; 1146 } 1147 1148 static int mtd_proc_open(struct inode *inode, struct file *file) 1149 { 1150 return single_open(file, mtd_proc_show, NULL); 1151 } 1152 1153 static const struct file_operations mtd_proc_ops = { 1154 .open = mtd_proc_open, 1155 .read = seq_read, 1156 .llseek = seq_lseek, 1157 .release = single_release, 1158 }; 1159 #endif /* CONFIG_PROC_FS */ 1160 1161 /*====================================================================*/ 1162 /* Init code */ 1163 1164 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name) 1165 { 1166 int ret; 1167 1168 ret = bdi_init(bdi); 1169 if (!ret) 1170 ret = bdi_register(bdi, NULL, "%s", name); 1171 1172 if (ret) 1173 bdi_destroy(bdi); 1174 1175 return ret; 1176 } 1177 1178 static struct proc_dir_entry *proc_mtd; 1179 1180 static int __init init_mtd(void) 1181 { 1182 int ret; 1183 1184 ret = class_register(&mtd_class); 1185 if (ret) 1186 goto err_reg; 1187 1188 ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap"); 1189 if (ret) 1190 goto err_bdi1; 1191 1192 ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap"); 1193 if (ret) 1194 goto err_bdi2; 1195 1196 ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap"); 1197 if (ret) 1198 goto err_bdi3; 1199 1200 proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops); 1201 1202 ret = init_mtdchar(); 1203 if (ret) 1204 goto out_procfs; 1205 1206 return 0; 1207 1208 out_procfs: 1209 if (proc_mtd) 1210 remove_proc_entry("mtd", NULL); 1211 err_bdi3: 1212 bdi_destroy(&mtd_bdi_ro_mappable); 1213 err_bdi2: 1214 bdi_destroy(&mtd_bdi_unmappable); 1215 err_bdi1: 1216 class_unregister(&mtd_class); 1217 err_reg: 1218 pr_err("Error registering mtd class or bdi: %d\n", ret); 1219 return ret; 1220 } 1221 1222 static void __exit cleanup_mtd(void) 1223 { 1224 cleanup_mtdchar(); 1225 if (proc_mtd) 1226 remove_proc_entry("mtd", NULL); 1227 class_unregister(&mtd_class); 1228 bdi_destroy(&mtd_bdi_unmappable); 1229 bdi_destroy(&mtd_bdi_ro_mappable); 1230 bdi_destroy(&mtd_bdi_rw_mappable); 1231 } 1232 1233 module_init(init_mtd); 1234 module_exit(cleanup_mtd); 1235 1236 MODULE_LICENSE("GPL"); 1237 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 1238 MODULE_DESCRIPTION("Core MTD registration and access routines"); 1239