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