mtdcore.c revision 92394b5c2be774425f255b5c7afbd8b19978fe12
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 dev_t index = MTD_DEVT(dev_to_mtd(dev)->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_to_mtd(dev); 120 121 if (mtd && mtd->suspend) 122 return mtd->suspend(mtd); 123 else 124 return 0; 125} 126 127static int mtd_cls_resume(struct device *dev) 128{ 129 struct mtd_info *mtd = dev_to_mtd(dev); 130 131 if (mtd && mtd->resume) 132 mtd->resume(mtd); 133 return 0; 134} 135 136static ssize_t mtd_type_show(struct device *dev, 137 struct device_attribute *attr, char *buf) 138{ 139 struct mtd_info *mtd = dev_to_mtd(dev); 140 char *type; 141 142 switch (mtd->type) { 143 case MTD_ABSENT: 144 type = "absent"; 145 break; 146 case MTD_RAM: 147 type = "ram"; 148 break; 149 case MTD_ROM: 150 type = "rom"; 151 break; 152 case MTD_NORFLASH: 153 type = "nor"; 154 break; 155 case MTD_NANDFLASH: 156 type = "nand"; 157 break; 158 case MTD_DATAFLASH: 159 type = "dataflash"; 160 break; 161 case MTD_UBIVOLUME: 162 type = "ubi"; 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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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 struct attribute *mtd_attrs[] = { 256 &dev_attr_type.attr, 257 &dev_attr_flags.attr, 258 &dev_attr_size.attr, 259 &dev_attr_erasesize.attr, 260 &dev_attr_writesize.attr, 261 &dev_attr_subpagesize.attr, 262 &dev_attr_oobsize.attr, 263 &dev_attr_numeraseregions.attr, 264 &dev_attr_name.attr, 265 NULL, 266}; 267 268static struct attribute_group mtd_group = { 269 .attrs = mtd_attrs, 270}; 271 272static const struct attribute_group *mtd_groups[] = { 273 &mtd_group, 274 NULL, 275}; 276 277static struct device_type mtd_devtype = { 278 .name = "mtd", 279 .groups = mtd_groups, 280 .release = mtd_release, 281}; 282 283/** 284 * add_mtd_device - register an MTD device 285 * @mtd: pointer to new MTD device info structure 286 * 287 * Add a device to the list of MTD devices present in the system, and 288 * notify each currently active MTD 'user' of its arrival. Returns 289 * zero on success or 1 on failure, which currently will only happen 290 * if there is insufficient memory or a sysfs error. 291 */ 292 293int add_mtd_device(struct mtd_info *mtd) 294{ 295 struct mtd_notifier *not; 296 int i, error; 297 298 if (!mtd->backing_dev_info) { 299 switch (mtd->type) { 300 case MTD_RAM: 301 mtd->backing_dev_info = &mtd_bdi_rw_mappable; 302 break; 303 case MTD_ROM: 304 mtd->backing_dev_info = &mtd_bdi_ro_mappable; 305 break; 306 default: 307 mtd->backing_dev_info = &mtd_bdi_unmappable; 308 break; 309 } 310 } 311 312 BUG_ON(mtd->writesize == 0); 313 mutex_lock(&mtd_table_mutex); 314 315 do { 316 if (!idr_pre_get(&mtd_idr, GFP_KERNEL)) 317 goto fail_locked; 318 error = idr_get_new(&mtd_idr, mtd, &i); 319 } while (error == -EAGAIN); 320 321 if (error) 322 goto fail_locked; 323 324 mtd->index = i; 325 mtd->usecount = 0; 326 327 if (is_power_of_2(mtd->erasesize)) 328 mtd->erasesize_shift = ffs(mtd->erasesize) - 1; 329 else 330 mtd->erasesize_shift = 0; 331 332 if (is_power_of_2(mtd->writesize)) 333 mtd->writesize_shift = ffs(mtd->writesize) - 1; 334 else 335 mtd->writesize_shift = 0; 336 337 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1; 338 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1; 339 340 /* Some chips always power up locked. Unlock them now */ 341 if ((mtd->flags & MTD_WRITEABLE) 342 && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) { 343 if (mtd->unlock(mtd, 0, mtd->size)) 344 printk(KERN_WARNING 345 "%s: unlock failed, writes may not work\n", 346 mtd->name); 347 } 348 349 /* Caller should have set dev.parent to match the 350 * physical device. 351 */ 352 mtd->dev.type = &mtd_devtype; 353 mtd->dev.class = &mtd_class; 354 mtd->dev.devt = MTD_DEVT(i); 355 dev_set_name(&mtd->dev, "mtd%d", i); 356 dev_set_drvdata(&mtd->dev, mtd); 357 if (device_register(&mtd->dev) != 0) 358 goto fail_added; 359 360 if (MTD_DEVT(i)) 361 device_create(&mtd_class, mtd->dev.parent, 362 MTD_DEVT(i) + 1, 363 NULL, "mtd%dro", i); 364 365 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name); 366 /* No need to get a refcount on the module containing 367 the notifier, since we hold the mtd_table_mutex */ 368 list_for_each_entry(not, &mtd_notifiers, list) 369 not->add(mtd); 370 371 mutex_unlock(&mtd_table_mutex); 372 /* We _know_ we aren't being removed, because 373 our caller is still holding us here. So none 374 of this try_ nonsense, and no bitching about it 375 either. :) */ 376 __module_get(THIS_MODULE); 377 return 0; 378 379fail_added: 380 idr_remove(&mtd_idr, i); 381fail_locked: 382 mutex_unlock(&mtd_table_mutex); 383 return 1; 384} 385 386/** 387 * del_mtd_device - unregister an MTD device 388 * @mtd: pointer to MTD device info structure 389 * 390 * Remove a device from the list of MTD devices present in the system, 391 * and notify each currently active MTD 'user' of its departure. 392 * Returns zero on success or 1 on failure, which currently will happen 393 * if the requested device does not appear to be present in the list. 394 */ 395 396int del_mtd_device(struct mtd_info *mtd) 397{ 398 int ret; 399 struct mtd_notifier *not; 400 401 mutex_lock(&mtd_table_mutex); 402 403 if (idr_find(&mtd_idr, mtd->index) != mtd) { 404 ret = -ENODEV; 405 goto out_error; 406 } 407 408 /* No need to get a refcount on the module containing 409 the notifier, since we hold the mtd_table_mutex */ 410 list_for_each_entry(not, &mtd_notifiers, list) 411 not->remove(mtd); 412 413 if (mtd->usecount) { 414 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n", 415 mtd->index, mtd->name, mtd->usecount); 416 ret = -EBUSY; 417 } else { 418 device_unregister(&mtd->dev); 419 420 idr_remove(&mtd_idr, mtd->index); 421 422 module_put(THIS_MODULE); 423 ret = 0; 424 } 425 426out_error: 427 mutex_unlock(&mtd_table_mutex); 428 return ret; 429} 430 431/** 432 * mtd_device_parse_register - parse partitions and register an MTD device. 433 * 434 * @mtd: the MTD device to register 435 * @types: the list of MTD partition probes to try, see 436 * 'parse_mtd_partitions()' for more information 437 * @parser_data: MTD partition parser-specific data 438 * @parts: fallback partition information to register, if parsing fails; 439 * only valid if %nr_parts > %0 440 * @nr_parts: the number of partitions in parts, if zero then the full 441 * MTD device is registered if no partition info is found 442 * 443 * This function aggregates MTD partitions parsing (done by 444 * 'parse_mtd_partitions()') and MTD device and partitions registering. It 445 * basically follows the most common pattern found in many MTD drivers: 446 * 447 * * It first tries to probe partitions on MTD device @mtd using parsers 448 * specified in @types (if @types is %NULL, then the default list of parsers 449 * is used, see 'parse_mtd_partitions()' for more information). If none are 450 * found this functions tries to fallback to information specified in 451 * @parts/@nr_parts. 452 * * If any partitioning info was found, this function registers the found 453 * partitions. 454 * * If no partitions were found this function just registers the MTD device 455 * @mtd and exits. 456 * 457 * Returns zero in case of success and a negative error code in case of failure. 458 */ 459int mtd_device_parse_register(struct mtd_info *mtd, const char **types, 460 struct mtd_part_parser_data *parser_data, 461 const struct mtd_partition *parts, 462 int nr_parts) 463{ 464 int err; 465 struct mtd_partition *real_parts; 466 467 err = parse_mtd_partitions(mtd, types, &real_parts, parser_data); 468 if (err <= 0 && nr_parts) { 469 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts, 470 GFP_KERNEL); 471 err = nr_parts; 472 if (!parts) 473 err = -ENOMEM; 474 } 475 476 if (err > 0) { 477 err = add_mtd_partitions(mtd, real_parts, err); 478 kfree(real_parts); 479 } else if (err == 0) { 480 err = add_mtd_device(mtd); 481 if (err == 1) 482 err = -ENODEV; 483 } 484 485 return err; 486} 487EXPORT_SYMBOL_GPL(mtd_device_parse_register); 488 489/** 490 * mtd_device_unregister - unregister an existing MTD device. 491 * 492 * @master: the MTD device to unregister. This will unregister both the master 493 * and any partitions if registered. 494 */ 495int mtd_device_unregister(struct mtd_info *master) 496{ 497 int err; 498 499 err = del_mtd_partitions(master); 500 if (err) 501 return err; 502 503 if (!device_is_registered(&master->dev)) 504 return 0; 505 506 return del_mtd_device(master); 507} 508EXPORT_SYMBOL_GPL(mtd_device_unregister); 509 510/** 511 * register_mtd_user - register a 'user' of MTD devices. 512 * @new: pointer to notifier info structure 513 * 514 * Registers a pair of callbacks function to be called upon addition 515 * or removal of MTD devices. Causes the 'add' callback to be immediately 516 * invoked for each MTD device currently present in the system. 517 */ 518 519void register_mtd_user (struct mtd_notifier *new) 520{ 521 struct mtd_info *mtd; 522 523 mutex_lock(&mtd_table_mutex); 524 525 list_add(&new->list, &mtd_notifiers); 526 527 __module_get(THIS_MODULE); 528 529 mtd_for_each_device(mtd) 530 new->add(mtd); 531 532 mutex_unlock(&mtd_table_mutex); 533} 534 535/** 536 * unregister_mtd_user - unregister a 'user' of MTD devices. 537 * @old: pointer to notifier info structure 538 * 539 * Removes a callback function pair from the list of 'users' to be 540 * notified upon addition or removal of MTD devices. Causes the 541 * 'remove' callback to be immediately invoked for each MTD device 542 * currently present in the system. 543 */ 544 545int unregister_mtd_user (struct mtd_notifier *old) 546{ 547 struct mtd_info *mtd; 548 549 mutex_lock(&mtd_table_mutex); 550 551 module_put(THIS_MODULE); 552 553 mtd_for_each_device(mtd) 554 old->remove(mtd); 555 556 list_del(&old->list); 557 mutex_unlock(&mtd_table_mutex); 558 return 0; 559} 560 561 562/** 563 * get_mtd_device - obtain a validated handle for an MTD device 564 * @mtd: last known address of the required MTD device 565 * @num: internal device number of the required MTD device 566 * 567 * Given a number and NULL address, return the num'th entry in the device 568 * table, if any. Given an address and num == -1, search the device table 569 * for a device with that address and return if it's still present. Given 570 * both, return the num'th driver only if its address matches. Return 571 * error code if not. 572 */ 573 574struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num) 575{ 576 struct mtd_info *ret = NULL, *other; 577 int err = -ENODEV; 578 579 mutex_lock(&mtd_table_mutex); 580 581 if (num == -1) { 582 mtd_for_each_device(other) { 583 if (other == mtd) { 584 ret = mtd; 585 break; 586 } 587 } 588 } else if (num >= 0) { 589 ret = idr_find(&mtd_idr, num); 590 if (mtd && mtd != ret) 591 ret = NULL; 592 } 593 594 if (!ret) { 595 ret = ERR_PTR(err); 596 goto out; 597 } 598 599 err = __get_mtd_device(ret); 600 if (err) 601 ret = ERR_PTR(err); 602out: 603 mutex_unlock(&mtd_table_mutex); 604 return ret; 605} 606 607 608int __get_mtd_device(struct mtd_info *mtd) 609{ 610 int err; 611 612 if (!try_module_get(mtd->owner)) 613 return -ENODEV; 614 615 if (mtd->get_device) { 616 err = mtd->get_device(mtd); 617 618 if (err) { 619 module_put(mtd->owner); 620 return err; 621 } 622 } 623 mtd->usecount++; 624 return 0; 625} 626 627/** 628 * get_mtd_device_nm - obtain a validated handle for an MTD device by 629 * device name 630 * @name: MTD device name to open 631 * 632 * This function returns MTD device description structure in case of 633 * success and an error code in case of failure. 634 */ 635 636struct mtd_info *get_mtd_device_nm(const char *name) 637{ 638 int err = -ENODEV; 639 struct mtd_info *mtd = NULL, *other; 640 641 mutex_lock(&mtd_table_mutex); 642 643 mtd_for_each_device(other) { 644 if (!strcmp(name, other->name)) { 645 mtd = other; 646 break; 647 } 648 } 649 650 if (!mtd) 651 goto out_unlock; 652 653 err = __get_mtd_device(mtd); 654 if (err) 655 goto out_unlock; 656 657 mutex_unlock(&mtd_table_mutex); 658 return mtd; 659 660out_unlock: 661 mutex_unlock(&mtd_table_mutex); 662 return ERR_PTR(err); 663} 664 665void put_mtd_device(struct mtd_info *mtd) 666{ 667 mutex_lock(&mtd_table_mutex); 668 __put_mtd_device(mtd); 669 mutex_unlock(&mtd_table_mutex); 670 671} 672 673void __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 684/* default_mtd_writev - default mtd writev method for MTD devices that 685 * don't implement their own 686 */ 687 688int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 689 unsigned long count, loff_t to, size_t *retlen) 690{ 691 unsigned long i; 692 size_t totlen = 0, thislen; 693 int ret = 0; 694 695 if(!mtd->write) { 696 ret = -EROFS; 697 } else { 698 for (i=0; i<count; i++) { 699 if (!vecs[i].iov_len) 700 continue; 701 ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base); 702 totlen += thislen; 703 if (ret || thislen != vecs[i].iov_len) 704 break; 705 to += vecs[i].iov_len; 706 } 707 } 708 if (retlen) 709 *retlen = totlen; 710 return ret; 711} 712 713/** 714 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size 715 * @size: A pointer to the ideal or maximum size of the allocation. Points 716 * to the actual allocation size on success. 717 * 718 * This routine attempts to allocate a contiguous kernel buffer up to 719 * the specified size, backing off the size of the request exponentially 720 * until the request succeeds or until the allocation size falls below 721 * the system page size. This attempts to make sure it does not adversely 722 * impact system performance, so when allocating more than one page, we 723 * ask the memory allocator to avoid re-trying, swapping, writing back 724 * or performing I/O. 725 * 726 * Note, this function also makes sure that the allocated buffer is aligned to 727 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value. 728 * 729 * This is called, for example by mtd_{read,write} and jffs2_scan_medium, 730 * to handle smaller (i.e. degraded) buffer allocations under low- or 731 * fragmented-memory situations where such reduced allocations, from a 732 * requested ideal, are allowed. 733 * 734 * Returns a pointer to the allocated buffer on success; otherwise, NULL. 735 */ 736void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size) 737{ 738 gfp_t flags = __GFP_NOWARN | __GFP_WAIT | 739 __GFP_NORETRY | __GFP_NO_KSWAPD; 740 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE); 741 void *kbuf; 742 743 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE); 744 745 while (*size > min_alloc) { 746 kbuf = kmalloc(*size, flags); 747 if (kbuf) 748 return kbuf; 749 750 *size >>= 1; 751 *size = ALIGN(*size, mtd->writesize); 752 } 753 754 /* 755 * For the last resort allocation allow 'kmalloc()' to do all sorts of 756 * things (write-back, dropping caches, etc) by using GFP_KERNEL. 757 */ 758 return kmalloc(*size, GFP_KERNEL); 759} 760 761EXPORT_SYMBOL_GPL(get_mtd_device); 762EXPORT_SYMBOL_GPL(get_mtd_device_nm); 763EXPORT_SYMBOL_GPL(__get_mtd_device); 764EXPORT_SYMBOL_GPL(put_mtd_device); 765EXPORT_SYMBOL_GPL(__put_mtd_device); 766EXPORT_SYMBOL_GPL(register_mtd_user); 767EXPORT_SYMBOL_GPL(unregister_mtd_user); 768EXPORT_SYMBOL_GPL(default_mtd_writev); 769EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to); 770 771#ifdef CONFIG_PROC_FS 772 773/*====================================================================*/ 774/* Support for /proc/mtd */ 775 776static struct proc_dir_entry *proc_mtd; 777 778static int mtd_proc_show(struct seq_file *m, void *v) 779{ 780 struct mtd_info *mtd; 781 782 seq_puts(m, "dev: size erasesize name\n"); 783 mutex_lock(&mtd_table_mutex); 784 mtd_for_each_device(mtd) { 785 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n", 786 mtd->index, (unsigned long long)mtd->size, 787 mtd->erasesize, mtd->name); 788 } 789 mutex_unlock(&mtd_table_mutex); 790 return 0; 791} 792 793static int mtd_proc_open(struct inode *inode, struct file *file) 794{ 795 return single_open(file, mtd_proc_show, NULL); 796} 797 798static const struct file_operations mtd_proc_ops = { 799 .open = mtd_proc_open, 800 .read = seq_read, 801 .llseek = seq_lseek, 802 .release = single_release, 803}; 804#endif /* CONFIG_PROC_FS */ 805 806/*====================================================================*/ 807/* Init code */ 808 809static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name) 810{ 811 int ret; 812 813 ret = bdi_init(bdi); 814 if (!ret) 815 ret = bdi_register(bdi, NULL, name); 816 817 if (ret) 818 bdi_destroy(bdi); 819 820 return ret; 821} 822 823static int __init init_mtd(void) 824{ 825 int ret; 826 827 ret = class_register(&mtd_class); 828 if (ret) 829 goto err_reg; 830 831 ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap"); 832 if (ret) 833 goto err_bdi1; 834 835 ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap"); 836 if (ret) 837 goto err_bdi2; 838 839 ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap"); 840 if (ret) 841 goto err_bdi3; 842 843#ifdef CONFIG_PROC_FS 844 proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops); 845#endif /* CONFIG_PROC_FS */ 846 return 0; 847 848err_bdi3: 849 bdi_destroy(&mtd_bdi_ro_mappable); 850err_bdi2: 851 bdi_destroy(&mtd_bdi_unmappable); 852err_bdi1: 853 class_unregister(&mtd_class); 854err_reg: 855 pr_err("Error registering mtd class or bdi: %d\n", ret); 856 return ret; 857} 858 859static void __exit cleanup_mtd(void) 860{ 861#ifdef CONFIG_PROC_FS 862 if (proc_mtd) 863 remove_proc_entry( "mtd", NULL); 864#endif /* CONFIG_PROC_FS */ 865 class_unregister(&mtd_class); 866 bdi_destroy(&mtd_bdi_unmappable); 867 bdi_destroy(&mtd_bdi_ro_mappable); 868 bdi_destroy(&mtd_bdi_rw_mappable); 869} 870 871module_init(init_mtd); 872module_exit(cleanup_mtd); 873 874MODULE_LICENSE("GPL"); 875MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 876MODULE_DESCRIPTION("Core MTD registration and access routines"); 877