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