Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

5 files changed, 50 insertions, 919 deletions

diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index 0f6bb2e625d8..a7ec5954caf5 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -200,27 +200,6 @@ config MTD_CFI_AMDSTD
           provides support for one of those command sets, used on chips
           including the AMD Am29LV320.
 
-config MTD_CFI_AMDSTD_RETRY
-        int "Retry failed commands (erase/program)"
-        depends on MTD_CFI_AMDSTD
-        default "0"
-        help
-          Some chips, when attached to a shared bus, don't properly filter
-          bus traffic that is destined to other devices.  This broken
-          behavior causes erase and program sequences to be aborted when
-          the sequences are mixed with traffic for other devices.
-
-          SST49LF040 (and related) chips are know to be broken.
-
-config MTD_CFI_AMDSTD_RETRY_MAX
-        int "Max retries of failed commands (erase/program)"
-        depends on MTD_CFI_AMDSTD_RETRY
-        default "0"
-        help
-          If you have an SST49LF040 (or related chip) then this value should
-          be set to at least 1.  This can also be adjusted at driver load
-          time with the retry_cmd_max module parameter.
-
 config MTD_CFI_STAA
         tristate "Support for ST (Advanced Architecture) flash chips"
         depends on MTD_GEN_PROBE
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index dd628cb51e31..7fac438b5c32 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -129,8 +129,8 @@ config MTDRAM_ABS_POS
           allocating space from Linux's available memory. Otherwise, leave
           this set to zero. Most people will want to leave this as zero.
 
-config MTD_BLKMTD
-        tristate "MTD emulation using block device"
+config MTD_BLOCK2MTD
+        tristate "MTD using block device"
         depends on MTD
         help
           This driver allows a block device to appear as an MTD. It would
@@ -141,15 +141,6 @@ config MTD_BLKMTD
           Testing MTD users (eg JFFS2) on large media and media that might
           be removed during a write (using the floppy drive).
 
-config MTD_BLOCK2MTD
-        tristate "MTD using block device (rewrite)"
-        depends on MTD && EXPERIMENTAL
-        help
-          This driver is basically the same at MTD_BLKMTD above, but
-          experienced some interface changes plus serious speedups.  In
-          the long term, it should replace MTD_BLKMTD.  Right now, you
-          shouldn't entrust important data to it yet.
-
 comment "Disk-On-Chip Device Drivers"
 
 config MTD_DOC2000
diff --git a/drivers/mtd/devices/Makefile b/drivers/mtd/devices/Makefile
index 7c5ed2178380..b6573670316f 100644
--- a/drivers/mtd/devices/Makefile
+++ b/drivers/mtd/devices/Makefile
@@ -21,7 +21,6 @@ obj-$(CONFIG_MTD_PMC551)	+= pmc551.o
 obj-$(CONFIG_MTD_MS02NV)        += ms02-nv.o
 obj-$(CONFIG_MTD_MTDRAM)        += mtdram.o
 obj-$(CONFIG_MTD_LART)          += lart.o
-obj-$(CONFIG_MTD_BLKMTD)        += blkmtd.o
 obj-$(CONFIG_MTD_BLOCK2MTD)     += block2mtd.o
 obj-$(CONFIG_MTD_DATAFLASH)     += mtd_dataflash.o
 obj-$(CONFIG_MTD_M25P80)        += m25p80.o
