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