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 */ 48 static 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 */ 57 static 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 */ 67 static 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 73 static int mtd_cls_suspend(struct device *dev, pm_message_t state); 74 static int mtd_cls_resume(struct device *dev); 75 76 static struct class mtd_class = { 77 .name = "mtd", 78 .owner = THIS_MODULE, 79 .suspend = mtd_cls_suspend, 80 .resume = mtd_cls_resume, 81 }; 82 83 static 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 */ 87 DEFINE_MUTEX(mtd_table_mutex); 88 EXPORT_SYMBOL_GPL(mtd_table_mutex); 89 90 struct mtd_info *__mtd_next_device(int i) 91 { 92 return idr_get_next(&mtd_idr, &i); 93 } 94 EXPORT_SYMBOL_GPL(__mtd_next_device); 95 96 static 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 */ 108 static 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 118 static 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 125 static 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 134 static 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 } 168 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL); 169 170 static 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 } 178 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL); 179 180 static 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 } 189 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL); 190 191 static 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 } 199 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL); 200 201 static 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 } 209 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL); 210 211 static 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 } 220 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL); 221 222 static 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 } 230 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL); 231 232 static 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 } 240 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show, 241 NULL); 242 243 static 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 } 251 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL); 252 253 static struct attribute *mtd_attrs[] = { 254 &dev_attr_type.attr, 255 &dev_attr_flags.attr, 256 &dev_attr_size.attr, 257 &dev_attr_erasesize.attr, 258 &dev_attr_writesize.attr, 259 &dev_attr_subpagesize.attr, 260 &dev_attr_oobsize.attr, 261 &dev_attr_numeraseregions.attr, 262 &dev_attr_name.attr, 263 NULL, 264 }; 265 266 static struct attribute_group mtd_group = { 267 .attrs = mtd_attrs, 268 }; 269 270 static const struct attribute_group *mtd_groups[] = { 271 &mtd_group, 272 NULL, 273 }; 274 275 static struct device_type mtd_devtype = { 276 .name = "mtd", 277 .groups = mtd_groups, 278 .release = mtd_release, 279 }; 280 281 /** 282 * add_mtd_device - register an MTD device 283 * @mtd: pointer to new MTD device info structure 284 * 285 * Add a device to the list of MTD devices present in the system, and 286 * notify each currently active MTD 'user' of its arrival. Returns 287 * zero on success or 1 on failure, which currently will only happen 288 * if there is insufficient memory or a sysfs error. 289 */ 290 291 int add_mtd_device(struct mtd_info *mtd) 292 { 293 struct mtd_notifier *not; 294 int i, error; 295 296 if (!mtd->backing_dev_info) { 297 switch (mtd->type) { 298 case MTD_RAM: 299 mtd->backing_dev_info = &mtd_bdi_rw_mappable; 300 break; 301 case MTD_ROM: 302 mtd->backing_dev_info = &mtd_bdi_ro_mappable; 303 break; 304 default: 305 mtd->backing_dev_info = &mtd_bdi_unmappable; 306 break; 307 } 308 } 309 310 BUG_ON(mtd->writesize == 0); 311 mutex_lock(&mtd_table_mutex); 312 313 do { 314 if (!idr_pre_get(&mtd_idr, GFP_KERNEL)) 315 goto fail_locked; 316 error = idr_get_new(&mtd_idr, mtd, &i); 317 } while (error == -EAGAIN); 318 319 if (error) 320 goto fail_locked; 321 322 mtd->index = i; 323 mtd->usecount = 0; 324 325 if (is_power_of_2(mtd->erasesize)) 326 mtd->erasesize_shift = ffs(mtd->erasesize) - 1; 327 else 328 mtd->erasesize_shift = 0; 329 330 if (is_power_of_2(mtd->writesize)) 331 mtd->writesize_shift = ffs(mtd->writesize) - 1; 332 else 333 mtd->writesize_shift = 0; 334 335 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1; 336 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1; 337 338 /* Some chips always power up locked. Unlock them now */ 339 if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) { 340 error = mtd_unlock(mtd, 0, mtd->size); 341 if (error && error != -EOPNOTSUPP) 342 printk(KERN_WARNING 343 "%s: unlock failed, writes may not work\n", 344 mtd->name); 345 } 346 347 /* Caller should have set dev.parent to match the 348 * physical device. 349 */ 350 mtd->dev.type = &mtd_devtype; 351 mtd->dev.class = &mtd_class; 352 mtd->dev.devt = MTD_DEVT(i); 353 dev_set_name(&mtd->dev, "mtd%d", i); 354 dev_set_drvdata(&mtd->dev, mtd); 355 if (device_register(&mtd->dev) != 0) 356 goto fail_added; 357 358 if (MTD_DEVT(i)) 359 device_create(&mtd_class, mtd->dev.parent, 360 MTD_DEVT(i) + 1, 361 NULL, "mtd%dro", i); 362 363 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name); 364 /* No need to get a refcount on the module containing 365 the notifier, since we hold the mtd_table_mutex */ 366 list_for_each_entry(not, &mtd_notifiers, list) 367 not->add(mtd); 368 369 mutex_unlock(&mtd_table_mutex); 370 /* We _know_ we aren't being removed, because 371 our caller is still holding us here. So none 372 of this try_ nonsense, and no bitching about it 373 either. :) */ 374 __module_get(THIS_MODULE); 375 return 0; 376 377 fail_added: 378 idr_remove(&mtd_idr, i); 379 fail_locked: 380 mutex_unlock(&mtd_table_mutex); 381 return 1; 382 } 383 384 /** 385 * del_mtd_device - unregister an MTD device 386 * @mtd: pointer to MTD device info structure 387 * 388 * Remove a device from the list of MTD devices present in the system, 389 * and notify each currently active MTD 'user' of its departure. 390 * Returns zero on success or 1 on failure, which currently will happen 391 * if the requested device does not appear to be present in the list. 392 */ 393 394 int del_mtd_device(struct mtd_info *mtd) 395 { 396 int ret; 397 struct mtd_notifier *not; 398 399 mutex_lock(&mtd_table_mutex); 400 401 if (idr_find(&mtd_idr, mtd->index) != mtd) { 402 ret = -ENODEV; 403 goto out_error; 404 } 405 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->remove(mtd); 410 411 if (mtd->usecount) { 412 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n", 413 mtd->index, mtd->name, mtd->usecount); 414 ret = -EBUSY; 415 } else { 416 device_unregister(&mtd->dev); 417 418 idr_remove(&mtd_idr, mtd->index); 419 420 module_put(THIS_MODULE); 421 ret = 0; 422 } 423 424 out_error: 425 mutex_unlock(&mtd_table_mutex); 426 return ret; 427 } 428 429 /** 430 * mtd_device_parse_register - parse partitions and register an MTD device. 431 * 432 * @mtd: the MTD device to register 433 * @types: the list of MTD partition probes to try, see 434 * 'parse_mtd_partitions()' for more information 435 * @parser_data: MTD partition parser-specific data 436 * @parts: fallback partition information to register, if parsing fails; 437 * only valid if %nr_parts > %0 438 * @nr_parts: the number of partitions in parts, if zero then the full 439 * MTD device is registered if no partition info is found 440 * 441 * This function aggregates MTD partitions parsing (done by 442 * 'parse_mtd_partitions()') and MTD device and partitions registering. It 443 * basically follows the most common pattern found in many MTD drivers: 444 * 445 * * It first tries to probe partitions on MTD device @mtd using parsers 446 * specified in @types (if @types is %NULL, then the default list of parsers 447 * is used, see 'parse_mtd_partitions()' for more information). If none are 448 * found this functions tries to fallback to information specified in 449 * @parts/@nr_parts. 450 * * If any partitioning info was found, this function registers the found 451 * partitions. 452 * * If no partitions were found this function just registers the MTD device 453 * @mtd and exits. 454 * 455 * Returns zero in case of success and a negative error code in case of failure. 456 */ 457 int mtd_device_parse_register(struct mtd_info *mtd, const char **types, 458 struct mtd_part_parser_data *parser_data, 459 const struct mtd_partition *parts, 460 int nr_parts) 461 { 462 int err; 463 struct mtd_partition *real_parts; 464 465 err = parse_mtd_partitions(mtd, types, &real_parts, parser_data); 466 if (err <= 0 && nr_parts && parts) { 467 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts, 468 GFP_KERNEL); 469 if (!real_parts) 470 err = -ENOMEM; 471 else 472 err = nr_parts; 473 } 474 475 if (err > 0) { 476 err = add_mtd_partitions(mtd, real_parts, err); 477 kfree(real_parts); 478 } else if (err == 0) { 479 err = add_mtd_device(mtd); 480 if (err == 1) 481 err = -ENODEV; 482 } 483 484 return err; 485 } 486 EXPORT_SYMBOL_GPL(mtd_device_parse_register); 487 488 /** 489 * mtd_device_unregister - unregister an existing MTD device. 490 * 491 * @master: the MTD device to unregister. This will unregister both the master 492 * and any partitions if registered. 493 */ 494 int mtd_device_unregister(struct mtd_info *master) 495 { 496 int err; 497 498 err = del_mtd_partitions(master); 499 if (err) 500 return err; 501 502 if (!device_is_registered(&master->dev)) 503 return 0; 504 505 return del_mtd_device(master); 506 } 507 EXPORT_SYMBOL_GPL(mtd_device_unregister); 508 509 /** 510 * register_mtd_user - register a 'user' of MTD devices. 511 * @new: pointer to notifier info structure 512 * 513 * Registers a pair of callbacks function to be called upon addition 514 * or removal of MTD devices. Causes the 'add' callback to be immediately 515 * invoked for each MTD device currently present in the system. 516 */ 517 void register_mtd_user (struct mtd_notifier *new) 518 { 519 struct mtd_info *mtd; 520 521 mutex_lock(&mtd_table_mutex); 522 523 list_add(&new->list, &mtd_notifiers); 524 525 __module_get(THIS_MODULE); 526 527 mtd_for_each_device(mtd) 528 new->add(mtd); 529 530 mutex_unlock(&mtd_table_mutex); 531 } 532 EXPORT_SYMBOL_GPL(register_mtd_user); 533 534 /** 535 * unregister_mtd_user - unregister a 'user' of MTD devices. 536 * @old: pointer to notifier info structure 537 * 538 * Removes a callback function pair from the list of 'users' to be 539 * notified upon addition or removal of MTD devices. Causes the 540 * 'remove' callback to be immediately invoked for each MTD device 541 * currently present in the system. 542 */ 543 int unregister_mtd_user (struct mtd_notifier *old) 544 { 545 struct mtd_info *mtd; 546 547 mutex_lock(&mtd_table_mutex); 548 549 module_put(THIS_MODULE); 550 551 mtd_for_each_device(mtd) 552 old->remove(mtd); 553 554 list_del(&old->list); 555 mutex_unlock(&mtd_table_mutex); 556 return 0; 557 } 558 EXPORT_SYMBOL_GPL(unregister_mtd_user); 559 560 /** 561 * get_mtd_device - obtain a validated handle for an MTD device 562 * @mtd: last known address of the required MTD device 563 * @num: internal device number of the required MTD device 564 * 565 * Given a number and NULL address, return the num'th entry in the device 566 * table, if any. Given an address and num == -1, search the device table 567 * for a device with that address and return if it's still present. Given 568 * both, return the num'th driver only if its address matches. Return 569 * error code if not. 570 */ 571 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num) 572 { 573 struct mtd_info *ret = NULL, *other; 574 int err = -ENODEV; 575 576 mutex_lock(&mtd_table_mutex); 577 578 if (num == -1) { 579 mtd_for_each_device(other) { 580 if (other == mtd) { 581 ret = mtd; 582 break; 583 } 584 } 585 } else if (num >= 0) { 586 ret = idr_find(&mtd_idr, num); 587 if (mtd && mtd != ret) 588 ret = NULL; 589 } 590 591 if (!ret) { 592 ret = ERR_PTR(err); 593 goto out; 594 } 595 596 err = __get_mtd_device(ret); 597 if (err) 598 ret = ERR_PTR(err); 599 out: 600 mutex_unlock(&mtd_table_mutex); 601 return ret; 602 } 603 EXPORT_SYMBOL_GPL(get_mtd_device); 604 605 606 int __get_mtd_device(struct mtd_info *mtd) 607 { 608 int err; 609 610 if (!try_module_get(mtd->owner)) 611 return -ENODEV; 612 613 if (mtd->_get_device) { 614 err = mtd->_get_device(mtd); 615 616 if (err) { 617 module_put(mtd->owner); 618 return err; 619 } 620 } 621 mtd->usecount++; 622 return 0; 623 } 624 EXPORT_SYMBOL_GPL(__get_mtd_device); 625 626 /** 627 * get_mtd_device_nm - obtain a validated handle for an MTD device by 628 * device name 629 * @name: MTD device name to open 630 * 631 * This function returns MTD device description structure in case of 632 * success and an error code in case of failure. 633 */ 634 struct mtd_info *get_mtd_device_nm(const char *name) 635 { 636 int err = -ENODEV; 637 struct mtd_info *mtd = NULL, *other; 638 639 mutex_lock(&mtd_table_mutex); 640 641 mtd_for_each_device(other) { 642 if (!strcmp(name, other->name)) { 643 mtd = other; 644 break; 645 } 646 } 647 648 if (!mtd) 649 goto out_unlock; 650 651 err = __get_mtd_device(mtd); 652 if (err) 653 goto out_unlock; 654 655 mutex_unlock(&mtd_table_mutex); 656 return mtd; 657 658 out_unlock: 659 mutex_unlock(&mtd_table_mutex); 660 return ERR_PTR(err); 661 } 662 EXPORT_SYMBOL_GPL(get_mtd_device_nm); 663 664 void put_mtd_device(struct mtd_info *mtd) 665 { 666 mutex_lock(&mtd_table_mutex); 667 __put_mtd_device(mtd); 668 mutex_unlock(&mtd_table_mutex); 669 670 } 671 EXPORT_SYMBOL_GPL(put_mtd_device); 672 673 void __put_mtd_device(struct mtd_info *mtd) 674 { 675 --mtd->usecount; 676 BUG_ON(mtd->usecount < 0); 677 678 if (mtd->_put_device) 679 mtd->_put_device(mtd); 680 681 module_put(mtd->owner); 682 } 683 EXPORT_SYMBOL_GPL(__put_mtd_device); 684 685 /* 686 * Erase is an asynchronous operation. Device drivers are supposed 687 * to call instr->callback() whenever the operation completes, even 688 * if it completes with a failure. 689 * Callers are supposed to pass a callback function and wait for it 690 * to be called before writing to the block. 691 */ 692 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 693 { 694 if (instr->addr > mtd->size || instr->len > mtd->size - instr->addr) 695 return -EINVAL; 696 if (!(mtd->flags & MTD_WRITEABLE)) 697 return -EROFS; 698 return mtd->_erase(mtd, instr); 699 } 700 EXPORT_SYMBOL_GPL(mtd_erase); 701 702 /* 703 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL. 704 */ 705 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 706 void **virt, resource_size_t *phys) 707 { 708 *retlen = 0; 709 if (!mtd->_point) 710 return -EOPNOTSUPP; 711 if (from < 0 || from > mtd->size || len > mtd->size - from) 712 return -EINVAL; 713 return mtd->_point(mtd, from, len, retlen, virt, phys); 714 } 715 EXPORT_SYMBOL_GPL(mtd_point); 716 717 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ 718 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 719 { 720 if (!mtd->_point) 721 return -EOPNOTSUPP; 722 if (from < 0 || from > mtd->size || len > mtd->size - from) 723 return -EINVAL; 724 return mtd->_unpoint(mtd, from, len); 725 } 726 EXPORT_SYMBOL_GPL(mtd_unpoint); 727 728 /* 729 * Allow NOMMU mmap() to directly map the device (if not NULL) 730 * - return the address to which the offset maps 731 * - return -ENOSYS to indicate refusal to do the mapping 732 */ 733 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 734 unsigned long offset, unsigned long flags) 735 { 736 if (!mtd->_get_unmapped_area) 737 return -EOPNOTSUPP; 738 if (offset > mtd->size || len > mtd->size - offset) 739 return -EINVAL; 740 return mtd->_get_unmapped_area(mtd, len, offset, flags); 741 } 742 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area); 743 744 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 745 u_char *buf) 746 { 747 if (from < 0 || from > mtd->size || len > mtd->size - from) 748 return -EINVAL; 749 return mtd->_read(mtd, from, len, retlen, buf); 750 } 751 EXPORT_SYMBOL_GPL(mtd_read); 752 753 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 754 const u_char *buf) 755 { 756 *retlen = 0; 757 if (to < 0 || to > mtd->size || len > mtd->size - to) 758 return -EINVAL; 759 if (!mtd->_write || !(mtd->flags & MTD_WRITEABLE)) 760 return -EROFS; 761 return mtd->_write(mtd, to, len, retlen, buf); 762 } 763 EXPORT_SYMBOL_GPL(mtd_write); 764 765 /* 766 * In blackbox flight recorder like scenarios we want to make successful writes 767 * in interrupt context. panic_write() is only intended to be called when its 768 * known the kernel is about to panic and we need the write to succeed. Since 769 * the kernel is not going to be running for much longer, this function can 770 * break locks and delay to ensure the write succeeds (but not sleep). 771 */ 772 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 773 const u_char *buf) 774 { 775 *retlen = 0; 776 if (!mtd->_panic_write) 777 return -EOPNOTSUPP; 778 if (to < 0 || to > mtd->size || len > mtd->size - to) 779 return -EINVAL; 780 if (!(mtd->flags & MTD_WRITEABLE)) 781 return -EROFS; 782 return mtd->_panic_write(mtd, to, len, retlen, buf); 783 } 784 EXPORT_SYMBOL_GPL(mtd_panic_write); 785 786 /* Chip-supported device locking */ 787 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 788 { 789 if (!mtd->_lock) 790 return -EOPNOTSUPP; 791 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 792 return -EINVAL; 793 return mtd->_lock(mtd, ofs, len); 794 } 795 EXPORT_SYMBOL_GPL(mtd_lock); 796 797 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 798 { 799 if (!mtd->_unlock) 800 return -EOPNOTSUPP; 801 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 802 return -EINVAL; 803 return mtd->_unlock(mtd, ofs, len); 804 } 805 EXPORT_SYMBOL_GPL(mtd_unlock); 806 807 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 808 { 809 if (!mtd->_is_locked) 810 return -EOPNOTSUPP; 811 if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 812 return -EINVAL; 813 return mtd->_is_locked(mtd, ofs, len); 814 } 815 EXPORT_SYMBOL_GPL(mtd_is_locked); 816 817 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs) 818 { 819 if (!mtd->_block_isbad) 820 return 0; 821 if (ofs < 0 || ofs > mtd->size) 822 return -EINVAL; 823 return mtd->_block_isbad(mtd, ofs); 824 } 825 EXPORT_SYMBOL_GPL(mtd_block_isbad); 826 827 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs) 828 { 829 if (!mtd->_block_markbad) 830 return -EOPNOTSUPP; 831 if (ofs < 0 || ofs > mtd->size) 832 return -EINVAL; 833 if (!(mtd->flags & MTD_WRITEABLE)) 834 return -EROFS; 835 return mtd->_block_markbad(mtd, ofs); 836 } 837 EXPORT_SYMBOL_GPL(mtd_block_markbad); 838 839 /* 840 * default_mtd_writev - the default writev method 841 * @mtd: mtd device description object pointer 842 * @vecs: the vectors to write 843 * @count: count of vectors in @vecs 844 * @to: the MTD device offset to write to 845 * @retlen: on exit contains the count of bytes written to the MTD device. 846 * 847 * This function returns zero in case of success and a negative error code in 848 * case of failure. 849 */ 850 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 851 unsigned long count, loff_t to, size_t *retlen) 852 { 853 unsigned long i; 854 size_t totlen = 0, thislen; 855 int ret = 0; 856 857 for (i = 0; i < count; i++) { 858 if (!vecs[i].iov_len) 859 continue; 860 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen, 861 vecs[i].iov_base); 862 totlen += thislen; 863 if (ret || thislen != vecs[i].iov_len) 864 break; 865 to += vecs[i].iov_len; 866 } 867 *retlen = totlen; 868 return ret; 869 } 870 871 /* 872 * mtd_writev - the vector-based MTD write method 873 * @mtd: mtd device description object pointer 874 * @vecs: the vectors to write 875 * @count: count of vectors in @vecs 876 * @to: the MTD device offset to write to 877 * @retlen: on exit contains the count of bytes written to the MTD device. 878 * 879 * This function returns zero in case of success and a negative error code in 880 * case of failure. 881 */ 882 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 883 unsigned long count, loff_t to, size_t *retlen) 884 { 885 *retlen = 0; 886 if (!(mtd->flags & MTD_WRITEABLE)) 887 return -EROFS; 888 if (!mtd->_writev) 889 return default_mtd_writev(mtd, vecs, count, to, retlen); 890 return mtd->_writev(mtd, vecs, count, to, retlen); 891 } 892 EXPORT_SYMBOL_GPL(mtd_writev); 893 894 /** 895 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size 896 * @mtd: mtd device description object pointer 897 * @size: a pointer to the ideal or maximum size of the allocation, points 898 * to the actual allocation size on success. 899 * 900 * This routine attempts to allocate a contiguous kernel buffer up to 901 * the specified size, backing off the size of the request exponentially 902 * until the request succeeds or until the allocation size falls below 903 * the system page size. This attempts to make sure it does not adversely 904 * impact system performance, so when allocating more than one page, we 905 * ask the memory allocator to avoid re-trying, swapping, writing back 906 * or performing I/O. 907 * 908 * Note, this function also makes sure that the allocated buffer is aligned to 909 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value. 910 * 911 * This is called, for example by mtd_{read,write} and jffs2_scan_medium, 912 * to handle smaller (i.e. degraded) buffer allocations under low- or 913 * fragmented-memory situations where such reduced allocations, from a 914 * requested ideal, are allowed. 915 * 916 * Returns a pointer to the allocated buffer on success; otherwise, NULL. 917 */ 918 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size) 919 { 920 gfp_t flags = __GFP_NOWARN | __GFP_WAIT | 921 __GFP_NORETRY | __GFP_NO_KSWAPD; 922 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE); 923 void *kbuf; 924 925 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE); 926 927 while (*size > min_alloc) { 928 kbuf = kmalloc(*size, flags); 929 if (kbuf) 930 return kbuf; 931 932 *size >>= 1; 933 *size = ALIGN(*size, mtd->writesize); 934 } 935 936 /* 937 * For the last resort allocation allow 'kmalloc()' to do all sorts of 938 * things (write-back, dropping caches, etc) by using GFP_KERNEL. 939 */ 940 return kmalloc(*size, GFP_KERNEL); 941 } 942 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to); 943 944 #ifdef CONFIG_PROC_FS 945 946 /*====================================================================*/ 947 /* Support for /proc/mtd */ 948 949 static struct proc_dir_entry *proc_mtd; 950 951 static int mtd_proc_show(struct seq_file *m, void *v) 952 { 953 struct mtd_info *mtd; 954 955 seq_puts(m, "dev: size erasesize name\n"); 956 mutex_lock(&mtd_table_mutex); 957 mtd_for_each_device(mtd) { 958 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n", 959 mtd->index, (unsigned long long)mtd->size, 960 mtd->erasesize, mtd->name); 961 } 962 mutex_unlock(&mtd_table_mutex); 963 return 0; 964 } 965 966 static int mtd_proc_open(struct inode *inode, struct file *file) 967 { 968 return single_open(file, mtd_proc_show, NULL); 969 } 970 971 static const struct file_operations mtd_proc_ops = { 972 .open = mtd_proc_open, 973 .read = seq_read, 974 .llseek = seq_lseek, 975 .release = single_release, 976 }; 977 #endif /* CONFIG_PROC_FS */ 978 979 /*====================================================================*/ 980 /* Init code */ 981 982 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name) 983 { 984 int ret; 985 986 ret = bdi_init(bdi); 987 if (!ret) 988 ret = bdi_register(bdi, NULL, name); 989 990 if (ret) 991 bdi_destroy(bdi); 992 993 return ret; 994 } 995 996 static int __init init_mtd(void) 997 { 998 int ret; 999 1000 ret = class_register(&mtd_class); 1001 if (ret) 1002 goto err_reg; 1003 1004 ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap"); 1005 if (ret) 1006 goto err_bdi1; 1007 1008 ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap"); 1009 if (ret) 1010 goto err_bdi2; 1011 1012 ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap"); 1013 if (ret) 1014 goto err_bdi3; 1015 1016 #ifdef CONFIG_PROC_FS 1017 proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops); 1018 #endif /* CONFIG_PROC_FS */ 1019 return 0; 1020 1021 err_bdi3: 1022 bdi_destroy(&mtd_bdi_ro_mappable); 1023 err_bdi2: 1024 bdi_destroy(&mtd_bdi_unmappable); 1025 err_bdi1: 1026 class_unregister(&mtd_class); 1027 err_reg: 1028 pr_err("Error registering mtd class or bdi: %d\n", ret); 1029 return ret; 1030 } 1031 1032 static void __exit cleanup_mtd(void) 1033 { 1034 #ifdef CONFIG_PROC_FS 1035 if (proc_mtd) 1036 remove_proc_entry( "mtd", NULL); 1037 #endif /* CONFIG_PROC_FS */ 1038 class_unregister(&mtd_class); 1039 bdi_destroy(&mtd_bdi_unmappable); 1040 bdi_destroy(&mtd_bdi_ro_mappable); 1041 bdi_destroy(&mtd_bdi_rw_mappable); 1042 } 1043 1044 module_init(init_mtd); 1045 module_exit(cleanup_mtd); 1046 1047 MODULE_LICENSE("GPL"); 1048 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 1049 MODULE_DESCRIPTION("Core MTD registration and access routines"); 1050