diff --git a/drivers/mtd/devices/blkmtd.c b/drivers/mtd/devices/blkmtd.c
deleted file mode 100644
index 79f2e1f23ebd..000000000000
--- a/drivers/mtd/devices/blkmtd.c
+++ /dev/null
@@ -1,819 +0,0 @@
-/*
- * $Id: blkmtd.c,v 1.27 2005/11/07 11:14:24 gleixner Exp $
- *
- * blkmtd.c - use a block device as a fake MTD
- *
- * Author: Simon Evans <spse@secret.org.uk>
- *
- * Copyright (C) 2001,2002 Simon Evans
- *
- * Licence: GPL
- *
- * How it works:
- *      The driver uses raw/io to read/write the device and the page
- *      cache to cache access. Writes update the page cache with the
- *      new data and mark it dirty and add the page into a BIO which
- *      is then written out.
- *
- *      It can be loaded Read-Only to prevent erases and writes to the
- *      medium.
- *
- */
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/blkdev.h>
-#include <linux/bio.h>
-#include <linux/pagemap.h>
-#include <linux/list.h>
-#include <linux/init.h>
-#include <linux/mount.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mutex.h>
-
-#define err(format, arg...) printk(KERN_ERR "blkmtd: " format "\n" , ## arg)
-#define info(format, arg...) printk(KERN_INFO "blkmtd: " format "\n" , ## arg)
-#define warn(format, arg...) printk(KERN_WARNING "blkmtd: " format "\n" , ## arg)
-#define crit(format, arg...) printk(KERN_CRIT "blkmtd: " format "\n" , ## arg)
-
-
-/* Default erase size in K, always make it a multiple of PAGE_SIZE */
-#define CONFIG_MTD_BLKDEV_ERASESIZE (128 << 10) /* 128KiB */
-#define VERSION "$Revision: 1.27 $"
-
-/* Info for the block device */
-struct blkmtd_dev {
-        struct list_head list;
-        struct block_device *blkdev;
-        struct mtd_info mtd_info;
-        struct mutex wrbuf_mutex;
-};
-
-
-/* Static info about the MTD, used in cleanup_module */
-static LIST_HEAD(blkmtd_device_list);
-
-
-static void blkmtd_sync(struct mtd_info *mtd);
-
-#define MAX_DEVICES 4
-
-/* Module parameters passed by insmod/modprobe */
-static char *device[MAX_DEVICES];    /* the block device to use */
-static int erasesz[MAX_DEVICES];     /* optional default erase size */
-static int ro[MAX_DEVICES];          /* optional read only flag */
-static int sync;
-
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
-MODULE_DESCRIPTION("Emulate an MTD using a block device");
-module_param_array(device, charp, NULL, 0);
-MODULE_PARM_DESC(device, "block device to use");
-module_param_array(erasesz, int, NULL, 0);
-MODULE_PARM_DESC(erasesz, "optional erase size to use in KiB. eg 4=4KiB.");
-module_param_array(ro, bool, NULL, 0);
-MODULE_PARM_DESC(ro, "1=Read only, writes and erases cause errors");
-module_param(sync, bool, 0);
-MODULE_PARM_DESC(sync, "1=Synchronous writes");
-
-
-/* completion handler for BIO reads */
-static int bi_read_complete(struct bio *bio, unsigned int bytes_done, int error)
-{
-        if (bio->bi_size)
-                return 1;
-
-        complete((struct completion*)bio->bi_private);
-        return 0;
-}
-
-
-/* completion handler for BIO writes */
-static int bi_write_complete(struct bio *bio, unsigned int bytes_done, int error)
-{
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
-        struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
-
-        if (bio->bi_size)
-                return 1;
-
-        if(!uptodate)
-                err("bi_write_complete: not uptodate\n");
-
-        do {
-                struct page *page = bvec->bv_page;
-                DEBUG(3, "Cleaning up page %ld\n", page->index);
-                if (--bvec >= bio->bi_io_vec)
-                        prefetchw(&bvec->bv_page->flags);
-
-                if (uptodate) {
-                        SetPageUptodate(page);
-                } else {
-                        ClearPageUptodate(page);
-                        SetPageError(page);
-                }
-                clear_page_dirty(page);
-                unlock_page(page);
-                page_cache_release(page);
-        } while (bvec >= bio->bi_io_vec);
-
-        complete((struct completion*)bio->bi_private);
-        return 0;
-}
-
-
-/* read one page from the block device */
-static int blkmtd_readpage(struct blkmtd_dev *dev, struct page *page)
-{
-        struct bio *bio;
-        struct completion event;
-        int err = -ENOMEM;
-
-        if(PageUptodate(page)) {
-                DEBUG(2, "blkmtd: readpage page %ld is already upto date\n", page->index);
-                unlock_page(page);
-                return 0;
-        }
-
-        ClearPageUptodate(page);
-        ClearPageError(page);
-
-        bio = bio_alloc(GFP_KERNEL, 1);
-        if(bio) {
-                init_completion(&event);
-                bio->bi_bdev = dev->blkdev;
-                bio->bi_sector = page->index << (PAGE_SHIFT-9);
-                bio->bi_private = &event;
-                bio->bi_end_io = bi_read_complete;
-                if(bio_add_page(bio, page, PAGE_SIZE, 0) == PAGE_SIZE) {
-                        submit_bio(READ_SYNC, bio);
-                        wait_for_completion(&event);
-                        err = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : -EIO;
-                        bio_put(bio);
-                }
-        }
-
-        if(err)
-                SetPageError(page);
-        else
-                SetPageUptodate(page);
-        flush_dcache_page(page);
-        unlock_page(page);
-        return err;
-}
-
-
-/* write out the current BIO and wait for it to finish */
-static int blkmtd_write_out(struct bio *bio)
-{
-        struct completion event;
-        int err;
-
-        if(!bio->bi_vcnt) {
-                bio_put(bio);
-                return 0;
-        }
-
-        init_completion(&event);
-        bio->bi_private = &event;
-        bio->bi_end_io = bi_write_complete;
-        submit_bio(WRITE_SYNC, bio);
-        wait_for_completion(&event);
-        DEBUG(3, "submit_bio completed, bi_vcnt = %d\n", bio->bi_vcnt);
-        err = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : -EIO;
-        bio_put(bio);
-        return err;
-}
-
-
-/**
- * blkmtd_add_page - add a page to the current BIO
- * @bio: bio to add to (NULL to alloc initial bio)
- * @blkdev: block device
- * @page: page to add
- * @pagecnt: pages left to add
- *
- * Adds a page to the current bio, allocating it if necessary. If it cannot be
- * added, the current bio is written out and a new one is allocated. Returns
- * the new bio to add or NULL on error
- */
-static struct bio *blkmtd_add_page(struct bio *bio, struct block_device *blkdev,
-                                   struct page *page, int pagecnt)
-{
-
- retry:
-        if(!bio) {
-                bio = bio_alloc(GFP_KERNEL, pagecnt);
-                if(!bio)
-                        return NULL;
-                bio->bi_sector = page->index << (PAGE_SHIFT-9);
-                bio->bi_bdev = blkdev;
-        }
-
-        if(bio_add_page(bio, page, PAGE_SIZE, 0) != PAGE_SIZE) {
-                blkmtd_write_out(bio);
-                bio = NULL;
-                goto retry;
-        }
-        return bio;
-}
-
-
-/**
- * write_pages - write block of data to device via the page cache
- * @dev: device to write to
- * @buf: data source or NULL if erase (output is set to 0xff)
- * @to: offset into output device
- * @len: amount to data to write
- * @retlen: amount of data written
- *
- * Grab pages from the page cache and fill them with the source data.
- * Non page aligned start and end result in a readin of the page and
- * part of the page being modified. Pages are added to the bio and then written
- * out.
- */
-static int write_pages(struct blkmtd_dev *dev, const u_char *buf, loff_t to,
-                    size_t len, size_t *retlen)
-{
-        int pagenr, offset;
-        size_t start_len = 0, end_len;
-        int pagecnt = 0;
-        int err = 0;
-        struct bio *bio = NULL;
-        size_t thislen = 0;
-
-        pagenr = to >> PAGE_SHIFT;
-        offset = to & ~PAGE_MASK;
-
-        DEBUG(2, "blkmtd: write_pages: buf = %p to = %ld len = %zd pagenr = %d offset = %d\n",
-              buf, (long)to, len, pagenr, offset);
-
-        /* see if we have to do a partial write at the start */
-        if(offset) {
-                start_len = ((offset + len) > PAGE_SIZE) ? PAGE_SIZE - offset : len;
-                len -= start_len;
-        }
-
-        /* calculate the length of the other two regions */
-        end_len = len & ~PAGE_MASK;
-        len -= end_len;
-
-        if(start_len)
-                pagecnt++;
-
-        if(len)
-                pagecnt += len >> PAGE_SHIFT;
-
-        if(end_len)
-                pagecnt++;
-
-        mutex_lock(&dev->wrbuf_mutex);
-
-        DEBUG(3, "blkmtd: write: start_len = %zd len = %zd end_len = %zd pagecnt = %d\n",
-              start_len, len, end_len, pagecnt);
-
-        if(start_len) {
-                /* do partial start region */
-                struct page *page;
-
-                DEBUG(3, "blkmtd: write: doing partial start, page = %d len = %zd offset = %d\n",
-                      pagenr, start_len, offset);
-
-                BUG_ON(!buf);
-                page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
-                lock_page(page);
-                if(PageDirty(page)) {
-                        err("to = %lld start_len = %zd len = %zd end_len = %zd pagenr = %d\n",
-                            to, start_len, len, end_len, pagenr);
-                        BUG();
-                }
-                memcpy(page_address(page)+offset, buf, start_len);
-                set_page_dirty(page);
-                SetPageUptodate(page);
-                buf += start_len;
-                thislen = start_len;
-                bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
-                if(!bio) {
-                        err = -ENOMEM;
-                        err("bio_add_page failed\n");
-                        goto write_err;
-                }
-                pagecnt--;
-                pagenr++;
-        }
-
-        /* Now do the main loop to a page aligned, n page sized output */
-        if(len) {
-                int pagesc = len >> PAGE_SHIFT;
-                DEBUG(3, "blkmtd: write: whole pages start = %d, count = %d\n",
-                      pagenr, pagesc);
-                while(pagesc) {
-                        struct page *page;
-
-                        /* see if page is in the page cache */
-                        DEBUG(3, "blkmtd: write: grabbing page %d from page cache\n", pagenr);
-                        page = grab_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr);
-                        if(PageDirty(page)) {
-                                BUG();
-                        }
-                        if(!page) {
-                                warn("write: cannot grab cache page %d", pagenr);
-                                err = -ENOMEM;
-                                goto write_err;
-                        }
-                        if(!buf) {
-                                memset(page_address(page), 0xff, PAGE_SIZE);
-                        } else {
-                                memcpy(page_address(page), buf, PAGE_SIZE);
-                                buf += PAGE_SIZE;
-                        }
-                        bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
-                        if(!bio) {
-                                err = -ENOMEM;
-                                err("bio_add_page failed\n");
-                                goto write_err;
-                        }
-                        pagenr++;
-                        pagecnt--;
-                        set_page_dirty(page);
-                        SetPageUptodate(page);
-                        pagesc--;
-                        thislen += PAGE_SIZE;
-                }
-        }
-
-        if(end_len) {
-                /* do the third region */
-                struct page *page;
-                DEBUG(3, "blkmtd: write: doing partial end, page = %d len = %zd\n",
-                      pagenr, end_len);
-                BUG_ON(!buf);
-                page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
-                lock_page(page);
-                if(PageDirty(page)) {
-                        err("to = %lld start_len = %zd len = %zd end_len = %zd pagenr = %d\n",
-                            to, start_len, len, end_len, pagenr);
-                        BUG();
-                }
-                memcpy(page_address(page), buf, end_len);
-                set_page_dirty(page);
-                SetPageUptodate(page);
-                DEBUG(3, "blkmtd: write: writing out partial end\n");
-                thislen += end_len;
-                bio = blkmtd_add_page(bio, dev->blkdev, page, pagecnt);
-                if(!bio) {
-                        err = -ENOMEM;
-                        err("bio_add_page failed\n");
-                        goto write_err;
-                }
-                pagenr++;
-        }
-
-        DEBUG(3, "blkmtd: write: got %d vectors to write\n", bio->bi_vcnt);
- write_err:
-        if(bio)
-                blkmtd_write_out(bio);
-
-        DEBUG(2, "blkmtd: write: end, retlen = %zd, err = %d\n", *retlen, err);
-        mutex_unlock(&dev->wrbuf_mutex);
-
-        if(retlen)
-                *retlen = thislen;
-        return err;
-}
-
-
-/* erase a specified part of the device */
-static int blkmtd_erase(struct mtd_info *mtd, struct erase_info *instr)
-{
-        struct blkmtd_dev *dev = mtd->priv;
-        struct mtd_erase_region_info *einfo = mtd->eraseregions;
-        int numregions = mtd->numeraseregions;
-        size_t from;
-        u_long len;
-        int err = -EIO;
-        size_t retlen;
-
-        instr->state = MTD_ERASING;
-        from = instr->addr;
-        len = instr->len;
-
-        /* check erase region has valid start and length */
-        DEBUG(2, "blkmtd: erase: dev = `%s' from = 0x%zx len = 0x%lx\n",
-              mtd->name+9, from, len);
-        while(numregions) {
-                DEBUG(3, "blkmtd: checking erase region = 0x%08X size = 0x%X num = 0x%x\n",
-                      einfo->offset, einfo->erasesize, einfo->numblocks);
-                if(from >= einfo->offset
-                   && from < einfo->offset + (einfo->erasesize * einfo->numblocks)) {
-                        if(len == einfo->erasesize
-                           && ( (from - einfo->offset) % einfo->erasesize == 0))
-                                break;
-                }
-                numregions--;
-                einfo++;
-        }
-
-        if(!numregions) {
-                /* Not a valid erase block */
-                err("erase: invalid erase request 0x%lX @ 0x%08zX", len, from);
-                instr->state = MTD_ERASE_FAILED;
-                err = -EIO;
-        }
-
-        if(instr->state != MTD_ERASE_FAILED) {
-                /* do the erase */
-                DEBUG(3, "Doing erase from = %zd len = %ld\n", from, len);
-                err = write_pages(dev, NULL, from, len, &retlen);
-                if(err || retlen != len) {
-                        err("erase failed err = %d", err);
-                        instr->state = MTD_ERASE_FAILED;
-                } else {
-                        instr->state = MTD_ERASE_DONE;
-                }
-        }
-
-        DEBUG(3, "blkmtd: erase: checking callback\n");
-        mtd_erase_callback(instr);
-        DEBUG(2, "blkmtd: erase: finished (err = %d)\n", err);
-        return err;
-}
-
-
-/* read a range of the data via the page cache */
-static int blkmtd_read(struct mtd_info *mtd, loff_t from, size_t len,
-                       size_t *retlen, u_char *buf)
-{
-        struct blkmtd_dev *dev = mtd->priv;
-        int err = 0;
-        int offset;
-        int pagenr, pages;
-        size_t thislen = 0;
-
-        DEBUG(2, "blkmtd: read: dev = `%s' from = %lld len = %zd buf = %p\n",
-              mtd->name+9, from, len, buf);
-
-        if(from > mtd->size)
-                return -EINVAL;
-        if(from + len > mtd->size)
-                len = mtd->size - from;
-
-        pagenr = from >> PAGE_SHIFT;
-        offset = from - (pagenr << PAGE_SHIFT);
-
-        pages = (offset+len+PAGE_SIZE-1) >> PAGE_SHIFT;
-        DEBUG(3, "blkmtd: read: pagenr = %d offset = %d, pages = %d\n",
-              pagenr, offset, pages);
-
-        while(pages) {
-                struct page *page;
-                int cpylen;
-
-                DEBUG(3, "blkmtd: read: looking for page: %d\n", pagenr);
-                page = read_cache_page(dev->blkdev->bd_inode->i_mapping, pagenr, (filler_t *)blkmtd_readpage, dev);
-                if(IS_ERR(page)) {
-                        err = -EIO;
-                        goto readerr;
-                }
-
-                cpylen = (PAGE_SIZE > len) ? len : PAGE_SIZE;
-                if(offset+cpylen > PAGE_SIZE)
-                        cpylen = PAGE_SIZE-offset;
-
-                memcpy(buf + thislen, page_address(page) + offset, cpylen);
-                offset = 0;
-                len -= cpylen;
-                thislen += cpylen;
-                pagenr++;
-                pages--;
-                if(!PageDirty(page))
-                        page_cache_release(page);
-        }
-
- readerr:
-        if(retlen)
-                *retlen = thislen;
-        DEBUG(2, "blkmtd: end read: retlen = %zd, err = %d\n", thislen, err);
-        return err;
-}
-
-
-/* write data to the underlying device */
-static int blkmtd_write(struct mtd_info *mtd, loff_t to, size_t len,
-                        size_t *retlen, const u_char *buf)
-{
-        struct blkmtd_dev *dev = mtd->priv;
-        int err;
-
-        if(!len)
-                return 0;
-
-        DEBUG(2, "blkmtd: write: dev = `%s' to = %lld len = %zd buf = %p\n",
-              mtd->name+9, to, len, buf);
-
-        if(to >= mtd->size) {
-                return -ENOSPC;
-        }
-
-        if(to + len > mtd->size) {
-                len = mtd->size - to;
-        }
-
-        err = write_pages(dev, buf, to, len, retlen);
-        if(err > 0)
-                err = 0;
-        DEBUG(2, "blkmtd: write: end, err = %d\n", err);
-        return err;
-}
-
-
-/* sync the device - wait until the write queue is empty */
-static void blkmtd_sync(struct mtd_info *mtd)
-{
-        /* Currently all writes are synchronous */
-}
-
-
-static void free_device(struct blkmtd_dev *dev)
-{
-        DEBUG(2, "blkmtd: free_device() dev = %p\n", dev);
-        if(dev) {
-                kfree(dev->mtd_info.eraseregions);
-                kfree(dev->mtd_info.name);
-                if(dev->blkdev) {
-                        invalidate_inode_pages(dev->blkdev->bd_inode->i_mapping);
-                        close_bdev_excl(dev->blkdev);
-                }
-                kfree(dev);
-        }
-}
-
-
-/* For a given size and initial erase size, calculate the number
- * and size of each erase region. Goes round the loop twice,
- * once to find out how many regions, then allocates space,
- * then round the loop again to fill it in.
- */
-static struct mtd_erase_region_info *calc_erase_regions(
-        size_t erase_size, size_t total_size, int *regions)
-{
-        struct mtd_erase_region_info *info = NULL;
-
-        DEBUG(2, "calc_erase_regions, es = %zd size = %zd regions = %d\n",
-              erase_size, total_size, *regions);
-        /* Make any user specified erasesize be a power of 2
-           and at least PAGE_SIZE */
-        if(erase_size) {
-                int es = erase_size;
-                erase_size = 1;
-                while(es != 1) {
-                        es >>= 1;
-                        erase_size <<= 1;
-                }
-                if(erase_size < PAGE_SIZE)
-                        erase_size = PAGE_SIZE;
-        } else {
-                erase_size = CONFIG_MTD_BLKDEV_ERASESIZE;
-        }
-
-        *regions = 0;
-
-        do {
-                int tot_size = total_size;
-                int er_size = erase_size;
-                int count = 0, offset = 0, regcnt = 0;
-
-                while(tot_size) {
-                        count = tot_size / er_size;
-                        if(count) {
-                                tot_size = tot_size % er_size;
-                                if(info) {
-                                        DEBUG(2, "adding to erase info off=%d er=%d cnt=%d\n",
-                                              offset, er_size, count);
-                                        (info+regcnt)->offset = offset;
-                                        (info+regcnt)->erasesize = er_size;
-                                        (info+regcnt)->numblocks = count;
-                                        (*regions)++;
-                                }
-                                regcnt++;
-                                offset += (count * er_size);
-                        }
-                        while(er_size > tot_size)
-                                er_size >>= 1;
-                }
-                if(info == NULL) {
-                        info = kmalloc(regcnt * sizeof(struct mtd_erase_region_info), GFP_KERNEL);
-                        if(!info)
-                                break;
-                }
-        } while(!(*regions));
-        DEBUG(2, "calc_erase_regions done, es = %zd size = %zd regions = %d\n",
-              erase_size, total_size, *regions);
-        return info;
-}
-
-
-static struct blkmtd_dev *add_device(char *devname, int readonly, int erase_size)
-{
-        struct block_device *bdev;
-        int mode;
-        struct blkmtd_dev *dev;
-
-        if(!devname)
-                return NULL;
-
-        /* Get a handle on the device */
-
-
-#ifdef MODULE
-        mode = (readonly) ? O_RDONLY : O_RDWR;
-        bdev = open_bdev_excl(devname, mode, NULL);
-#else
-        mode = (readonly) ? FMODE_READ : FMODE_WRITE;
-        bdev = open_by_devnum(name_to_dev_t(devname), mode);
-#endif
-        if(IS_ERR(bdev)) {
-                err("error: cannot open device %s", devname);
-                DEBUG(2, "blkmtd: opening bdev returned %ld\n", PTR_ERR(bdev));
-                return NULL;
-        }
-
-        DEBUG(1, "blkmtd: found a block device major = %d, minor = %d\n",
-              MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
-
-        if(MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
-                err("attempting to use an MTD device as a block device");
-                blkdev_put(bdev);
-                return NULL;
-        }
-
-        dev = kmalloc(sizeof(struct blkmtd_dev), GFP_KERNEL);
-        if(dev == NULL) {
-                blkdev_put(bdev);
-                return NULL;
-        }
-
-        memset(dev, 0, sizeof(struct blkmtd_dev));
-        dev->blkdev = bdev;
-        if(!readonly) {
-                mutex_init(&dev->wrbuf_mutex);
-        }
-
-        dev->mtd_info.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
-
-        /* Setup the MTD structure */
-        /* make the name contain the block device in */
-        dev->mtd_info.name = kmalloc(sizeof("blkmtd: ") + strlen(devname), GFP_KERNEL);
-        if(dev->mtd_info.name == NULL)
-                goto devinit_err;
-
-        sprintf(dev->mtd_info.name, "blkmtd: %s", devname);
-        dev->mtd_info.eraseregions = calc_erase_regions(erase_size, dev->mtd_info.size,
-                                                        &dev->mtd_info.numeraseregions);
-        if(dev->mtd_info.eraseregions == NULL)
-                goto devinit_err;
-
-        dev->mtd_info.erasesize = dev->mtd_info.eraseregions->erasesize;
-        DEBUG(1, "blkmtd: init: found %d erase regions\n",
-              dev->mtd_info.numeraseregions);
-
-        if(readonly) {
-                dev->mtd_info.type = MTD_ROM;
-                dev->mtd_info.flags = MTD_CAP_ROM;
-        } else {
-                dev->mtd_info.type = MTD_RAM;
-                dev->mtd_info.flags = MTD_CAP_RAM;
-                dev->mtd_info.erase = blkmtd_erase;
-                dev->mtd_info.write = blkmtd_write;
-                dev->mtd_info.writev = default_mtd_writev;
-                dev->mtd_info.sync = blkmtd_sync;
-        }
-        dev->mtd_info.read = blkmtd_read;
-        dev->mtd_info.readv = default_mtd_readv;
-        dev->mtd_info.priv = dev;
-        dev->mtd_info.owner = THIS_MODULE;
-
-        list_add(&dev->list, &blkmtd_device_list);
-        if (add_mtd_device(&dev->mtd_info)) {
-                /* Device didnt get added, so free the entry */
-                list_del(&dev->list);
-                goto devinit_err;
-        } else {
-                info("mtd%d: [%s] erase_size = %dKiB %s",
-                     dev->mtd_info.index, dev->mtd_info.name + strlen("blkmtd: "),
-                     dev->mtd_info.erasesize >> 10,
-                     readonly ? "(read-only)" : "");
-        }
-
-        return dev;
-
- devinit_err:
-        free_device(dev);
-        return NULL;
-}
-
-
-/* Cleanup and exit - sync the device and kill of the kernel thread */
-static void __devexit cleanup_blkmtd(void)
-{
-        struct list_head *temp1, *temp2;
-
-        /* Remove the MTD devices */
-        list_for_each_safe(temp1, temp2, &blkmtd_device_list) {
-                struct blkmtd_dev *dev = list_entry(temp1, struct blkmtd_dev,
-                                                    list);
-                blkmtd_sync(&dev->mtd_info);
-                del_mtd_device(&dev->mtd_info);
-                info("mtd%d: [%s] removed", dev->mtd_info.index,
-                     dev->mtd_info.name + strlen("blkmtd: "));
-                list_del(&dev->list);
-                free_device(dev);
-        }
-}
-
-#ifndef MODULE
-
-/* Handle kernel boot params */
-
-
-static int __init param_blkmtd_device(char *str)
-{
-        int i;
-
-        for(i = 0; i < MAX_DEVICES; i++) {
-                device[i] = str;
-                DEBUG(2, "blkmtd: device setup: %d = %s\n", i, device[i]);
-                strsep(&str, ",");
-        }
-        return 1;
-}
-
-
-static int __init param_blkmtd_erasesz(char *str)
-{
-        int i;
-        for(i = 0; i < MAX_DEVICES; i++) {
-                char *val = strsep(&str, ",");
-                if(val)
-                        erasesz[i] = simple_strtoul(val, NULL, 0);
-                DEBUG(2, "blkmtd: erasesz setup: %d = %d\n", i, erasesz[i]);
-        }
-
-        return 1;
-}
-
-
-static int __init param_blkmtd_ro(char *str)
-{
-        int i;
-        for(i = 0; i < MAX_DEVICES; i++) {
-                char *val = strsep(&str, ",");
-                if(val)
-                        ro[i] = simple_strtoul(val, NULL, 0);
-                DEBUG(2, "blkmtd: ro setup: %d = %d\n", i, ro[i]);
-        }
-
-        return 1;
-}
-
-
-static int __init param_blkmtd_sync(char *str)
-{
-        if(str[0] == '1')
-                sync = 1;
-        return 1;
-}
-
-__setup("blkmtd_device=", param_blkmtd_device);
-__setup("blkmtd_erasesz=", param_blkmtd_erasesz);
-__setup("blkmtd_ro=", param_blkmtd_ro);
-__setup("blkmtd_sync=", param_blkmtd_sync);
-
-#endif
-
-
-/* Startup */
-static int __init init_blkmtd(void)
-{
-        int i;
-
-        info("version " VERSION);
-        /* Check args - device[0] is the bare minimum*/
-        if(!device[0]) {
-                err("error: missing `device' name\n");
-                return -EINVAL;
-        }
-
-        for(i = 0; i < MAX_DEVICES; i++)
-                add_device(device[i], ro[i], erasesz[i] << 10);
-
-        if(list_empty(&blkmtd_device_list))
-                return -EINVAL;
-
-        return 0;
-}
-
-module_init(init_blkmtd);
-module_exit(cleanup_blkmtd);
diff --git a/drivers/mtd/maps/pcmciamtd.c b/drivers/mtd/maps/pcmciamtd.c
index 8bbc751a6021..d27f4129afd3 100644
--- a/drivers/mtd/maps/pcmciamtd.c
+++ b/drivers/mtd/maps/pcmciamtd.c
@@ -54,7 +54,7 @@ static const int debug = 0;
 #define MAX_PCMCIA_ADDR 0x4000000
 
 struct pcmciamtd_dev {
-        dev_link_t      link;           /* PCMCIA link */
+        struct pcmcia_device    *p_dev;
         dev_node_t      node;           /* device node */
         caddr_t         win_base;       /* ioremapped address of PCMCIA window */
         unsigned int    win_size;       /* size of window */
@@ -111,8 +111,8 @@ static caddr_t remap_window(struct map_info *map, unsigned long to)
         memreq_t mrq;
         int ret;
 
-        if(!(dev->link.state & DEV_PRESENT)) {
-                DEBUG(1, "device removed state = 0x%4.4X", dev->link.state);
+        if (!pcmcia_dev_present(dev->p_dev)) {
+                DEBUG(1, "device removed");
                 return 0;
         }
 
@@ -122,7 +122,7 @@ static caddr_t remap_window(struct map_info *map, unsigned long to)
                       dev->offset, mrq.CardOffset);
                 mrq.Page = 0;
                 if( (ret = pcmcia_map_mem_page(win, &mrq)) != CS_SUCCESS) {
-                        cs_error(dev->link.handle, MapMemPage, ret);
+                        cs_error(dev->p_dev, MapMemPage, ret);
                         return NULL;
                 }
                 dev->offset = mrq.CardOffset;
@@ -238,7 +238,7 @@ static void pcmcia_copy_to_remap(struct map_info *map, unsigned long to, const v
 
 /* read/write{8,16} copy_{from,to} routines with direct access */
 
-#define DEV_REMOVED(x)  (!(*(u_int *)x->map_priv_1 & DEV_PRESENT))
+#define DEV_REMOVED(x)  (!(pcmcia_dev_present(((struct pcmciamtd_dev *)map->map_priv_1)->p_dev)))
 
 static map_word pcmcia_read8(struct map_info *map, unsigned long ofs)
 {
@@ -319,7 +319,7 @@ static void pcmcia_copy_to(struct map_info *map, unsigned long to, const void *f
 static void pcmciamtd_set_vpp(struct map_info *map, int on)
 {
         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
-        dev_link_t *link = &dev->link;
+        struct pcmcia_device *link = dev->p_dev;
         modconf_t mod;
         int ret;
 
@@ -328,9 +328,9 @@ static void pcmciamtd_set_vpp(struct map_info *map, int on)
         mod.Vpp1 = mod.Vpp2 = on ? dev->vpp : 0;
 
         DEBUG(2, "dev = %p on = %d vpp = %d\n", dev, on, dev->vpp);
-        ret = pcmcia_modify_configuration(link->handle, &mod);
+        ret = pcmcia_modify_configuration(link, &mod);
         if(ret != CS_SUCCESS) {
-                cs_error(link->handle, ModifyConfiguration, ret);
+                cs_error(link, ModifyConfiguration, ret);
         }
 }
 
@@ -340,7 +340,7 @@ static void pcmciamtd_set_vpp(struct map_info *map, int on)
  * still open, this will be postponed until it is closed.
  */
 
-static void pcmciamtd_release(dev_link_t *link)
+static void pcmciamtd_release(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev = link->priv;
 
@@ -353,12 +353,11 @@ static void pcmciamtd_release(dev_link_t *link)
                 }
                 pcmcia_release_window(link->win);
         }
-        pcmcia_release_configuration(link->handle);
-        link->state &= ~DEV_CONFIG;
+        pcmcia_disable_device(link);
 }
 
 
-static void card_settings(struct pcmciamtd_dev *dev, dev_link_t *link, int *new_name)
+static void card_settings(struct pcmciamtd_dev *dev, struct pcmcia_device *link, int *new_name)
 {
         int rc;
         tuple_t tuple;
@@ -371,16 +370,16 @@ static void card_settings(struct pcmciamtd_dev *dev, dev_link_t *link, int *new_
         tuple.TupleOffset = 0;
         tuple.DesiredTuple = RETURN_FIRST_TUPLE;
 
-        rc = pcmcia_get_first_tuple(link->handle, &tuple);
+        rc = pcmcia_get_first_tuple(link, &tuple);
         while(rc == CS_SUCCESS) {
-                rc = pcmcia_get_tuple_data(link->handle, &tuple);
+                rc = pcmcia_get_tuple_data(link, &tuple);
                 if(rc != CS_SUCCESS) {
-                        cs_error(link->handle, GetTupleData, rc);
+                        cs_error(link, GetTupleData, rc);
                         break;
                 }
-                rc = pcmcia_parse_tuple(link->handle, &tuple, &parse);
+                rc = pcmcia_parse_tuple(link, &tuple, &parse);
                 if(rc != CS_SUCCESS) {
-                        cs_error(link->handle, ParseTuple, rc);
+                        cs_error(link, ParseTuple, rc);
                         break;
                 }
 
@@ -451,7 +450,7 @@ static void card_settings(struct pcmciamtd_dev *dev, dev_link_t *link, int *new_
                         DEBUG(2, "Unknown tuple code %d", tuple.TupleCode);
                 }
 
-                rc = pcmcia_get_next_tuple(link->handle, &tuple);
+                rc = pcmcia_get_next_tuple(link, &tuple);
         }
         if(!dev->pcmcia_map.size)
                 dev->pcmcia_map.size = MAX_PCMCIA_ADDR;
@@ -488,7 +487,7 @@ static void card_settings(struct pcmciamtd_dev *dev, dev_link_t *link, int *new_
 #define CS_CHECK(fn, ret) \
 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 
-static void pcmciamtd_config(dev_link_t *link)
+static int pcmciamtd_config(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev = link->priv;
         struct mtd_info *mtd = NULL;
@@ -504,13 +503,10 @@ static void pcmciamtd_config(dev_link_t *link)
 
         DEBUG(3, "link=0x%p", link);
 
-        /* Configure card */
-        link->state |= DEV_CONFIG;
-
         DEBUG(2, "Validating CIS");
-        ret = pcmcia_validate_cis(link->handle, &cisinfo);
+        ret = pcmcia_validate_cis(link, &cisinfo);
         if(ret != CS_SUCCESS) {
-                cs_error(link->handle, GetTupleData, ret);
+                cs_error(link, GetTupleData, ret);
         } else {
                 DEBUG(2, "ValidateCIS found %d chains", cisinfo.Chains);
         }
@@ -538,7 +534,7 @@ static void pcmciamtd_config(dev_link_t *link)
         req.Attributes |= (dev->pcmcia_map.bankwidth == 1) ? WIN_DATA_WIDTH_8 : WIN_DATA_WIDTH_16;
         req.Base = 0;
         req.AccessSpeed = mem_speed;
-        link->win = (window_handle_t)link->handle;
+        link->win = (window_handle_t)link;
         req.Size = (force_size) ? force_size << 20 : MAX_PCMCIA_ADDR;
         dev->win_size = 0;
 
@@ -546,7 +542,7 @@ static void pcmciamtd_config(dev_link_t *link)
                 int ret;
                 DEBUG(2, "requesting window with size = %dKiB memspeed = %d",
                       req.Size >> 10, req.AccessSpeed);
-                ret = pcmcia_request_window(&link->handle, &req, &link->win);
+                ret = pcmcia_request_window(&link, &req, &link->win);
                 DEBUG(2, "ret = %d dev->win_size = %d", ret, dev->win_size);
                 if(ret) {
                         req.Size >>= 1;
@@ -562,19 +558,19 @@ static void pcmciamtd_config(dev_link_t *link)
         if(!dev->win_size) {
                 err("Cant allocate memory window");
                 pcmciamtd_release(link);
-                return;
+                return -ENODEV;
         }
         DEBUG(1, "Allocated a window of %dKiB", dev->win_size >> 10);
 
         /* Get write protect status */
-        CS_CHECK(GetStatus, pcmcia_get_status(link->handle, &status));
+        CS_CHECK(GetStatus, pcmcia_get_status(link, &status));
         DEBUG(2, "status value: 0x%x window handle = 0x%8.8lx",
               status.CardState, (unsigned long)link->win);
         dev->win_base = ioremap(req.Base, req.Size);
         if(!dev->win_base) {
                 err("ioremap(%lu, %u) failed", req.Base, req.Size);
                 pcmciamtd_release(link);
-                return;
+                return -ENODEV;
         }
         DEBUG(1, "mapped window dev = %p req.base = 0x%lx base = %p size = 0x%x",
               dev, req.Base, dev->win_base, req.Size);
@@ -584,17 +580,14 @@ static void pcmciamtd_config(dev_link_t *link)
         dev->pcmcia_map.map_priv_2 = (unsigned long)link->win;
 
         DEBUG(2, "Getting configuration");
-        CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link->handle, &t));
+        CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &t));
         DEBUG(2, "Vcc = %d Vpp1 = %d Vpp2 = %d", t.Vcc, t.Vpp1, t.Vpp2);
         dev->vpp = (vpp) ? vpp : t.Vpp1;
         link->conf.Attributes = 0;
-        link->conf.Vcc = t.Vcc;
         if(setvpp == 2) {
-                link->conf.Vpp1 = dev->vpp;
-                link->conf.Vpp2 = dev->vpp;
+                link->conf.Vpp = dev->vpp;
         } else {
-                link->conf.Vpp1 = 0;
-                link->conf.Vpp2 = 0;
+                link->conf.Vpp = 0;
         }
 
         link->conf.IntType = INT_MEMORY;
@@ -606,9 +599,10 @@ static void pcmciamtd_config(dev_link_t *link)
         link->conf.ConfigIndex = 0;
         link->conf.Present = t.Present;
         DEBUG(2, "Setting Configuration");
-        ret = pcmcia_request_configuration(link->handle, &link->conf);
+        ret = pcmcia_request_configuration(link, &link->conf);
         if(ret != CS_SUCCESS) {
-                cs_error(link->handle, RequestConfiguration, ret);
+                cs_error(link, RequestConfiguration, ret);
+                return -ENODEV;
         }
 
         if(mem_type == 1) {
@@ -629,7 +623,7 @@ static void pcmciamtd_config(dev_link_t *link)
         if(!mtd) {
                 DEBUG(1, "Cant find an MTD");
                 pcmciamtd_release(link);
-                return;
+                return -ENODEV;
         }
 
         dev->mtd_info = mtd;
@@ -654,7 +648,6 @@ static void pcmciamtd_config(dev_link_t *link)
            use the faster non-remapping read/write functions */
         if(mtd->size <= dev->win_size) {
                 DEBUG(1, "Using non remapping memory functions");
-                dev->pcmcia_map.map_priv_1 = (unsigned long)&(dev->link.state);
                 dev->pcmcia_map.map_priv_2 = (unsigned long)dev->win_base;
                 if (dev->pcmcia_map.bankwidth == 1) {
                         dev->pcmcia_map.read = pcmcia_read8;
@@ -672,19 +665,18 @@ static void pcmciamtd_config(dev_link_t *link)
                 dev->mtd_info = NULL;
                 err("Couldnt register MTD device");
                 pcmciamtd_release(link);
-                return;
+                return -ENODEV;
         }
         snprintf(dev->node.dev_name, sizeof(dev->node.dev_name), "mtd%d", mtd->index);
         info("mtd%d: %s", mtd->index, mtd->name);
-        link->state &= ~DEV_CONFIG_PENDING;
-        link->dev = &dev->node;
-        return;
+        link->dev_node = &dev->node;
+        return 0;
 
  cs_failed:
-        cs_error(link->handle, last_fn, last_ret);
+        cs_error(link, last_fn, last_ret);
         err("CS Error, exiting");
         pcmciamtd_release(link);
-        return;
+        return -ENODEV;
 }
 
 
@@ -713,21 +705,18 @@ static int pcmciamtd_resume(struct pcmcia_device *dev)
  * when the device is released.
  */
 
-static void pcmciamtd_detach(struct pcmcia_device *p_dev)
+static void pcmciamtd_detach(struct pcmcia_device *link)
 {
-        dev_link_t *link = dev_to_instance(p_dev);
+        struct pcmciamtd_dev *dev = link->priv;
 
         DEBUG(3, "link=0x%p", link);
 
-        if(link->state & DEV_CONFIG) {
-                struct pcmciamtd_dev *dev = link->priv;
-                if(dev->mtd_info) {
-                        del_mtd_device(dev->mtd_info);
-                        info("mtd%d: Removed", dev->mtd_info->index);
-                }
-
-                pcmciamtd_release(link);
+        if(dev->mtd_info) {
+                del_mtd_device(dev->mtd_info);
+                info("mtd%d: Removed", dev->mtd_info->index);
         }
+
+        pcmciamtd_release(link);
 }
 
 
@@ -736,10 +725,9 @@ static void pcmciamtd_detach(struct pcmcia_device *p_dev)
  * with Card Services.
  */
 
-static int pcmciamtd_attach(struct pcmcia_device *p_dev)
+static int pcmciamtd_probe(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev;
-        dev_link_t *link;
 
         /* Create new memory card device */
         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
@@ -747,20 +735,13 @@ static int pcmciamtd_attach(struct pcmcia_device *p_dev)
         DEBUG(1, "dev=0x%p", dev);
 
         memset(dev, 0, sizeof(*dev));
-        link = &dev->link;
+        dev->p_dev = link;
         link->priv = dev;
 
         link->conf.Attributes = 0;
         link->conf.IntType = INT_MEMORY;
 
-        link->next = NULL;
-        link->handle = p_dev;
-        p_dev->instance = link;
-
-        link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
-        pcmciamtd_config(link);
-
-        return 0;
+        return pcmciamtd_config(link);
 }
 
 static struct pcmcia_device_id pcmciamtd_ids[] = {
@@ -794,7 +775,7 @@ static struct pcmcia_driver pcmciamtd_driver = {
         .drv            = {
                 .name   = "pcmciamtd"
         },
-        .probe          = pcmciamtd_attach,
+        .probe          = pcmciamtd_probe,
         .remove         = pcmciamtd_detach,
         .owner          = THIS_MODULE,
         .id_table       = pcmciamtd_ids,