26 files changed, 189 insertions, 247 deletions

diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index dd0279249bf4..31b034b7eba3 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -110,7 +110,7 @@ config MTD_NAND_AMS_DELTA
 
 config MTD_NAND_OMAP2
         tristate "NAND Flash device on OMAP2, OMAP3 and OMAP4"
-        depends on ARM && (ARCH_OMAP2 || ARCH_OMAP3 || ARCH_OMAP4)
+        depends on ARCH_OMAP2PLUS
         help
           Support for NAND flash on Texas Instruments OMAP2, OMAP3 and OMAP4
           platforms.
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index 9e6b498c9beb..3197e9764fcd 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -280,17 +280,7 @@ static struct platform_driver ams_delta_nand_driver = {
         },
 };
 
-static int __init ams_delta_nand_init(void)
-{
-        return platform_driver_register(&ams_delta_nand_driver);
-}
-module_init(ams_delta_nand_init);
-
-static void __exit ams_delta_nand_exit(void)
-{
-        platform_driver_unregister(&ams_delta_nand_driver);
-}
-module_exit(ams_delta_nand_exit);
+module_platform_driver(ams_delta_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Jonathan McDowell <noodles@earth.li>");
diff --git a/drivers/mtd/nand/bcm_umi_nand.c b/drivers/mtd/nand/bcm_umi_nand.c
index 46b58d672847..50387fd4009b 100644
--- a/drivers/mtd/nand/bcm_umi_nand.c
+++ b/drivers/mtd/nand/bcm_umi_nand.c
@@ -546,18 +546,7 @@ static struct platform_driver nand_driver = {
         .resume = bcm_umi_nand_resume,
 };
 
-static int __init nand_init(void)
-{
-        return platform_driver_register(&nand_driver);
-}
-
-static void __exit nand_exit(void)
-{
-        platform_driver_unregister(&nand_driver);
-}
-
-module_init(nand_init);
-module_exit(nand_exit);
+module_platform_driver(nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Broadcom");
diff --git a/drivers/mtd/nand/davinci_nand.c b/drivers/mtd/nand/davinci_nand.c
index c153e1f77f90..6e566156956f 100644
--- a/drivers/mtd/nand/davinci_nand.c
+++ b/drivers/mtd/nand/davinci_nand.c
@@ -675,7 +675,9 @@ static int __init nand_davinci_probe(struct platform_device *pdev)
 
         davinci_nand_writel(info, A1CR_OFFSET + info->core_chipsel * 4, val);
 
-        ret = davinci_aemif_setup_timing(info->timing, info->base,
+        ret = 0;
+        if (info->timing)
+                ret = davinci_aemif_setup_timing(info->timing, info->base,
                                                         info->core_chipsel);
         if (ret < 0) {
                 dev_dbg(&pdev->dev, "NAND timing values setup fail\n");
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index 5780dbab6113..df921e7a496c 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -1072,7 +1072,7 @@ static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const ch
         size_t retlen;
 
         for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
-                ret = mtd->read(mtd, offs, mtd->writesize, &retlen, buf);
+                ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
                 if (retlen != mtd->writesize)
                         continue;
                 if (ret) {
@@ -1097,7 +1097,7 @@ static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const ch
         /* Only one mediaheader was found.  We want buf to contain a
            mediaheader on return, so we'll have to re-read the one we found. */
         offs = doc->mh0_page << this->page_shift;
-        ret = mtd->read(mtd, offs, mtd->writesize, &retlen, buf);
+        ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
         if (retlen != mtd->writesize) {
                 /* Insanity.  Give up. */
                 printk(KERN_ERR "Read DiskOnChip Media Header once, but can't reread it???\n");
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index eedd8ee2c9ac..7195ee6efe12 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -166,15 +166,22 @@ static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
 
         elbc_fcm_ctrl->page = page_addr;
 
-        out_be32(&lbc->fbar,
-                 page_addr >> (chip->phys_erase_shift - chip->page_shift));
-
         if (priv->page_size) {
+                /*
+                 * large page size chip : FPAR[PI] save the lowest 6 bits,
+                 *                        FBAR[BLK] save the other bits.
+                 */
+                out_be32(&lbc->fbar, page_addr >> 6);
                 out_be32(&lbc->fpar,
                          ((page_addr << FPAR_LP_PI_SHIFT) & FPAR_LP_PI) |
                          (oob ? FPAR_LP_MS : 0) | column);
                 buf_num = (page_addr & 1) << 2;
         } else {
+                /*
+                 * small page size chip : FPAR[PI] save the lowest 5 bits,
+                 *                        FBAR[BLK] save the other bits.
+                 */
+                out_be32(&lbc->fbar, page_addr >> 5);
                 out_be32(&lbc->fpar,
                          ((page_addr << FPAR_SP_PI_SHIFT) & FPAR_SP_PI) |
                          (oob ? FPAR_SP_MS : 0) | column);
@@ -349,20 +356,22 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                 fsl_elbc_run_command(mtd);
                 return;
 
-        /* READID must read all 5 possible bytes while CEB is active */
         case NAND_CMD_READID:
-                dev_vdbg(priv->dev, "fsl_elbc_cmdfunc: NAND_CMD_READID.\n");
+        case NAND_CMD_PARAM:
+                dev_vdbg(priv->dev, "fsl_elbc_cmdfunc: NAND_CMD %x\n", command);
 
                 out_be32(&lbc->fir, (FIR_OP_CM0 << FIR_OP0_SHIFT) |
                                     (FIR_OP_UA  << FIR_OP1_SHIFT) |
                                     (FIR_OP_RBW << FIR_OP2_SHIFT));
-                out_be32(&lbc->fcr, NAND_CMD_READID << FCR_CMD0_SHIFT);
-                /* nand_get_flash_type() reads 8 bytes of entire ID string */
-                out_be32(&lbc->fbcr, 8);
-                elbc_fcm_ctrl->read_bytes = 8;
+                out_be32(&lbc->fcr, command << FCR_CMD0_SHIFT);
+                /*
+                 * although currently it's 8 bytes for READID, we always read
+                 * the maximum 256 bytes(for PARAM)
+                 */
+                out_be32(&lbc->fbcr, 256);
+                elbc_fcm_ctrl->read_bytes = 256;
                 elbc_fcm_ctrl->use_mdr = 1;
-                elbc_fcm_ctrl->mdr = 0;
-
+                elbc_fcm_ctrl->mdr = column;
                 set_addr(mtd, 0, 0, 0);
                 fsl_elbc_run_command(mtd);
                 return;
@@ -407,9 +416,17 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                          page_addr, column);
 
                 elbc_fcm_ctrl->column = column;
-                elbc_fcm_ctrl->oob = 0;
                 elbc_fcm_ctrl->use_mdr = 1;
 
+                if (column >= mtd->writesize) {
+                        /* OOB area */
+                        column -= mtd->writesize;
+                        elbc_fcm_ctrl->oob = 1;
+                } else {
+                        WARN_ON(column != 0);
+                        elbc_fcm_ctrl->oob = 0;
+                }
+
                 fcr = (NAND_CMD_STATUS   << FCR_CMD1_SHIFT) |
                       (NAND_CMD_SEQIN    << FCR_CMD2_SHIFT) |
                       (NAND_CMD_PAGEPROG << FCR_CMD3_SHIFT);
@@ -434,16 +451,12 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                                  (FIR_OP_CW1 << FIR_OP6_SHIFT) |
                                  (FIR_OP_RS  << FIR_OP7_SHIFT));
 
-                        if (column >= mtd->writesize) {
+                        if (elbc_fcm_ctrl->oob)
                                 /* OOB area --> READOOB */
-                                column -= mtd->writesize;
                                 fcr |= NAND_CMD_READOOB << FCR_CMD0_SHIFT;
-                                elbc_fcm_ctrl->oob = 1;
-                        } else {
-                                WARN_ON(column != 0);
+                        else
                                 /* First 256 bytes --> READ0 */
                                 fcr |= NAND_CMD_READ0 << FCR_CMD0_SHIFT;
-                        }
                 }
 
                 out_be32(&lbc->fcr, fcr);
@@ -463,7 +476,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                  */
                 if (elbc_fcm_ctrl->oob || elbc_fcm_ctrl->column != 0 ||
                     elbc_fcm_ctrl->index != mtd->writesize + mtd->oobsize)
-                        out_be32(&lbc->fbcr, elbc_fcm_ctrl->index);
+                        out_be32(&lbc->fbcr,
+                                elbc_fcm_ctrl->index - elbc_fcm_ctrl->column);
                 else
                         out_be32(&lbc->fbcr, 0);
 
@@ -659,9 +673,7 @@ static int fsl_elbc_chip_init_tail(struct mtd_info *mtd)
         if (chip->pagemask & 0xff000000)
                 al++;
 
-        /* add to ECCM mode set in fsl_elbc_init */
-        priv->fmr |= (12 << FMR_CWTO_SHIFT) |  /* Timeout > 12 ms */
-                     (al << FMR_AL_SHIFT);
+        priv->fmr |= al << FMR_AL_SHIFT;
 
         dev_dbg(priv->dev, "fsl_elbc_init: nand->numchips = %d\n",
                 chip->numchips);
@@ -764,8 +776,10 @@ static int fsl_elbc_chip_init(struct fsl_elbc_mtd *priv)
         priv->mtd.priv = chip;
         priv->mtd.owner = THIS_MODULE;
 
-        /* Set the ECCM according to the settings in bootloader.*/
-        priv->fmr = in_be32(&lbc->fmr) & FMR_ECCM;
+        /* set timeout to maximum */
+        priv->fmr = 15 << FMR_CWTO_SHIFT;
+        if (in_be32(&lbc->bank[priv->bank].or) & OR_FCM_PGS)
+                priv->fmr |= FMR_ECCM;
 
         /* fill in nand_chip structure */
         /* set up function call table */
@@ -971,18 +985,7 @@ static struct platform_driver fsl_elbc_nand_driver = {
         .remove = fsl_elbc_nand_remove,
 };
 
-static int __init fsl_elbc_nand_init(void)
-{
-        return platform_driver_register(&fsl_elbc_nand_driver);
-}
-
-static void __exit fsl_elbc_nand_exit(void)
-{
-        platform_driver_unregister(&fsl_elbc_nand_driver);
-}
-
-module_init(fsl_elbc_nand_init);
-module_exit(fsl_elbc_nand_exit);
+module_platform_driver(fsl_elbc_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Freescale");
diff --git a/drivers/mtd/nand/fsl_upm.c b/drivers/mtd/nand/fsl_upm.c
index b4f3cc9f32fb..45df542b9c61 100644
--- a/drivers/mtd/nand/fsl_upm.c
+++ b/drivers/mtd/nand/fsl_upm.c
@@ -353,17 +353,7 @@ static struct platform_driver of_fun_driver = {
         .remove         = __devexit_p(fun_remove),
 };
 
-static int __init fun_module_init(void)
-{
-        return platform_driver_register(&of_fun_driver);
-}
-module_init(fun_module_init);
-
-static void __exit fun_module_exit(void)
-{
-        platform_driver_unregister(&of_fun_driver);
-}
-module_exit(fun_module_exit);
+module_platform_driver(of_fun_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Anton Vorontsov <avorontsov@ru.mvista.com>");
diff --git a/drivers/mtd/nand/gpio.c b/drivers/mtd/nand/gpio.c
index 2c2060b2800e..27000a5f5f47 100644
--- a/drivers/mtd/nand/gpio.c
+++ b/drivers/mtd/nand/gpio.c
@@ -27,6 +27,9 @@
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/nand-gpio.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_gpio.h>
 
 struct gpiomtd {
         void __iomem            *io_sync;
@@ -171,6 +174,96 @@ static int gpio_nand_devready(struct mtd_info *mtd)
         return gpio_get_value(gpiomtd->plat.gpio_rdy);
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id gpio_nand_id_table[] = {
+        { .compatible = "gpio-control-nand" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, gpio_nand_id_table);
+
+static int gpio_nand_get_config_of(const struct device *dev,
+                                   struct gpio_nand_platdata *plat)
+{
+        u32 val;
+
+        if (!of_property_read_u32(dev->of_node, "bank-width", &val)) {
+                if (val == 2) {
+                        plat->options |= NAND_BUSWIDTH_16;
+                } else if (val != 1) {
+                        dev_err(dev, "invalid bank-width %u\n", val);
+                        return -EINVAL;
+                }
+        }
+
+        plat->gpio_rdy = of_get_gpio(dev->of_node, 0);
+        plat->gpio_nce = of_get_gpio(dev->of_node, 1);
+        plat->gpio_ale = of_get_gpio(dev->of_node, 2);
+        plat->gpio_cle = of_get_gpio(dev->of_node, 3);
+        plat->gpio_nwp = of_get_gpio(dev->of_node, 4);
+
+        if (!of_property_read_u32(dev->of_node, "chip-delay", &val))
+                plat->chip_delay = val;
+
+        return 0;
+}
+
+static struct resource *gpio_nand_get_io_sync_of(struct platform_device *pdev)
+{
+        struct resource *r = devm_kzalloc(&pdev->dev, sizeof(*r), GFP_KERNEL);
+        u64 addr;
+
+        if (!r || of_property_read_u64(pdev->dev.of_node,
+                                       "gpio-control-nand,io-sync-reg", &addr))
+                return NULL;
+
+        r->start = addr;
+        r->end = r->start + 0x3;
+        r->flags = IORESOURCE_MEM;
+
+        return r;
+}
+#else /* CONFIG_OF */
+#define gpio_nand_id_table NULL
+static inline int gpio_nand_get_config_of(const struct device *dev,
+                                          struct gpio_nand_platdata *plat)
+{
+        return -ENOSYS;
+}
+
+static inline struct resource *
+gpio_nand_get_io_sync_of(struct platform_device *pdev)
+{
+        return NULL;
+}
+#endif /* CONFIG_OF */
+
+static inline int gpio_nand_get_config(const struct device *dev,
+                                       struct gpio_nand_platdata *plat)
+{
+        int ret = gpio_nand_get_config_of(dev, plat);
+
+        if (!ret)
+                return ret;
+
+        if (dev->platform_data) {
+                memcpy(plat, dev->platform_data, sizeof(*plat));
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+static inline struct resource *
+gpio_nand_get_io_sync(struct platform_device *pdev)
+{
+        struct resource *r = gpio_nand_get_io_sync_of(pdev);
+
+        if (r)
+                return r;
+
+        return platform_get_resource(pdev, IORESOURCE_MEM, 1);
+}
+
 static int __devexit gpio_nand_remove(struct platform_device *dev)
 {
         struct gpiomtd *gpiomtd = platform_get_drvdata(dev);
@@ -178,7 +271,7 @@ static int __devexit gpio_nand_remove(struct platform_device *dev)
 
         nand_release(&gpiomtd->mtd_info);
 
-        res = platform_get_resource(dev, IORESOURCE_MEM, 1);
+        res = gpio_nand_get_io_sync(dev);
         iounmap(gpiomtd->io_sync);
         if (res)
                 release_mem_region(res->start, resource_size(res));
@@ -226,9 +319,10 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
         struct gpiomtd *gpiomtd;
         struct nand_chip *this;
         struct resource *res0, *res1;
-        int ret;
+        struct mtd_part_parser_data ppdata = {};
+        int ret = 0;
 
-        if (!dev->dev.platform_data)
+        if (!dev->dev.of_node && !dev->dev.platform_data)
                 return -EINVAL;
 
         res0 = platform_get_resource(dev, IORESOURCE_MEM, 0);
@@ -248,7 +342,7 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
                 goto err_map;
         }
 
-        res1 = platform_get_resource(dev, IORESOURCE_MEM, 1);
+        res1 = gpio_nand_get_io_sync(dev);
         if (res1) {
                 gpiomtd->io_sync = request_and_remap(res1, 4, "NAND sync", &ret);
                 if (!gpiomtd->io_sync) {
@@ -257,7 +351,9 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
                 }
         }
 
-        memcpy(&gpiomtd->plat, dev->dev.platform_data, sizeof(gpiomtd->plat));
+        ret = gpio_nand_get_config(&dev->dev, &gpiomtd->plat);
+        if (ret)
+                goto err_nce;
 
         ret = gpio_request(gpiomtd->plat.gpio_nce, "NAND NCE");
         if (ret)
@@ -316,8 +412,12 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
                 gpiomtd->plat.adjust_parts(&gpiomtd->plat,
                                            gpiomtd->mtd_info.size);
 
-        mtd_device_register(&gpiomtd->mtd_info, gpiomtd->plat.parts,
-                            gpiomtd->plat.num_parts);
+        ppdata.of_node = dev->dev.of_node;
+        ret = mtd_device_parse_register(&gpiomtd->mtd_info, NULL, &ppdata,
+                                        gpiomtd->plat.parts,
+                                        gpiomtd->plat.num_parts);
+        if (ret)
+                goto err_wp;
         platform_set_drvdata(dev, gpiomtd);
 
         return 0;
@@ -352,6 +452,7 @@ static struct platform_driver gpio_nand_driver = {
         .remove         = gpio_nand_remove,
         .driver         = {
                 .name   = "gpio-nand",
+                .of_match_table = gpio_nand_id_table,
         },
 };
 
diff --git a/drivers/mtd/nand/jz4740_nand.c b/drivers/mtd/nand/jz4740_nand.c
index e2664073a89b..ac3b9f255e00 100644
--- a/drivers/mtd/nand/jz4740_nand.c
+++ b/drivers/mtd/nand/jz4740_nand.c
@@ -423,17 +423,7 @@ static struct platform_driver jz_nand_driver = {
         },
 };
 
-static int __init jz_nand_init(void)
-{
-        return platform_driver_register(&jz_nand_driver);
-}
-module_init(jz_nand_init);
-
-static void __exit jz_nand_exit(void)
-{
-        platform_driver_unregister(&jz_nand_driver);
-}
-module_exit(jz_nand_exit);
+module_platform_driver(jz_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
diff --git a/drivers/mtd/nand/mpc5121_nfc.c b/drivers/mtd/nand/mpc5121_nfc.c
index 5ede64706346..c240cf1af961 100644
--- a/drivers/mtd/nand/mpc5121_nfc.c
+++ b/drivers/mtd/nand/mpc5121_nfc.c
@@ -879,19 +879,7 @@ static struct platform_driver mpc5121_nfc_driver = {
         },
 };
 
-static int __init mpc5121_nfc_init(void)
-{
-        return platform_driver_register(&mpc5121_nfc_driver);
-}
-
-module_init(mpc5121_nfc_init);
-
-static void __exit mpc5121_nfc_cleanup(void)
-{
-        platform_driver_unregister(&mpc5121_nfc_driver);
-}
-
-module_exit(mpc5121_nfc_cleanup);
+module_platform_driver(mpc5121_nfc_driver);
 
 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_DESCRIPTION("MPC5121 NAND MTD driver");
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 3ed9c5e4d34e..35b4565050f1 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -3132,8 +3132,8 @@ ident_done:
          * Bad block marker is stored in the last page of each block
          * on Samsung and Hynix MLC devices; stored in first two pages
          * of each block on Micron devices with 2KiB pages and on
-         * SLC Samsung, Hynix, Toshiba and AMD/Spansion. All others scan
-         * only the first page.
+         * SLC Samsung, Hynix, Toshiba, AMD/Spansion, and Macronix.
+         * All others scan only the first page.
          */
         if ((chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
                         (*maf_id == NAND_MFR_SAMSUNG ||
@@ -3143,7 +3143,8 @@ ident_done:
                                 (*maf_id == NAND_MFR_SAMSUNG ||
                                  *maf_id == NAND_MFR_HYNIX ||
                                  *maf_id == NAND_MFR_TOSHIBA ||
-                                 *maf_id == NAND_MFR_AMD)) ||
+                                 *maf_id == NAND_MFR_AMD ||
+                                 *maf_id == NAND_MFR_MACRONIX)) ||
                         (mtd->writesize == 2048 &&
                          *maf_id == NAND_MFR_MICRON))
                 chip->bbt_options |= NAND_BBT_SCAN2NDPAGE;
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index 69148ae3bf58..20a112f591fe 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -201,7 +201,7 @@ static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
                         from += marker_len;
                         marker_len = 0;
                 }
-                res = mtd->read(mtd, from, len, &retlen, buf);
+                res = mtd_read(mtd, from, len, &retlen, buf);
                 if (res < 0) {
                         if (mtd_is_eccerr(res)) {
                                 pr_info("nand_bbt: ECC error in BBT at "
@@ -298,7 +298,7 @@ static int scan_read_raw_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
         if (td->options & NAND_BBT_VERSION)
                 len++;
 
-        return mtd->read(mtd, offs, len, &retlen, buf);
+        return mtd_read(mtd, offs, len, &retlen, buf);
 }
 
 /* Scan read raw data from flash */
@@ -317,7 +317,7 @@ static int scan_read_raw_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
                 ops.len = min(len, (size_t)mtd->writesize);
                 ops.oobbuf = buf + ops.len;
 
-                res = mtd->read_oob(mtd, offs, &ops);
+                res = mtd_read_oob(mtd, offs, &ops);
 
                 if (res)
                         return res;
@@ -350,7 +350,7 @@ static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
         ops.oobbuf = oob;
         ops.len = len;
 
-        return mtd->write_oob(mtd, offs, &ops);
+        return mtd_write_oob(mtd, offs, &ops);
 }
 
 static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
@@ -434,7 +434,7 @@ static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
                  * Read the full oob until read_oob is fixed to handle single
                  * byte reads for 16 bit buswidth.
                  */
-                ret = mtd->read_oob(mtd, offs, &ops);
+                ret = mtd_read_oob(mtd, offs, &ops);
                 /* Ignore ECC errors when checking for BBM */
                 if (ret && !mtd_is_bitflip_or_eccerr(ret))
                         return ret;
@@ -756,7 +756,7 @@ static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
                         /* Make it block aligned */
                         to &= ~((loff_t)((1 << this->bbt_erase_shift) - 1));
                         len = 1 << this->bbt_erase_shift;
-                        res = mtd->read(mtd, to, len, &retlen, buf);
+                        res = mtd_read(mtd, to, len, &retlen, buf);
                         if (res < 0) {
                                 if (retlen != len) {
                                         pr_info("nand_bbt: error reading block "
@@ -769,7 +769,7 @@ static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
                         /* Read oob data */
                         ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
                         ops.oobbuf = &buf[len];
-                        res = mtd->read_oob(mtd, to + mtd->writesize, &ops);
+                        res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
                         if (res < 0 || ops.oobretlen != ops.ooblen)
                                 goto outerr;
 
diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c
index 00cf1b0d6053..af4fe8ca7b5e 100644
--- a/drivers/mtd/nand/nand_ids.c
+++ b/drivers/mtd/nand/nand_ids.c
@@ -73,11 +73,12 @@ struct nand_flash_dev nand_flash_ids[] = {
 #define LP_OPTIONS (NAND_SAMSUNG_LP_OPTIONS | NAND_NO_READRDY | NAND_NO_AUTOINCR)
 #define LP_OPTIONS16 (LP_OPTIONS | NAND_BUSWIDTH_16)
 
-        /*512 Megabit */
+        /* 512 Megabit */
         {"NAND 64MiB 1,8V 8-bit",       0xA2, 0,  64, 0, LP_OPTIONS},
         {"NAND 64MiB 1,8V 8-bit",       0xA0, 0,  64, 0, LP_OPTIONS},
         {"NAND 64MiB 3,3V 8-bit",       0xF2, 0,  64, 0, LP_OPTIONS},
         {"NAND 64MiB 3,3V 8-bit",       0xD0, 0,  64, 0, LP_OPTIONS},
+        {"NAND 64MiB 3,3V 8-bit",       0xF0, 0,  64, 0, LP_OPTIONS},
         {"NAND 64MiB 1,8V 16-bit",      0xB2, 0,  64, 0, LP_OPTIONS16},
         {"NAND 64MiB 1,8V 16-bit",      0xB0, 0,  64, 0, LP_OPTIONS16},
         {"NAND 64MiB 3,3V 16-bit",      0xC2, 0,  64, 0, LP_OPTIONS16},
@@ -176,6 +177,7 @@ struct nand_manufacturers nand_manuf_ids[] = {
         {NAND_MFR_HYNIX, "Hynix"},
         {NAND_MFR_MICRON, "Micron"},
         {NAND_MFR_AMD, "AMD"},
+        {NAND_MFR_MACRONIX, "Macronix"},
         {0x0, "Unknown"}
 };
 
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 34c03be77301..261f478f8cc3 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -737,7 +737,7 @@ static int parse_badblocks(struct nandsim *ns, struct mtd_info *mtd)
                         return -EINVAL;
                 }
                 offset = erase_block_no * ns->geom.secsz;
-                if (mtd->block_markbad(mtd, offset)) {
+                if (mtd_block_markbad(mtd, offset)) {
                         NS_ERR("invalid badblocks.\n");
                         return -EINVAL;
                 }
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index f8aacf48ecdd..ec688548c880 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -294,18 +294,7 @@ static struct platform_driver ndfc_driver = {
         .remove = __devexit_p(ndfc_remove),
 };
 
-static int __init ndfc_nand_init(void)
-{
-        return platform_driver_register(&ndfc_driver);
-}
-
-static void __exit ndfc_nand_exit(void)
-{
-        platform_driver_unregister(&ndfc_driver);
-}
-
-module_init(ndfc_nand_init);
-module_exit(ndfc_nand_exit);
+module_platform_driver(ndfc_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Thomas Gleixner <tglx@linutronix.de>");
diff --git a/drivers/mtd/nand/nomadik_nand.c b/drivers/mtd/nand/nomadik_nand.c
index b463ecfb4c1a..a86aa812ca13 100644
--- a/drivers/mtd/nand/nomadik_nand.c
+++ b/drivers/mtd/nand/nomadik_nand.c
@@ -201,7 +201,7 @@ static int nomadik_nand_suspend(struct device *dev)
         struct nomadik_nand_host *host = dev_get_drvdata(dev);
         int ret = 0;
         if (host)
-                ret = host->mtd.suspend(&host->mtd);
+                ret = mtd_suspend(&host->mtd);
         return ret;
 }
 
@@ -209,7 +209,7 @@ static int nomadik_nand_resume(struct device *dev)
 {
         struct nomadik_nand_host *host = dev_get_drvdata(dev);
         if (host)
-                host->mtd.resume(&host->mtd);
+                mtd_resume(&host->mtd);
         return 0;
 }
 
@@ -228,19 +228,7 @@ static struct platform_driver nomadik_nand_driver = {
         },
 };
 
-static int __init nand_nomadik_init(void)
-{
-        pr_info("Nomadik NAND driver\n");
-        return platform_driver_register(&nomadik_nand_driver);
-}
-
-static void __exit nand_nomadik_exit(void)
-{
-        platform_driver_unregister(&nomadik_nand_driver);
-}
-
-module_init(nand_nomadik_init);
-module_exit(nand_nomadik_exit);
+module_platform_driver(nomadik_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("ST Microelectronics (sachin.verma@st.com)");
diff --git a/drivers/mtd/nand/nuc900_nand.c b/drivers/mtd/nand/nuc900_nand.c
index fa8faedfad6e..8febe46e1105 100644
--- a/drivers/mtd/nand/nuc900_nand.c
+++ b/drivers/mtd/nand/nuc900_nand.c
@@ -364,18 +364,7 @@ static struct platform_driver nuc900_nand_driver = {
         },
 };
 
-static int __init nuc900_nand_init(void)
-{
-        return platform_driver_register(&nuc900_nand_driver);
-}
-
-static void __exit nuc900_nand_exit(void)
-{
-        platform_driver_unregister(&nuc900_nand_driver);
-}
-
-module_init(nuc900_nand_init);
-module_exit(nuc900_nand_exit);
+module_platform_driver(nuc900_nand_driver);
 
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("w90p910/NUC9xx nand driver!");
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index f745f00f3167..b3a883e2a22f 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -1145,20 +1145,7 @@ static struct platform_driver omap_nand_driver = {
         },
 };
 
-static int __init omap_nand_init(void)
-{
-        pr_info("%s driver initializing\n", DRIVER_NAME);
-
-        return platform_driver_register(&omap_nand_driver);
-}
-
-static void __exit omap_nand_exit(void)
-{
-        platform_driver_unregister(&omap_nand_driver);
-}
-
-module_init(omap_nand_init);
-module_exit(omap_nand_exit);
+module_platform_driver(omap_nand_driver);
 
 MODULE_ALIAS("platform:" DRIVER_NAME);
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/pasemi_nand.c b/drivers/mtd/nand/pasemi_nand.c
index a97264ececdb..974dbf8251c9 100644
--- a/drivers/mtd/nand/pasemi_nand.c
+++ b/drivers/mtd/nand/pasemi_nand.c
@@ -230,17 +230,7 @@ static struct platform_driver pasemi_nand_driver =
         .remove         = pasemi_nand_remove,
 };
 
-static int __init pasemi_nand_init(void)
-{
-        return platform_driver_register(&pasemi_nand_driver);
-}
-module_init(pasemi_nand_init);
-
-static void __exit pasemi_nand_exit(void)
-{
-        platform_driver_unregister(&pasemi_nand_driver);
-}
-module_exit(pasemi_nand_exit);
+module_platform_driver(pasemi_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Egor Martovetsky <egor@pasemi.com>");
diff --git a/drivers/mtd/nand/plat_nand.c b/drivers/mtd/nand/plat_nand.c
index ea8e1234e0e2..7f2da6953357 100644
--- a/drivers/mtd/nand/plat_nand.c
+++ b/drivers/mtd/nand/plat_nand.c
@@ -148,18 +148,7 @@ static struct platform_driver plat_nand_driver = {
         },
 };
 
-static int __init plat_nand_init(void)
-{
-        return platform_driver_register(&plat_nand_driver);
-}
-
-static void __exit plat_nand_exit(void)
-{
-        platform_driver_unregister(&plat_nand_driver);
-}
-
-module_init(plat_nand_init);
-module_exit(plat_nand_exit);
+module_platform_driver(plat_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Vitaly Wool");
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index 9eb7f879969e..8544d6bf50a0 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -1258,7 +1258,7 @@ static int pxa3xx_nand_suspend(struct platform_device *pdev, pm_message_t state)
 
         for (cs = 0; cs < pdata->num_cs; cs++) {
                 mtd = info->host[cs]->mtd;
-                mtd->suspend(mtd);
+                mtd_suspend(mtd);
         }
 
         return 0;
@@ -1291,7 +1291,7 @@ static int pxa3xx_nand_resume(struct platform_device *pdev)
         nand_writel(info, NDSR, NDSR_MASK);
         for (cs = 0; cs < pdata->num_cs; cs++) {
                 mtd = info->host[cs]->mtd;
-                mtd->resume(mtd);
+                mtd_resume(mtd);
         }
 
         return 0;
@@ -1311,17 +1311,7 @@ static struct platform_driver pxa3xx_nand_driver = {
         .resume         = pxa3xx_nand_resume,
 };
 
-static int __init pxa3xx_nand_init(void)
-{
-        return platform_driver_register(&pxa3xx_nand_driver);
-}
-module_init(pxa3xx_nand_init);
-
-static void __exit pxa3xx_nand_exit(void)
-{
-        platform_driver_unregister(&pxa3xx_nand_driver);
-}
-module_exit(pxa3xx_nand_exit);
+module_platform_driver(pxa3xx_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("PXA3xx NAND controller driver");
diff --git a/drivers/mtd/nand/sharpsl.c b/drivers/mtd/nand/sharpsl.c
index 619d2a504788..b175c0fd8b93 100644
--- a/drivers/mtd/nand/sharpsl.c
+++ b/drivers/mtd/nand/sharpsl.c
@@ -230,17 +230,7 @@ static struct platform_driver sharpsl_nand_driver = {
         .remove         = __devexit_p(sharpsl_nand_remove),
 };
 
-static int __init sharpsl_nand_init(void)
-{
-        return platform_driver_register(&sharpsl_nand_driver);
-}
-module_init(sharpsl_nand_init);
-
-static void __exit sharpsl_nand_exit(void)
-{
-        platform_driver_unregister(&sharpsl_nand_driver);
-}
-module_exit(sharpsl_nand_exit);
+module_platform_driver(sharpsl_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
diff --git a/drivers/mtd/nand/sm_common.c b/drivers/mtd/nand/sm_common.c
index 32ae5af7444f..774c3c266713 100644
--- a/drivers/mtd/nand/sm_common.c
+++ b/drivers/mtd/nand/sm_common.c
@@ -55,7 +55,7 @@ static int sm_block_markbad(struct mtd_info *mtd, loff_t ofs)
         ops.datbuf = NULL;
 
 
-        ret = mtd->write_oob(mtd, ofs, &ops);
+        ret = mtd_write_oob(mtd, ofs, &ops);
         if (ret < 0 || ops.oobretlen != SM_OOB_SIZE) {
                 printk(KERN_NOTICE
                         "sm_common: can't mark sector at %i as bad\n",
diff --git a/drivers/mtd/nand/socrates_nand.c b/drivers/mtd/nand/socrates_nand.c
index 0fb24f9c2327..e02b08bcf0c0 100644
--- a/drivers/mtd/nand/socrates_nand.c
+++ b/drivers/mtd/nand/socrates_nand.c
@@ -273,18 +273,7 @@ static struct platform_driver socrates_nand_driver = {
         .remove         = __devexit_p(socrates_nand_remove),
 };
 
-static int __init socrates_nand_init(void)
-{
-        return platform_driver_register(&socrates_nand_driver);
-}
-
-static void __exit socrates_nand_exit(void)
-{
-        platform_driver_unregister(&socrates_nand_driver);
-}
-
-module_init(socrates_nand_init);
-module_exit(socrates_nand_exit);
+module_platform_driver(socrates_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Ilya Yanok");
diff --git a/drivers/mtd/nand/tmio_nand.c b/drivers/mtd/nand/tmio_nand.c
index beebd95f7690..6caa0cd9d6a7 100644
--- a/drivers/mtd/nand/tmio_nand.c
+++ b/drivers/mtd/nand/tmio_nand.c
@@ -533,18 +533,7 @@ static struct platform_driver tmio_driver = {
         .resume         = tmio_resume,
 };
 
-static int __init tmio_init(void)
-{
-        return platform_driver_register(&tmio_driver);
-}
-
-static void __exit tmio_exit(void)
-{
-        platform_driver_unregister(&tmio_driver);
-}
-
-module_init(tmio_init);
-module_exit(tmio_exit);
+module_platform_driver(tmio_driver);
 
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Ian Molton, Dirk Opfer, Chris Humbert, Dmitry Baryshkov");
diff --git a/drivers/mtd/nand/txx9ndfmc.c b/drivers/mtd/nand/txx9ndfmc.c
index ace46fdaef58..c7c4f1d11c77 100644
--- a/drivers/mtd/nand/txx9ndfmc.c
+++ b/drivers/mtd/nand/txx9ndfmc.c
@@ -298,11 +298,7 @@ static int __init txx9ndfmc_probe(struct platform_device *dev)
         drvdata = devm_kzalloc(&dev->dev, sizeof(*drvdata), GFP_KERNEL);
         if (!drvdata)
                 return -ENOMEM;
-        if (!devm_request_mem_region(&dev->dev, res->start,
-                                     resource_size(res), dev_name(&dev->dev)))
-                return -EBUSY;
-        drvdata->base = devm_ioremap(&dev->dev, res->start,
-                                     resource_size(res));
+        drvdata->base = devm_request_and_ioremap(&dev->dev, res);
         if (!drvdata->base)
                 return -EBUSY;