drivers/mtd/devices/blkmtd.c

   1 /*
   2  * $Id: blkmtd.c,v 1.23 2004/08/09 14:03:19 dwmw2 Exp $
   3  *
   4  * blkmtd.c - use a block device as a fake MTD
   5  *
   6  * Author: Simon Evans <spse@secret.org.uk>
   7  *
   8  * Copyright (C) 2001,2002 Simon Evans
   9  *
  10  * Licence: GPL
  11  *
  12  * How it works:
  13  *      The driver uses raw/io to read/write the device and the page
  14  *      cache to cache access. Writes update the page cache with the
  15  *      new data and mark it dirty and add the page into a BIO which
  16  *      is then written out.
  17  *
  18  *      It can be loaded Read-Only to prevent erases and writes to the
  19  *      medium.
  20  *
  21  */
  22
  23 #include <linux/config.h>
  24 #include <linux/module.h>
  25 #include <linux/fs.h>
  26 #include <linux/blkdev.h>
  27 #include <linux/bio.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/list.h>
  30 #include <linux/init.h>
  31 #include <linux/mtd/mtd.h>
  32
  33
  34 #define err(format, arg...) printk(KERN_ERR "blkmtd: " format "\n" , ## arg)
  35 #define info(format, arg...) printk(KERN_INFO "blkmtd: " format "\n" , ## arg)
  36 #define warn(format, arg...) printk(KERN_WARNING "blkmtd: " format "\n" , ## arg)
  37 #define crit(format, arg...) printk(KERN_CRIT "blkmtd: " format "\n" , ## arg)
  38
  39
  40 /* Default erase size in K, always make it a multiple of PAGE_SIZE */
  41 #define CONFIG_MTD_BLKDEV_ERASESIZE (128 << 10) /* 128KiB */
  42 #define VERSION "$Revision: 1.23 $"
  43
  44 /* Info for the block device */
  45 struct blkmtd_dev {
  46         struct list_head list;
  47         struct block_device *blkdev;
  48         struct mtd_info mtd_info;
  49         struct semaphore wrbuf_mutex;
  50 };
  51
  52
  53 /* Static info about the MTD, used in cleanup_module */
  54 static LIST_HEAD(blkmtd_device_list);
  55
  56
  57 static void blkmtd_sync(struct mtd_info *mtd);
  58
  59 #define MAX_DEVICES 4
  60
  61 /* Module parameters passed by insmod/modprobe */
  62 char *device[MAX_DEVICES];    /* the block device to use */
  63 int erasesz[MAX_DEVICES];     /* optional default erase size */
  64 int ro[MAX_DEVICES];          /* optional read only flag */
  65 int sync;
  66
  67
  68 MODULE_LICENSE("GPL");
  69 MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
  70 MODULE_DESCRIPTION("Emulate an MTD using a block device");
  71 MODULE_PARM(device, "1-4s");
  72 MODULE_PARM_DESC(device, "block device to use");
  73 MODULE_PARM(erasesz, "1-4i");
  74 MODULE_PARM_DESC(erasesz, "optional erase size to use in KiB. eg 4=4KiB.");
  75 MODULE_PARM(ro, "1-4i");
  76 MODULE_PARM_DESC(ro, "1=Read only, writes and erases cause errors");
  77 MODULE_PARM(sync, "i");
  78 MODULE_PARM_DESC(sync, "1=Synchronous writes");
  79
  80
  81 /* completion handler for BIO reads */
  82 static int bi_read_complete(struct bio *bio, unsigned int bytes_done, int error)
  83 {
  84         if (bio->bi_size)
  85                 return 1;
  86
  87         complete((struct completion*)bio->bi_private);
  88         return 0;
  89 }
  90
  91
  92 /* completion handler for BIO writes */
  93 static int bi_write_complete(struct bio *bio, unsigned int bytes_done, int error)
  94 {
  95         const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
  96         struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
  97
  98         if (bio->bi_size)
  99                 return 1;
 100
 101         if(!uptodate)
 102                 err("bi_write_complete: not uptodate\n");
 103
 104         do {
 105                 struct page *page = bvec->bv_page;
 106                 DEBUG(3, "Cleaning up page %ld\n", page->index);
 107                 if (--bvec >= bio->bi_io_vec)
 108                         prefetchw(&bvec->bv_page->flags);
 109
 110                 if (uptodate) {
 111                         SetPageUptodate(page);
 112                 } else {
 113                         ClearPageUptodate(page);
 114                         SetPageError(page);
 115                 }
 116                 ClearPageDirty(page);
 117                 unlock_page(page);
 118                 page_cache_release(page);
 119         } while (bvec >= bio->bi_io_vec);
 120
 121         complete((struct completion*)bio->bi_private);
 122         return 0;
 123 }
 124
 125
 126 /* read one page from the block device */
 127 static int blkmtd_readpage(struct blkmtd_dev *dev, struct page *page)
 128 {
 129         struct bio *bio;
 130         struct completion event;
 131         int err = -ENOMEM;
 132
 133         if(PageUptodate(page)) {
 134                 DEBUG(2, "blkmtd: readpage page %ld is already upto date\n", page->index);
 135                 unlock_page(page);
 136                 return 0;
 137         }
 138
 139         ClearPageUptodate(page);
 140         ClearPageError(page);
 141
 142         bio = bio_alloc(GFP_KERNEL, 1);
 143         if(bio) {
 144                 init_completion(&event);
 145                 bio->bi_bdev = dev->blkdev;
 146                 bio->bi_sector = page->index << (PAGE_SHIFT-9);
 147                 bio->bi_private = &event;
 148                 bio->bi_end_io = bi_read_complete;
 149                 if(bio_add_page(bio, page, PAGE_SIZE, 0) == PAGE_SIZE) {
 150                         submit_bio(READ_SYNC, bio);
 151                         wait_for_completion(&event);
 152                         err = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : -EIO;
 153                         bio_put(bio);
 154                 }
 155         }
 156
 157         if(err)
 158                 SetPageError(page);
 159         else
 160                 SetPageUptodate(page);
 161         flush_dcache_page(page);
 162         unlock_page(page);
 163         return err;
 164 }
 165
 166
 167 /* write out the current BIO and wait for it to finish */
 168 static int blkmtd_write_out(struct bio *bio)
 169 {
 170         struct completion event;
 171         int err;
 172
 173         if(!bio->bi_vcnt) {
 174                 bio_put(bio);
 175                 return 0;
 176         }
 177
 178         init_completion(&event);
 179         bio->bi_private = &event;
 180         bio->bi_end_io = bi_write_complete;
 181         submit_bio(WRITE_SYNC, bio);
 182         wait_for_completion(&event);
 183         DEBUG(3, "submit_bio completed, bi_vcnt = %d\n", bio->bi_vcnt);
 184         err = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : -EIO;
 185         bio_put(bio);
 186         return err;
 187 }
 188
 189
 190 /**
 191  * blkmtd_add_page - add a page to the current BIO
 192  * @bio: bio to add to (NULL to alloc initial bio)
 193  * @blkdev: block device
 194  * @page: page to add
 195  * @pagecnt: pages left to add
 196  *
 197  * Adds a page to the current bio, allocating it if necessary. If it cannot be
 198  * added, the current bio is written out and a new one is allocated. Returns
 199  * the new bio to add or NULL on error
 200  */
 201 static struct bio *blkmtd_add_page(struct bio *bio, struct block_device *blkdev,
 202                                    struct page *page, int pagecnt)
 203 {
 204
 205  retry:
 206         if(!bio) {
 207                 bio = bio_alloc(GFP_KERNEL, pagecnt);
 208                 if(!bio)
 209                         return NULL;
 210                 bio->bi_sector = page->index << (PAGE_SHIFT-9);
 211                 bio->bi_bdev = blkdev;
 212         }
 213
 214         if(bio_add_page(bio, page, PAGE_SIZE, 0) != PAGE_SIZE) {
 215                 blkmtd_write_out(bio);
 216                 bio = NULL;
 217                 goto retry;
 218         }
 219         return bio;
 220 }
 221
 222
 223 /**
 224  * write_pages - write block of data to device via the page cache
 225  * @dev: device to write to
 226  * @buf: data source or NULL if erase (output is set to 0xff)
 227  * @to: offset into output device
 228  * @len: amount to data to write
 229  * @retlen: amount of data written
 230  *
 231  * Grab pages from the page cache and fill them with the source data.
 232  * Non page aligned start and end result in a readin of the page and
 233  * part of the page being modified. Pages are added to the bio and then written
 234  * out.
 235  */
 236 static int write_pages(struct blkmtd_dev *dev, const u_char *buf, loff_t to,
 237                     size_t len, size_t *retlen)
 238 {
 239         int pagenr, offset;
 240         size_t start_len = 0, end_len;
 241         int pagecnt = 0;
 242         int err = 0;
 243         struct bio *bio = NULL;
 244         size_t thislen = 0;
 245
 246         pagenr = to >> PAGE_SHIFT;
 247         offset = to & ~PAGE_MASK;
 248
 249         DEBUG(2, "blkmtd: write_pages: buf = %p to = %ld len = %zd pagenr = %d offset = %d\n",
 250               buf, (long)to, len, pagenr, offset);
 251
 252         /* see if we have to do a partial write at the start */
 253         if(offset) {
 254                 start_len = ((offset + len) > PAGE_SIZE) ? PAGE_SIZE - offset : len;
 255                 len -= start_len;
 256         }
 257
 258         /* calculate the length of the other two regions */
 259         end_len = len & ~PAGE_MASK;
 260         len -= end_len;
 261
 262         if(start_len)
 263                 pagecnt++;
 264
 265         if(len)
 266                 pagecnt += len >> PAGE_SHIFT;
 267
 268         if(end_len)
 269                 pagecnt++;
 270
 271         down(&dev->wrbuf_mutex);
 272
 273         DEBUG(3, "blkmtd: write: start_len = %zd len = %zd end_len = %zd pagecnt = %d\n",
 274               start_len, len, end_len, pagecnt);
 275
 276         if(start_len) {
 277                 /* do partial start region */
 278                 struct page *page;
 279
 280                 DEBUG(3, "blkmtd: write: doing partial start, page = %d len = %zd offset = %d\n",
 281                       pagenr, start_len, offset);
 282
 283                 BUG_ON(!buf);
 284                 page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
 285                 lock_page(page);
 286                 if(PageDirty(page)) {
 287                         err("to = %lld start_len = %zd len = %zd end_len = %zd pagenr = %d\n",
 288                             to, start_len, len, end_len, pagenr);
 289                         BUG();
 290                 }
 291                 memcpy(page_address(page)+offset, buf, start_len);
 292                 SetPageDirty(page);
 293                 SetPageUptodate(page);
 294                 buf += start_len;
 295                 thislen = start_len;
 296                 bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
 297                 if(!bio) {
 298                         err = -ENOMEM;
 299                         err("bio_add_page failed\n");
 300                         goto write_err;
 301                 }
 302                 pagecnt--;
 303                 pagenr++;
 304         }
 305
 306         /* Now do the main loop to a page aligned, n page sized output */
 307         if(len) {
 308                 int pagesc = len >> PAGE_SHIFT;
 309                 DEBUG(3, "blkmtd: write: whole pages start = %d, count = %d\n",
 310                       pagenr, pagesc);
 311                 while(pagesc) {
 312                         struct page *page;
 313
 314                         /* see if page is in the page cache */
 315                         DEBUG(3, "blkmtd: write: grabbing page %d from page cache\n", pagenr);
 316                         page = grab_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr);
 317                         if(PageDirty(page)) {
 318                                 BUG();
 319                         }
 320                         if(!page) {
 321                                 warn("write: cannot grab cache page %d", pagenr);
 322                                 err = -ENOMEM;
 323                                 goto write_err;
 324                         }
 325                         if(!buf) {
 326                                 memset(page_address(page), 0xff, PAGE_SIZE);
 327                         } else {
 328                                 memcpy(page_address(page), buf, PAGE_SIZE);
 329                                 buf += PAGE_SIZE;
 330                         }
 331                         bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
 332                         if(!bio) {
 333                                 err = -ENOMEM;
 334                                 err("bio_add_page failed\n");
 335                                 goto write_err;
 336                         }
 337                         pagenr++;
 338                         pagecnt--;
 339                         SetPageDirty(page);
 340                         SetPageUptodate(page);
 341                         pagesc--;
 342                         thislen += PAGE_SIZE;
 343                 }
 344         }
 345
 346         if(end_len) {
 347                 /* do the third region */
 348                 struct page *page;
 349                 DEBUG(3, "blkmtd: write: doing partial end, page = %d len = %zd\n",
 350                       pagenr, end_len);
 351                 BUG_ON(!buf);
 352                 page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
 353                 lock_page(page);
 354                 if(PageDirty(page)) {
 355                         err("to = %lld start_len = %zd len = %zd end_len = %zd pagenr = %d\n",
 356                             to, start_len, len, end_len, pagenr);
 357                         BUG();
 358                 }
 359                 memcpy(page_address(page), buf, end_len);
 360                 SetPageDirty(page);
 361                 SetPageUptodate(page);
 362                 DEBUG(3, "blkmtd: write: writing out partial end\n");
 363                 thislen += end_len;
 364                 bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
 365                 if(!bio) {
 366                         err = -ENOMEM;
 367                         err("bio_add_page failed\n");
 368                         goto write_err;
 369                 }
 370                 pagenr++;
 371         }
 372
 373         DEBUG(3, "blkmtd: write: got %d vectors to write\n", bio->bi_vcnt);
 374  write_err:
 375         if(bio)
 376                 blkmtd_write_out(bio);
 377
 378         DEBUG(2, "blkmtd: write: end, retlen = %zd, err = %d\n", *retlen, err);
 379         up(&dev->wrbuf_mutex);
 380
 381         if(retlen)
 382                 *retlen = thislen;
 383         return err;
 384 }
 385
 386
 387 /* erase a specified part of the device */
 388 static int blkmtd_erase(struct mtd_info *mtd, struct erase_info *instr)
 389 {
 390         struct blkmtd_dev *dev = mtd->priv;
 391         struct mtd_erase_region_info *einfo = mtd->eraseregions;
 392         int numregions = mtd->numeraseregions;
 393         size_t from;
 394         u_long len;
 395         int err = -EIO;
 396         size_t retlen;
 397
 398         instr->state = MTD_ERASING;
 399         from = instr->addr;
 400         len = instr->len;
 401
 402         /* check erase region has valid start and length */
 403         DEBUG(2, "blkmtd: erase: dev = `%s' from = 0x%zx len = 0x%lx\n",
 404               mtd->name+9, from, len);
 405         while(numregions) {
 406                 DEBUG(3, "blkmtd: checking erase region = 0x%08X size = 0x%X num = 0x%x\n",
 407                       einfo->offset, einfo->erasesize, einfo->numblocks);
 408                 if(from >= einfo->offset
 409                    && from < einfo->offset + (einfo->erasesize * einfo->numblocks)) {
 410                         if(len == einfo->erasesize
 411                            && ( (from - einfo->offset) % einfo->erasesize == 0))
 412                                 break;
 413                 }
 414                 numregions--;
 415                 einfo++;
 416         }
 417
 418         if(!numregions) {
 419                 /* Not a valid erase block */
 420                 err("erase: invalid erase request 0x%lX @ 0x%08zX", len, from);
 421                 instr->state = MTD_ERASE_FAILED;
 422                 err = -EIO;
 423         }
 424
 425         if(instr->state != MTD_ERASE_FAILED) {
 426                 /* do the erase */
 427                 DEBUG(3, "Doing erase from = %zd len = %ld\n", from, len);
 428                 err = write_pages(dev, NULL, from, len, &retlen);
 429                 if(err || retlen != len) {
 430                         err("erase failed err = %d", err);
 431                         instr->state = MTD_ERASE_FAILED;
 432                 } else {
 433                         instr->state = MTD_ERASE_DONE;
 434                 }
 435         }
 436
 437         DEBUG(3, "blkmtd: erase: checking callback\n");
 438         mtd_erase_callback(instr);
 439         DEBUG(2, "blkmtd: erase: finished (err = %d)\n", err);
 440         return err;
 441 }
 442
 443
 444 /* read a range of the data via the page cache */
 445 static int blkmtd_read(struct mtd_info *mtd, loff_t from, size_t len,
 446                        size_t *retlen, u_char *buf)
 447 {
 448         struct blkmtd_dev *dev = mtd->priv;
 449         int err = 0;
 450         int offset;
 451         int pagenr, pages;
 452         size_t thislen = 0;
 453
 454         DEBUG(2, "blkmtd: read: dev = `%s' from = %lld len = %zd buf = %p\n",
 455               mtd->name+9, from, len, buf);
 456
 457         if(from > mtd->size)
 458                 return -EINVAL;
 459         if(from + len > mtd->size)
 460                 len = mtd->size - from;
 461
 462         pagenr = from >> PAGE_SHIFT;
 463         offset = from - (pagenr << PAGE_SHIFT);
 464
 465         pages = (offset+len+PAGE_SIZE-1) >> PAGE_SHIFT;
 466         DEBUG(3, "blkmtd: read: pagenr = %d offset = %d, pages = %d\n",
 467               pagenr, offset, pages);
 468
 469         while(pages) {
 470                 struct page *page;
 471                 int cpylen;
 472
 473                 DEBUG(3, "blkmtd: read: looking for page: %d\n", pagenr);
 474                 page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
 475                 if(IS_ERR(page)) {
 476                         err = -EIO;
 477                         goto readerr;
 478                 }
 479
 480                 cpylen = (PAGE_SIZE > len) ? len : PAGE_SIZE;
 481                 if(offset+cpylen > PAGE_SIZE)
 482                         cpylen = PAGE_SIZE-offset;
 483
 484                 memcpy(buf + thislen, page_address(page) + offset, cpylen);
 485                 offset = 0;
 486                 len -= cpylen;
 487                 thislen += cpylen;
 488                 pagenr++;
 489                 pages--;
 490                 if(!PageDirty(page))
 491                         page_cache_release(page);
 492         }
 493
 494  readerr:
 495         if(retlen)
 496                 *retlen = thislen;
 497         DEBUG(2, "blkmtd: end read: retlen = %zd, err = %d\n", thislen, err);
 498         return err;
 499 }
 500
 501
 502 /* write data to the underlying device */
 503 static int blkmtd_write(struct mtd_info *mtd, loff_t to, size_t len,
 504                         size_t *retlen, const u_char *buf)
 505 {
 506         struct blkmtd_dev *dev = mtd->priv;
 507         int err;
 508
 509         if(!len)
 510                 return 0;
 511
 512         DEBUG(2, "blkmtd: write: dev = `%s' to = %lld len = %zd buf = %p\n",
 513               mtd->name+9, to, len, buf);
 514
 515         if(to >= mtd->size) {
 516                 return -ENOSPC;
 517         }
 518
 519         if(to + len > mtd->size) {
 520                 len = mtd->size - to;
 521         }
 522
 523         err = write_pages(dev, buf, to, len, retlen);
 524         if(err > 0)
 525                 err = 0;
 526         DEBUG(2, "blkmtd: write: end, err = %d\n", err);
 527         return err;
 528 }
 529
 530
 531 /* sync the device - wait until the write queue is empty */
 532 static void blkmtd_sync(struct mtd_info *mtd)
 533 {
 534         /* Currently all writes are synchronous */
 535 }
 536
 537
 538 static void free_device(struct blkmtd_dev *dev)
 539 {
 540         DEBUG(2, "blkmtd: free_device() dev = %p\n", dev);
 541         if(dev) {
 542                 if(dev->mtd_info.eraseregions)
 543                         kfree(dev->mtd_info.eraseregions);
 544                 if(dev->mtd_info.name)
 545                         kfree(dev->mtd_info.name);
 546
 547                 if(dev->blkdev) {
 548                         invalidate_inode_pages(dev->blkdev->bd_inode->i_mapping);
 549                         close_bdev_excl(dev->blkdev);
 550                 }
 551                 kfree(dev);
 552         }
 553 }
 554
 555
 556 /* For a given size and initial erase size, calculate the number
 557  * and size of each erase region. Goes round the loop twice,
 558  * once to find out how many regions, then allocates space,
 559  * then round the loop again to fill it in.
 560  */
 561 static struct mtd_erase_region_info *calc_erase_regions(
 562         size_t erase_size, size_t total_size, int *regions)
 563 {
 564         struct mtd_erase_region_info *info = NULL;
 565
 566         DEBUG(2, "calc_erase_regions, es = %zd size = %zd regions = %d\n",
 567               erase_size, total_size, *regions);
 568         /* Make any user specified erasesize be a power of 2
 569            and at least PAGE_SIZE */
 570         if(erase_size) {
 571                 int es = erase_size;
 572                 erase_size = 1;
 573                 while(es != 1) {
 574                         es >>= 1;
 575                         erase_size <<= 1;
 576                 }
 577                 if(erase_size < PAGE_SIZE)
 578                         erase_size = PAGE_SIZE;
 579         } else {
 580                 erase_size = CONFIG_MTD_BLKDEV_ERASESIZE;
 581         }
 582
 583         *regions = 0;
 584
 585         do {
 586                 int tot_size = total_size;
 587                 int er_size = erase_size;
 588                 int count = 0, offset = 0, regcnt = 0;
 589
 590                 while(tot_size) {
 591                         count = tot_size / er_size;
 592                         if(count) {
 593                                 tot_size = tot_size % er_size;
 594                                 if(info) {
 595                                         DEBUG(2, "adding to erase info off=%d er=%d cnt=%d\n",
 596                                               offset, er_size, count);
 597                                         (info+regcnt)->offset = offset;
 598                                         (info+regcnt)->erasesize = er_size;
 599                                         (info+regcnt)->numblocks = count;
 600                                         (*regions)++;
 601                                 }
 602                                 regcnt++;
 603                                 offset += (count * er_size);
 604                         }
 605                         while(er_size > tot_size)
 606                                 er_size >>= 1;
 607                 }
 608                 if(info == NULL) {
 609                         info = kmalloc(regcnt * sizeof(struct mtd_erase_region_info), GFP_KERNEL);
 610                         if(!info)
 611                                 break;
 612                 }
 613         } while(!(*regions));
 614         DEBUG(2, "calc_erase_regions done, es = %zd size = %zd regions = %d\n",
 615               erase_size, total_size, *regions);
 616         return info;
 617 }
 618
 619
 620 extern dev_t __init name_to_dev_t(const char *line);
 621
 622 static struct blkmtd_dev *add_device(char *devname, int readonly, int erase_size)
 623 {
 624         struct block_device *bdev;
 625         int mode;
 626         struct blkmtd_dev *dev;
 627
 628         if(!devname)
 629                 return NULL;
 630
 631         /* Get a handle on the device */
 632
 633
 634 #ifdef MODULE
 635         mode = (readonly) ? O_RDONLY : O_RDWR;
 636         bdev = open_bdev_excl(devname, mode, NULL);
 637 #else
 638         mode = (readonly) ? FMODE_READ : FMODE_WRITE;
 639         bdev = open_by_devnum(name_to_dev_t(devname), mode);
 640 #endif
 641         if(IS_ERR(bdev)) {
 642                 err("error: cannot open device %s", devname);
 643                 DEBUG(2, "blkmtd: opening bdev returned %ld\n", PTR_ERR(bdev));
 644                 return NULL;
 645         }
 646
 647         DEBUG(1, "blkmtd: found a block device major = %d, minor = %d\n",
 648               MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
 649
 650         if(MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
 651                 err("attempting to use an MTD device as a block device");
 652                 blkdev_put(bdev);
 653                 return NULL;
 654         }
 655
 656         dev = kmalloc(sizeof(struct blkmtd_dev), GFP_KERNEL);
 657         if(dev == NULL) {
 658                 blkdev_put(bdev);
 659                 return NULL;
 660         }
 661
 662         memset(dev, 0, sizeof(struct blkmtd_dev));
 663         dev->blkdev = bdev;
 664         atomic_set(&(dev->blkdev->bd_inode->i_mapping->truncate_count), 0);
 665         if(!readonly) {
 666                 init_MUTEX(&dev->wrbuf_mutex);
 667         }
 668
 669         dev->mtd_info.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
 670
 671         /* Setup the MTD structure */
 672         /* make the name contain the block device in */
 673         dev->mtd_info.name = kmalloc(sizeof("blkmtd: ") + strlen(devname), GFP_KERNEL);
 674         if(dev->mtd_info.name == NULL)
 675                 goto devinit_err;
 676
 677         sprintf(dev->mtd_info.name, "blkmtd: %s", devname);
 678         dev->mtd_info.eraseregions = calc_erase_regions(erase_size, dev->mtd_info.size,
 679                                                         &dev->mtd_info.numeraseregions);
 680         if(dev->mtd_info.eraseregions == NULL)
 681                 goto devinit_err;
 682
 683         dev->mtd_info.erasesize = dev->mtd_info.eraseregions->erasesize;
 684         DEBUG(1, "blkmtd: init: found %d erase regions\n",
 685               dev->mtd_info.numeraseregions);
 686
 687         if(readonly) {
 688                 dev->mtd_info.type = MTD_ROM;
 689                 dev->mtd_info.flags = MTD_CAP_ROM;
 690         } else {
 691                 dev->mtd_info.type = MTD_RAM;
 692                 dev->mtd_info.flags = MTD_CAP_RAM;
 693                 dev->mtd_info.erase = blkmtd_erase;
 694                 dev->mtd_info.write = blkmtd_write;
 695                 dev->mtd_info.writev = default_mtd_writev;
 696                 dev->mtd_info.sync = blkmtd_sync;
 697         }
 698         dev->mtd_info.read = blkmtd_read;
 699         dev->mtd_info.readv = default_mtd_readv;
 700         dev->mtd_info.priv = dev;
 701         dev->mtd_info.owner = THIS_MODULE;
 702
 703         list_add(&dev->list, &blkmtd_device_list);
 704         if (add_mtd_device(&dev->mtd_info)) {
 705                 /* Device didnt get added, so free the entry */
 706                 list_del(&dev->list);
 707                 goto devinit_err;
 708         } else {
 709                 info("mtd%d: [%s] erase_size = %dKiB %s",
 710                      dev->mtd_info.index, dev->mtd_info.name + strlen("blkmtd: "),
 711                      dev->mtd_info.erasesize >> 10,
 712                      readonly ? "(read-only)" : "");
 713         }
 714
 715         return dev;
 716
 717  devinit_err:
 718         free_device(dev);
 719         return NULL;
 720 }
 721
 722
 723 /* Cleanup and exit - sync the device and kill of the kernel thread */
 724 static void __devexit cleanup_blkmtd(void)
 725 {
 726         struct list_head *temp1, *temp2;
 727
 728         /* Remove the MTD devices */
 729         list_for_each_safe(temp1, temp2, &blkmtd_device_list) {
 730                 struct blkmtd_dev *dev = list_entry(temp1, struct blkmtd_dev,
 731                                                     list);
 732                 blkmtd_sync(&dev->mtd_info);
 733                 del_mtd_device(&dev->mtd_info);
 734                 info("mtd%d: [%s] removed", dev->mtd_info.index,
 735                      dev->mtd_info.name + strlen("blkmtd: "));
 736                 list_del(&dev->list);
 737                 free_device(dev);
 738         }
 739 }
 740
 741 #ifndef MODULE
 742
 743 /* Handle kernel boot params */
 744
 745
 746 static int __init param_blkmtd_device(char *str)
 747 {
 748         int i;
 749
 750         for(i = 0; i < MAX_DEVICES; i++) {
 751                 device[i] = str;
 752                 DEBUG(2, "blkmtd: device setup: %d = %s\n", i, device[i]);
 753                 strsep(&str, ",");
 754         }
 755         return 1;
 756 }
 757
 758
 759 static int __init param_blkmtd_erasesz(char *str)
 760 {
 761         int i;
 762         for(i = 0; i < MAX_DEVICES; i++) {
 763                 char *val = strsep(&str, ",");
 764                 if(val)
 765                         erasesz[i] = simple_strtoul(val, NULL, 0);
 766                 DEBUG(2, "blkmtd: erasesz setup: %d = %d\n", i, erasesz[i]);
 767         }
 768
 769         return 1;
 770 }
 771
 772
 773 static int __init param_blkmtd_ro(char *str)
 774 {
 775         int i;
 776         for(i = 0; i < MAX_DEVICES; i++) {
 777                 char *val = strsep(&str, ",");
 778                 if(val)
 779                         ro[i] = simple_strtoul(val, NULL, 0);
 780                 DEBUG(2, "blkmtd: ro setup: %d = %d\n", i, ro[i]);
 781         }
 782
 783         return 1;
 784 }
 785
 786
 787 static int __init param_blkmtd_sync(char *str)
 788 {
 789         if(str[0] == '1')
 790                 sync = 1;
 791         return 1;
 792 }
 793
 794 __setup("blkmtd_device=", param_blkmtd_device);
 795 __setup("blkmtd_erasesz=", param_blkmtd_erasesz);
 796 __setup("blkmtd_ro=", param_blkmtd_ro);
 797 __setup("blkmtd_sync=", param_blkmtd_sync);
 798
 799 #endif
 800
 801
 802 /* Startup */
 803 static int __init init_blkmtd(void)
 804 {
 805         int i;
 806
 807         info("version " VERSION);
 808         /* Check args - device[0] is the bare minimum*/
 809         if(!device[0]) {
 810                 err("error: missing `device' name\n");
 811                 return -EINVAL;
 812         }
 813
 814         for(i = 0; i < MAX_DEVICES; i++)
 815                 add_device(device[i], ro[i], erasesz[i] << 10);
 816
 817         if(list_empty(&blkmtd_device_list))
 818                 return -EINVAL;
 819
 820         return 0;
 821 }
 822
 823 module_init(init_blkmtd);
 824 module_exit(cleanup_blkmtd);