drivers/mtd/mtdcore.c

   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/string.h>
  28 #include <linux/timer.h>
  29 #include <linux/major.h>
  30 #include <linux/fs.h>
  31 #include <linux/err.h>
  32 #include <linux/ioctl.h>
  33 #include <linux/init.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/idr.h>
  36 #include <linux/backing-dev.h>
  37 #include <linux/gfp.h>
  38
  39 #include <linux/mtd/mtd.h>
  40
  41 #include "mtdcore.h"
  42 /*
  43  * backing device capabilities for non-mappable devices (such as NAND flash)
  44  * - permits private mappings, copies are taken of the data
  45  */
  46 struct backing_dev_info mtd_bdi_unmappable = {
  47         .capabilities   = BDI_CAP_MAP_COPY,
  48 };
  49
  50 /*
  51  * backing device capabilities for R/O mappable devices (such as ROM)
  52  * - permits private mappings, copies are taken of the data
  53  * - permits non-writable shared mappings
  54  */
  55 struct backing_dev_info mtd_bdi_ro_mappable = {
  56         .capabilities   = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
  57                            BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP),
  58 };
  59
  60 /*
  61  * backing device capabilities for writable mappable devices (such as RAM)
  62  * - permits private mappings, copies are taken of the data
  63  * - permits non-writable shared mappings
  64  */
  65 struct backing_dev_info mtd_bdi_rw_mappable = {
  66         .capabilities   = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
  67                            BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP |
  68                            BDI_CAP_WRITE_MAP),
  69 };
  70
  71 static int mtd_cls_suspend(struct device *dev, pm_message_t state);
  72 static int mtd_cls_resume(struct device *dev);
  73
  74 static struct class mtd_class = {
  75         .name = "mtd",
  76         .owner = THIS_MODULE,
  77         .suspend = mtd_cls_suspend,
  78         .resume = mtd_cls_resume,
  79 };
  80
  81 static DEFINE_IDR(mtd_idr);
  82
  83 /* These are exported solely for the purpose of mtd_blkdevs.c. You
  84    should not use them for _anything_ else */
  85 DEFINE_MUTEX(mtd_table_mutex);
  86 EXPORT_SYMBOL_GPL(mtd_table_mutex);
  87
  88 struct mtd_info *__mtd_next_device(int i)
  89 {
  90         return idr_get_next(&mtd_idr, &i);
  91 }
  92 EXPORT_SYMBOL_GPL(__mtd_next_device);
  93
  94 static LIST_HEAD(mtd_notifiers);
  95
  96
  97 #if defined(CONFIG_MTD_CHAR) || defined(CONFIG_MTD_CHAR_MODULE)
  98 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
  99 #else
 100 #define MTD_DEVT(index) 0
 101 #endif
 102
 103 /* REVISIT once MTD uses the driver model better, whoever allocates
 104  * the mtd_info will probably want to use the release() hook...
 105  */
 106 static void mtd_release(struct device *dev)
 107 {
 108         dev_t index = MTD_DEVT(dev_to_mtd(dev)->index);
 109
 110         /* remove /dev/mtdXro node if needed */
 111         if (index)
 112                 device_destroy(&mtd_class, index + 1);
 113 }
 114
 115 static int mtd_cls_suspend(struct device *dev, pm_message_t state)
 116 {
 117         struct mtd_info *mtd = dev_to_mtd(dev);
 118
 119         if (mtd && mtd->suspend)
 120                 return mtd->suspend(mtd);
 121         else
 122                 return 0;
 123 }
 124
 125 static int mtd_cls_resume(struct device *dev)
 126 {
 127         struct mtd_info *mtd = dev_to_mtd(dev);
 128
 129         if (mtd && mtd->resume)
 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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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_to_mtd(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)
 340             && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
 341                 if (mtd->unlock(mtd, 0, mtd->size))
 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         DEBUG(0, "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  *      register_mtd_user - register a 'user' of MTD devices.
 431  *      @new: pointer to notifier info structure
 432  *
 433  *      Registers a pair of callbacks function to be called upon addition
 434  *      or removal of MTD devices. Causes the 'add' callback to be immediately
 435  *      invoked for each MTD device currently present in the system.
 436  */
 437
 438 void register_mtd_user (struct mtd_notifier *new)
 439 {
 440         struct mtd_info *mtd;
 441
 442         mutex_lock(&mtd_table_mutex);
 443
 444         list_add(&new->list, &mtd_notifiers);
 445
 446         __module_get(THIS_MODULE);
 447
 448         mtd_for_each_device(mtd)
 449                 new->add(mtd);
 450
 451         mutex_unlock(&mtd_table_mutex);
 452 }
 453
 454 /**
 455  *      unregister_mtd_user - unregister a 'user' of MTD devices.
 456  *      @old: pointer to notifier info structure
 457  *
 458  *      Removes a callback function pair from the list of 'users' to be
 459  *      notified upon addition or removal of MTD devices. Causes the
 460  *      'remove' callback to be immediately invoked for each MTD device
 461  *      currently present in the system.
 462  */
 463
 464 int unregister_mtd_user (struct mtd_notifier *old)
 465 {
 466         struct mtd_info *mtd;
 467
 468         mutex_lock(&mtd_table_mutex);
 469
 470         module_put(THIS_MODULE);
 471
 472         mtd_for_each_device(mtd)
 473                 old->remove(mtd);
 474
 475         list_del(&old->list);
 476         mutex_unlock(&mtd_table_mutex);
 477         return 0;
 478 }
 479
 480
 481 /**
 482  *      get_mtd_device - obtain a validated handle for an MTD device
 483  *      @mtd: last known address of the required MTD device
 484  *      @num: internal device number of the required MTD device
 485  *
 486  *      Given a number and NULL address, return the num'th entry in the device
 487  *      table, if any.  Given an address and num == -1, search the device table
 488  *      for a device with that address and return if it's still present. Given
 489  *      both, return the num'th driver only if its address matches. Return
 490  *      error code if not.
 491  */
 492
 493 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
 494 {
 495         struct mtd_info *ret = NULL, *other;
 496         int err = -ENODEV;
 497
 498         mutex_lock(&mtd_table_mutex);
 499
 500         if (num == -1) {
 501                 mtd_for_each_device(other) {
 502                         if (other == mtd) {
 503                                 ret = mtd;
 504                                 break;
 505                         }
 506                 }
 507         } else if (num >= 0) {
 508                 ret = idr_find(&mtd_idr, num);
 509                 if (mtd && mtd != ret)
 510                         ret = NULL;
 511         }
 512
 513         if (!ret) {
 514                 ret = ERR_PTR(err);
 515                 goto out;
 516         }
 517
 518         err = __get_mtd_device(ret);
 519         if (err)
 520                 ret = ERR_PTR(err);
 521 out:
 522         mutex_unlock(&mtd_table_mutex);
 523         return ret;
 524 }
 525
 526
 527 int __get_mtd_device(struct mtd_info *mtd)
 528 {
 529         int err;
 530
 531         if (!try_module_get(mtd->owner))
 532                 return -ENODEV;
 533
 534         if (mtd->get_device) {
 535
 536                 err = mtd->get_device(mtd);
 537
 538                 if (err) {
 539                         module_put(mtd->owner);
 540                         return err;
 541                 }
 542         }
 543         mtd->usecount++;
 544         return 0;
 545 }
 546
 547 /**
 548  *      get_mtd_device_nm - obtain a validated handle for an MTD device by
 549  *      device name
 550  *      @name: MTD device name to open
 551  *
 552  *      This function returns MTD device description structure in case of
 553  *      success and an error code in case of failure.
 554  */
 555
 556 struct mtd_info *get_mtd_device_nm(const char *name)
 557 {
 558         int err = -ENODEV;
 559         struct mtd_info *mtd = NULL, *other;
 560
 561         mutex_lock(&mtd_table_mutex);
 562
 563         mtd_for_each_device(other) {
 564                 if (!strcmp(name, other->name)) {
 565                         mtd = other;
 566                         break;
 567                 }
 568         }
 569
 570         if (!mtd)
 571                 goto out_unlock;
 572
 573         if (!try_module_get(mtd->owner))
 574                 goto out_unlock;
 575
 576         if (mtd->get_device) {
 577                 err = mtd->get_device(mtd);
 578                 if (err)
 579                         goto out_put;
 580         }
 581
 582         mtd->usecount++;
 583         mutex_unlock(&mtd_table_mutex);
 584         return mtd;
 585
 586 out_put:
 587         module_put(mtd->owner);
 588 out_unlock:
 589         mutex_unlock(&mtd_table_mutex);
 590         return ERR_PTR(err);
 591 }
 592
 593 void put_mtd_device(struct mtd_info *mtd)
 594 {
 595         mutex_lock(&mtd_table_mutex);
 596         __put_mtd_device(mtd);
 597         mutex_unlock(&mtd_table_mutex);
 598
 599 }
 600
 601 void __put_mtd_device(struct mtd_info *mtd)
 602 {
 603         --mtd->usecount;
 604         BUG_ON(mtd->usecount < 0);
 605
 606         if (mtd->put_device)
 607                 mtd->put_device(mtd);
 608
 609         module_put(mtd->owner);
 610 }
 611
 612 /* default_mtd_writev - default mtd writev method for MTD devices that
 613  *                      don't implement their own
 614  */
 615
 616 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
 617                        unsigned long count, loff_t to, size_t *retlen)
 618 {
 619         unsigned long i;
 620         size_t totlen = 0, thislen;
 621         int ret = 0;
 622
 623         if(!mtd->write) {
 624                 ret = -EROFS;
 625         } else {
 626                 for (i=0; i<count; i++) {
 627                         if (!vecs[i].iov_len)
 628                                 continue;
 629                         ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base);
 630                         totlen += thislen;
 631                         if (ret || thislen != vecs[i].iov_len)
 632                                 break;
 633                         to += vecs[i].iov_len;
 634                 }
 635         }
 636         if (retlen)
 637                 *retlen = totlen;
 638         return ret;
 639 }
 640
 641 EXPORT_SYMBOL_GPL(add_mtd_device);
 642 EXPORT_SYMBOL_GPL(del_mtd_device);
 643 EXPORT_SYMBOL_GPL(get_mtd_device);
 644 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
 645 EXPORT_SYMBOL_GPL(__get_mtd_device);
 646 EXPORT_SYMBOL_GPL(put_mtd_device);
 647 EXPORT_SYMBOL_GPL(__put_mtd_device);
 648 EXPORT_SYMBOL_GPL(register_mtd_user);
 649 EXPORT_SYMBOL_GPL(unregister_mtd_user);
 650 EXPORT_SYMBOL_GPL(default_mtd_writev);
 651
 652 #ifdef CONFIG_PROC_FS
 653
 654 /*====================================================================*/
 655 /* Support for /proc/mtd */
 656
 657 static struct proc_dir_entry *proc_mtd;
 658
 659 static inline int mtd_proc_info(char *buf, struct mtd_info *this)
 660 {
 661         return sprintf(buf, "mtd%d: %8.8llx %8.8x \"%s\"\n", this->index,
 662                        (unsigned long long)this->size,
 663                        this->erasesize, this->name);
 664 }
 665
 666 static int mtd_read_proc (char *page, char **start, off_t off, int count,
 667                           int *eof, void *data_unused)
 668 {
 669         struct mtd_info *mtd;
 670         int len, l;
 671         off_t   begin = 0;
 672
 673         mutex_lock(&mtd_table_mutex);
 674
 675         len = sprintf(page, "dev:    size   erasesize  name\n");
 676         mtd_for_each_device(mtd) {
 677                 l = mtd_proc_info(page + len, mtd);
 678                 len += l;
 679                 if (len+begin > off+count)
 680                         goto done;
 681                 if (len+begin < off) {
 682                         begin += len;
 683                         len = 0;
 684                 }
 685         }
 686
 687         *eof = 1;
 688
 689 done:
 690         mutex_unlock(&mtd_table_mutex);
 691         if (off >= len+begin)
 692                 return 0;
 693         *start = page + (off-begin);
 694         return ((count < begin+len-off) ? count : begin+len-off);
 695 }
 696
 697 #endif /* CONFIG_PROC_FS */
 698
 699 /*====================================================================*/
 700 /* Init code */
 701
 702 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name)
 703 {
 704         int ret;
 705
 706         ret = bdi_init(bdi);
 707         if (!ret)
 708                 ret = bdi_register(bdi, NULL, name);
 709
 710         if (ret)
 711                 bdi_destroy(bdi);
 712
 713         return ret;
 714 }
 715
 716 static int __init init_mtd(void)
 717 {
 718         int ret;
 719
 720         ret = class_register(&mtd_class);
 721         if (ret)
 722                 goto err_reg;
 723
 724         ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap");
 725         if (ret)
 726                 goto err_bdi1;
 727
 728         ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap");
 729         if (ret)
 730                 goto err_bdi2;
 731
 732         ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap");
 733         if (ret)
 734                 goto err_bdi3;
 735
 736 #ifdef CONFIG_PROC_FS
 737         if ((proc_mtd = create_proc_entry( "mtd", 0, NULL )))
 738                 proc_mtd->read_proc = mtd_read_proc;
 739 #endif /* CONFIG_PROC_FS */
 740         return 0;
 741
 742 err_bdi3:
 743         bdi_destroy(&mtd_bdi_ro_mappable);
 744 err_bdi2:
 745         bdi_destroy(&mtd_bdi_unmappable);
 746 err_bdi1:
 747         class_unregister(&mtd_class);
 748 err_reg:
 749         pr_err("Error registering mtd class or bdi: %d\n", ret);
 750         return ret;
 751 }
 752
 753 static void __exit cleanup_mtd(void)
 754 {
 755 #ifdef CONFIG_PROC_FS
 756         if (proc_mtd)
 757                 remove_proc_entry( "mtd", NULL);
 758 #endif /* CONFIG_PROC_FS */
 759         class_unregister(&mtd_class);
 760         bdi_destroy(&mtd_bdi_unmappable);
 761         bdi_destroy(&mtd_bdi_ro_mappable);
 762         bdi_destroy(&mtd_bdi_rw_mappable);
 763 }
 764
 765 module_init(init_mtd);
 766 module_exit(cleanup_mtd);
 767
 768 MODULE_LICENSE("GPL");
 769 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
 770 MODULE_DESCRIPTION("Core MTD registration and access routines");