Merge git://git.infradead.org/mtd-2.6

* git://git.infradead.org/mtd-2.6: (59 commits)
  mtd: mtdpart: disallow reading OOB past the end of the partition
  mtd: pxa3xx_nand: NULL dereference in pxa3xx_nand_probe
  UBI: use mtd->writebufsize to set minimal I/O unit size
  mtd: initialize writebufsize in the MTD object of a partition
  mtd: onenand: add mtd->writebufsize initialization
  mtd: nand: add mtd->writebufsize initialization
  mtd: cfi: add writebufsize initialization
  mtd: add writebufsize field to mtd_info struct
  mtd: OneNAND: OMAP2/3: prevent regulator sleeping while OneNAND is in use
  mtd: OneNAND: add enable / disable methods to onenand_chip
  mtd: m25p80: Fix JEDEC ID for AT26DF321
  mtd: txx9ndfmc: limit transfer bytes to 512 (ECC provides 6 bytes max)
  mtd: cfi_cmdset_0002: add support for Samsung K8D3x16UxC NOR chips
  mtd: cfi_cmdset_0002: add support for Samsung K8D6x16UxM NOR chips
  mtd: nand: ams-delta: drop omap_read/write, use ioremap
  mtd: m25p80: add debugging trace in sst_write
  mtd: nand: ams-delta: select for built-in by default
  mtd: OneNAND: lighten scary initial bad block messages
  mtd: OneNAND: OMAP2/3: add support for command line partitioning
  mtd: nand: rearrange ONFI revision checking, add ONFI 2.3
  ...

Fix up trivial conflict in drivers/mtd/Kconfig as per DavidW.

12 files changed, 183 insertions, 124 deletions

diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 8229802b4346..c89592239bc7 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -96,6 +96,7 @@ config MTD_NAND_SPIA
 config MTD_NAND_AMS_DELTA
         tristate "NAND Flash device on Amstrad E3"
         depends on MACH_AMS_DELTA
+        default y
         help
           Support for NAND flash on Amstrad E3 (Delta).
 
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index 2548e1065bf8..a067d090cb31 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -4,6 +4,8 @@
  *  Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
  *
  *  Derived from drivers/mtd/toto.c
+ *  Converted to platform driver by Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
+ *  Partially stolen from drivers/mtd/nand/plat_nand.c
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -62,9 +64,10 @@ static struct mtd_partition partition_info[] = {
 static void ams_delta_write_byte(struct mtd_info *mtd, u_char byte)
 {
         struct nand_chip *this = mtd->priv;
+        void __iomem *io_base = this->priv;
 
-        omap_writew(0, (OMAP1_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
-        omap_writew(byte, this->IO_ADDR_W);
+        writew(0, io_base + OMAP_MPUIO_IO_CNTL);
+        writew(byte, this->IO_ADDR_W);
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE, 0);
         ndelay(40);
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE,
@@ -75,11 +78,12 @@ static u_char ams_delta_read_byte(struct mtd_info *mtd)
 {
         u_char res;
         struct nand_chip *this = mtd->priv;
+        void __iomem *io_base = this->priv;
 
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, 0);
         ndelay(40);
-        omap_writew(~0, (OMAP1_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
-        res = omap_readw(this->IO_ADDR_R);
+        writew(~0, io_base + OMAP_MPUIO_IO_CNTL);
+        res = readw(this->IO_ADDR_R);
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE,
                                AMS_DELTA_LATCH2_NAND_NRE);
 
@@ -151,11 +155,16 @@ static int ams_delta_nand_ready(struct mtd_info *mtd)
 /*
  * Main initialization routine
  */
-static int __init ams_delta_init(void)
+static int __devinit ams_delta_init(struct platform_device *pdev)
 {
         struct nand_chip *this;
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        void __iomem *io_base;
         int err = 0;
 
+        if (!res)
+                return -ENXIO;
+
         /* Allocate memory for MTD device structure and private data */
         ams_delta_mtd = kmalloc(sizeof(struct mtd_info) +
                                 sizeof(struct nand_chip), GFP_KERNEL);
@@ -177,9 +186,25 @@ static int __init ams_delta_init(void)
         /* Link the private data with the MTD structure */
         ams_delta_mtd->priv = this;
 
+        if (!request_mem_region(res->start, resource_size(res),
+                        dev_name(&pdev->dev))) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                err = -EBUSY;
+                goto out_free;
+        }
+
+        io_base = ioremap(res->start, resource_size(res));
+        if (io_base == NULL) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                err = -EIO;
+                goto out_release_io;
+        }
+
+        this->priv = io_base;
+
         /* Set address of NAND IO lines */
-        this->IO_ADDR_R = (OMAP1_MPUIO_BASE + OMAP_MPUIO_INPUT_LATCH);
-        this->IO_ADDR_W = (OMAP1_MPUIO_BASE + OMAP_MPUIO_OUTPUT);
+        this->IO_ADDR_R = io_base + OMAP_MPUIO_INPUT_LATCH;
+        this->IO_ADDR_W = io_base + OMAP_MPUIO_OUTPUT;
         this->read_byte = ams_delta_read_byte;
         this->write_buf = ams_delta_write_buf;
         this->read_buf = ams_delta_read_buf;
@@ -195,6 +220,8 @@ static int __init ams_delta_init(void)
         this->chip_delay = 30;
         this->ecc.mode = NAND_ECC_SOFT;
 
+        platform_set_drvdata(pdev, io_base);
+
         /* Set chip enabled, but  */
         ams_delta_latch2_write(NAND_MASK, AMS_DELTA_LATCH2_NAND_NRE |
                                           AMS_DELTA_LATCH2_NAND_NWE |
@@ -214,25 +241,56 @@ static int __init ams_delta_init(void)
         goto out;
 
  out_mtd:
+        platform_set_drvdata(pdev, NULL);
+        iounmap(io_base);
+out_release_io:
+        release_mem_region(res->start, resource_size(res));
+out_free:
         kfree(ams_delta_mtd);
  out:
         return err;
 }
 
-module_init(ams_delta_init);
-
 /*
  * Clean up routine
  */
-static void __exit ams_delta_cleanup(void)
+static int __devexit ams_delta_cleanup(struct platform_device *pdev)
 {
+        void __iomem *io_base = platform_get_drvdata(pdev);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
         /* Release resources, unregister device */
         nand_release(ams_delta_mtd);
 
+        iounmap(io_base);
+        release_mem_region(res->start, resource_size(res));
+
         /* Free the MTD device structure */
         kfree(ams_delta_mtd);
+
+        return 0;
+}
+
+static struct platform_driver ams_delta_nand_driver = {
+        .probe          = ams_delta_init,
+        .remove         = __devexit_p(ams_delta_cleanup),
+        .driver         = {
+                .name   = "ams-delta-nand",
+                .owner  = THIS_MODULE,
+        },
+};
+
+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_cleanup);
+module_exit(ams_delta_nand_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Jonathan McDowell <noodles@earth.li>");
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index c141b07b25d1..7a13d42cbabd 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -388,6 +388,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                          "page_addr: 0x%x, column: 0x%x.\n",
                          page_addr, column);
 
+                elbc_fcm_ctrl->column = column;
+                elbc_fcm_ctrl->oob = 0;
                 elbc_fcm_ctrl->use_mdr = 1;
 
                 fcr = (NAND_CMD_STATUS   << FCR_CMD1_SHIFT) |
diff --git a/drivers/mtd/nand/fsmc_nand.c b/drivers/mtd/nand/fsmc_nand.c
index 02edfba25b0c..205b10b9f9b9 100644
--- a/drivers/mtd/nand/fsmc_nand.c
+++ b/drivers/mtd/nand/fsmc_nand.c
@@ -31,6 +31,7 @@
 #include <linux/io.h>
 #include <linux/slab.h>
 #include <linux/mtd/fsmc.h>
+#include <linux/amba/bus.h>
 #include <mtd/mtd-abi.h>
 
 static struct nand_ecclayout fsmc_ecc1_layout = {
@@ -119,21 +120,36 @@ static struct fsmc_eccplace fsmc_ecc4_sp_place = {
         }
 };
 
-/*
- * Default partition tables to be used if the partition information not
- * provided through platform data
- */
-#define PARTITION(n, off, sz)   {.name = n, .offset = off, .size = sz}
 
+#ifdef CONFIG_MTD_PARTITIONS
 /*
+ * Default partition tables to be used if the partition information not
+ * provided through platform data.
+ *
  * Default partition layout for small page(= 512 bytes) devices
  * Size for "Root file system" is updated in driver based on actual device size
  */
 static struct mtd_partition partition_info_16KB_blk[] = {
-        PARTITION("X-loader", 0, 4 * 0x4000),
-        PARTITION("U-Boot", 0x10000, 20 * 0x4000),
-        PARTITION("Kernel", 0x60000, 256 * 0x4000),
-        PARTITION("Root File System", 0x460000, 0),
+        {
+                .name = "X-loader",
+                .offset = 0,
+                .size = 4*0x4000,
+        },
+        {
+                .name = "U-Boot",
+                .offset = 0x10000,
+                .size = 20*0x4000,
+        },
+        {
+                .name = "Kernel",
+                .offset = 0x60000,
+                .size = 256*0x4000,
+        },
+        {
+                .name = "Root File System",
+                .offset = 0x460000,
+                .size = 0,
+        },
 };
 
 /*
@@ -141,19 +157,37 @@ static struct mtd_partition partition_info_16KB_blk[] = {
  * Size for "Root file system" is updated in driver based on actual device size
  */
 static struct mtd_partition partition_info_128KB_blk[] = {
-        PARTITION("X-loader", 0, 4 * 0x20000),
-        PARTITION("U-Boot", 0x80000, 12 * 0x20000),
-        PARTITION("Kernel", 0x200000, 48 * 0x20000),
-        PARTITION("Root File System", 0x800000, 0),
+        {
+                .name = "X-loader",
+                .offset = 0,
+                .size = 4*0x20000,
+        },
+        {
+                .name = "U-Boot",
+                .offset = 0x80000,
+                .size = 12*0x20000,
+        },
+        {
+                .name = "Kernel",
+                .offset = 0x200000,
+                .size = 48*0x20000,
+        },
+        {
+                .name = "Root File System",
+                .offset = 0x800000,
+                .size = 0,
+        },
 };
 
 #ifdef CONFIG_MTD_CMDLINE_PARTS
 const char *part_probes[] = { "cmdlinepart", NULL };
 #endif
+#endif
 
 /**
- * struct fsmc_nand_data - atructure for FSMC NAND device state
+ * struct fsmc_nand_data - structure for FSMC NAND device state
  *
+ * @pid:                Part ID on the AMBA PrimeCell format
  * @mtd:                MTD info for a NAND flash.
  * @nand:               Chip related info for a NAND flash.
  * @partitions:         Partition info for a NAND Flash.
@@ -169,6 +203,7 @@ const char *part_probes[] = { "cmdlinepart", NULL };
  * @regs_va:            FSMC regs base address.
  */
 struct fsmc_nand_data {
+        u32                     pid;
         struct mtd_info         mtd;
         struct nand_chip        nand;
         struct mtd_partition    *partitions;
@@ -508,7 +543,9 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
         struct nand_chip *nand;
         struct fsmc_regs *regs;
         struct resource *res;
-        int nr_parts, ret = 0;
+        int ret = 0;
+        u32 pid;
+        int i;
 
         if (!pdata) {
                 dev_err(&pdev->dev, "platform data is NULL\n");
@@ -598,6 +635,18 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
         if (ret)
                 goto err_probe1;
 
+        /*
+         * This device ID is actually a common AMBA ID as used on the
+         * AMBA PrimeCell bus. However it is not a PrimeCell.
+         */
+        for (pid = 0, i = 0; i < 4; i++)
+                pid |= (readl(host->regs_va + resource_size(res) - 0x20 + 4 * i) & 255) << (i * 8);
+        host->pid = pid;
+        dev_info(&pdev->dev, "FSMC device partno %03x, manufacturer %02x, "
+                 "revision %02x, config %02x\n",
+                 AMBA_PART_BITS(pid), AMBA_MANF_BITS(pid),
+                 AMBA_REV_BITS(pid), AMBA_CONFIG_BITS(pid));
+
         host->bank = pdata->bank;
         host->select_chip = pdata->select_bank;
         regs = host->regs_va;
@@ -625,7 +674,7 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
 
         fsmc_nand_setup(regs, host->bank, nand->options & NAND_BUSWIDTH_16);
 
-        if (get_fsmc_version(host->regs_va) == FSMC_VER8) {
+        if (AMBA_REV_BITS(host->pid) >= 8) {
                 nand->ecc.read_page = fsmc_read_page_hwecc;
                 nand->ecc.calculate = fsmc_read_hwecc_ecc4;
                 nand->ecc.correct = fsmc_correct_data;
@@ -645,7 +694,7 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
                 goto err_probe;
         }
 
-        if (get_fsmc_version(host->regs_va) == FSMC_VER8) {
+        if (AMBA_REV_BITS(host->pid) >= 8) {
                 if (host->mtd.writesize == 512) {
                         nand->ecc.layout = &fsmc_ecc4_sp_layout;
                         host->ecc_place = &fsmc_ecc4_sp_place;
@@ -676,11 +725,9 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
          * Check if partition info passed via command line
          */
         host->mtd.name = "nand";
-        nr_parts = parse_mtd_partitions(&host->mtd, part_probes,
+        host->nr_partitions = parse_mtd_partitions(&host->mtd, part_probes,
                         &host->partitions, 0);
-        if (nr_parts > 0) {
-                host->nr_partitions = nr_parts;
-        } else {
+        if (host->nr_partitions <= 0) {
 #endif
                 /*
                  * Check if partition info passed via command line
diff --git a/drivers/mtd/nand/jz4740_nand.c b/drivers/mtd/nand/jz4740_nand.c
index 67343fc31bd5..cea38a5d4ac5 100644
--- a/drivers/mtd/nand/jz4740_nand.c
+++ b/drivers/mtd/nand/jz4740_nand.c
@@ -251,58 +251,6 @@ static int jz_nand_correct_ecc_rs(struct mtd_info *mtd, uint8_t *dat,
         return 0;
 }
 
-
-/* Copy paste of nand_read_page_hwecc_oob_first except for different eccpos
- * handling. The ecc area is for 4k chips 72 bytes long and thus does not fit
- * into the eccpos array. */
-static int jz_nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
-        struct nand_chip *chip, uint8_t *buf, int page)
-{
-        int i, eccsize = chip->ecc.size;
-        int eccbytes = chip->ecc.bytes;
-        int eccsteps = chip->ecc.steps;
-        uint8_t *p = buf;
-        unsigned int ecc_offset = chip->page_shift;
-
-        /* Read the OOB area first */
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
-
-        for (i = ecc_offset; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
-                int stat;
-
-                chip->ecc.hwctl(mtd, NAND_ECC_READ);
-                chip->read_buf(mtd, p, eccsize);
-
-                stat = chip->ecc.correct(mtd, p, &chip->oob_poi[i], NULL);
-                if (stat < 0)
-                        mtd->ecc_stats.failed++;
-                else
-                        mtd->ecc_stats.corrected += stat;
-        }
-        return 0;
-}
-
-/* Copy-and-paste of nand_write_page_hwecc with different eccpos handling. */
-static void jz_nand_write_page_hwecc(struct mtd_info *mtd,
-        struct nand_chip *chip, const uint8_t *buf)
-{
-        int i, eccsize = chip->ecc.size;
-        int eccbytes = chip->ecc.bytes;
-        int eccsteps = chip->ecc.steps;
-        const uint8_t *p = buf;
-        unsigned int ecc_offset = chip->page_shift;
-
-        for (i = ecc_offset; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
-                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
-                chip->write_buf(mtd, p, eccsize);
-                chip->ecc.calculate(mtd, p, &chip->oob_poi[i]);
-        }
-
-        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-}
-
 #ifdef CONFIG_MTD_CMDLINE_PARTS
 static const char *part_probes[] = {"cmdline", NULL};
 #endif
@@ -393,9 +341,6 @@ static int __devinit jz_nand_probe(struct platform_device *pdev)
         chip->ecc.size          = 512;
         chip->ecc.bytes         = 9;
 
-        chip->ecc.read_page     = jz_nand_read_page_hwecc_oob_first;
-        chip->ecc.write_page    = jz_nand_write_page_hwecc;
-
         if (pdata)
                 chip->ecc.layout = pdata->ecc_layout;
 
@@ -489,7 +434,7 @@ static int __devexit jz_nand_remove(struct platform_device *pdev)
         return 0;
 }
 
-struct platform_driver jz_nand_driver = {
+static struct platform_driver jz_nand_driver = {
         .probe = jz_nand_probe,
         .remove = __devexit_p(jz_nand_remove),
         .driver = {
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index 214b03afdd48..ef932ba55a0b 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -1009,7 +1009,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         struct mxc_nand_platform_data *pdata = pdev->dev.platform_data;
         struct mxc_nand_host *host;
         struct resource *res;
-        int err = 0, nr_parts = 0;
+        int err = 0, __maybe_unused nr_parts = 0;
         struct nand_ecclayout *oob_smallpage, *oob_largepage;
 
         /* Allocate memory for MTD device structure and private data */
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 31bf376b82a0..a9c6ce745767 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -2865,20 +2865,24 @@ static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip,
 
         /* check version */
         val = le16_to_cpu(p->revision);
-        if (val == 1 || val > (1 << 4)) {
-                printk(KERN_INFO "%s: unsupported ONFI version: %d\n",
-                                                                __func__, val);
-                return 0;
-        }
-
-        if (val & (1 << 4))
+        if (val & (1 << 5))
+                chip->onfi_version = 23;
+        else if (val & (1 << 4))
                 chip->onfi_version = 22;
         else if (val & (1 << 3))
                 chip->onfi_version = 21;
         else if (val & (1 << 2))
                 chip->onfi_version = 20;
-        else
+        else if (val & (1 << 1))
                 chip->onfi_version = 10;
+        else
+                chip->onfi_version = 0;
+
+        if (!chip->onfi_version) {
+                printk(KERN_INFO "%s: unsupported ONFI version: %d\n",
+                                                                __func__, val);
+                return 0;
+        }
 
         sanitize_string(p->manufacturer, sizeof(p->manufacturer));
         sanitize_string(p->model, sizeof(p->model));
@@ -2887,7 +2891,7 @@ static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip,
         mtd->writesize = le32_to_cpu(p->byte_per_page);
         mtd->erasesize = le32_to_cpu(p->pages_per_block) * mtd->writesize;
         mtd->oobsize = le16_to_cpu(p->spare_bytes_per_page);
-        chip->chipsize = le32_to_cpu(p->blocks_per_lun) * mtd->erasesize;
+        chip->chipsize = (uint64_t)le32_to_cpu(p->blocks_per_lun) * mtd->erasesize;
         busw = 0;
         if (le16_to_cpu(p->features) & 1)
                 busw = NAND_BUSWIDTH_16;
@@ -3157,7 +3161,7 @@ ident_done:
         printk(KERN_INFO "NAND device: Manufacturer ID:"
                 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id, *dev_id,
                 nand_manuf_ids[maf_idx].name,
-        chip->onfi_version ? type->name : chip->onfi_params.model);
+                chip->onfi_version ? chip->onfi_params.model : type->name);
 
         return type;
 }
@@ -3435,6 +3439,7 @@ int nand_scan_tail(struct mtd_info *mtd)
         mtd->resume = nand_resume;
         mtd->block_isbad = nand_block_isbad;
         mtd->block_markbad = nand_block_markbad;
+        mtd->writebufsize = mtd->writesize;
 
         /* propagate ecc.layout to mtd_info */
         mtd->ecclayout = chip->ecc.layout;
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index 586b981f0e61..6ebd869993aa 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -1092,7 +1092,8 @@ static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
 
 /**
  * verify_bbt_descr - verify the bad block description
- * @bd:                 the table to verify
+ * @mtd:        MTD device structure
+ * @bd:         the table to verify
  *
  * This functions performs a few sanity checks on the bad block description
  * table.
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index a6a73aab1253..a5aa99f014ba 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -210,12 +210,12 @@ MODULE_PARM_DESC(bbt,		 "0 OOB, 1 BBT with marker in OOB, 2 BBT with marker in d
 #define STATE_CMD_READ0        0x00000001 /* read data from the beginning of page */
 #define STATE_CMD_READ1        0x00000002 /* read data from the second half of page */
 #define STATE_CMD_READSTART    0x00000003 /* read data second command (large page devices) */
-#define STATE_CMD_PAGEPROG     0x00000004 /* start page programm */
+#define STATE_CMD_PAGEPROG     0x00000004 /* start page program */
 #define STATE_CMD_READOOB      0x00000005 /* read OOB area */
 #define STATE_CMD_ERASE1       0x00000006 /* sector erase first command */
 #define STATE_CMD_STATUS       0x00000007 /* read status */
 #define STATE_CMD_STATUS_M     0x00000008 /* read multi-plane status (isn't implemented) */
-#define STATE_CMD_SEQIN        0x00000009 /* sequential data imput */
+#define STATE_CMD_SEQIN        0x00000009 /* sequential data input */
 #define STATE_CMD_READID       0x0000000A /* read ID */
 #define STATE_CMD_ERASE2       0x0000000B /* sector erase second command */
 #define STATE_CMD_RESET        0x0000000C /* reset */
@@ -230,7 +230,7 @@ MODULE_PARM_DESC(bbt,		 "0 OOB, 1 BBT with marker in OOB, 2 BBT with marker in d
 #define STATE_ADDR_ZERO        0x00000040 /* one byte zero address was accepted */
 #define STATE_ADDR_MASK        0x00000070 /* address states mask */
 
-/* Durind data input/output the simulator is in these states */
+/* During data input/output the simulator is in these states */
 #define STATE_DATAIN           0x00000100 /* waiting for data input */
 #define STATE_DATAIN_MASK      0x00000100 /* data input states mask */
 
@@ -248,7 +248,7 @@ MODULE_PARM_DESC(bbt,		 "0 OOB, 1 BBT with marker in OOB, 2 BBT with marker in d
 
 /* Simulator's actions bit masks */
 #define ACTION_CPY       0x00100000 /* copy page/OOB to the internal buffer */
-#define ACTION_PRGPAGE   0x00200000 /* programm the internal buffer to flash */
+#define ACTION_PRGPAGE   0x00200000 /* program the internal buffer to flash */
 #define ACTION_SECERASE  0x00300000 /* erase sector */
 #define ACTION_ZEROOFF   0x00400000 /* don't add any offset to address */
 #define ACTION_HALFOFF   0x00500000 /* add to address half of page */
@@ -263,18 +263,18 @@ MODULE_PARM_DESC(bbt,		 "0 OOB, 1 BBT with marker in OOB, 2 BBT with marker in d
 #define OPT_PAGE512      0x00000002 /* 512-byte  page chips */
 #define OPT_PAGE2048     0x00000008 /* 2048-byte page chips */
 #define OPT_SMARTMEDIA   0x00000010 /* SmartMedia technology chips */
-#define OPT_AUTOINCR     0x00000020 /* page number auto inctimentation is possible */
+#define OPT_AUTOINCR     0x00000020 /* page number auto incrementation is possible */
 #define OPT_PAGE512_8BIT 0x00000040 /* 512-byte page chips with 8-bit bus width */
 #define OPT_PAGE4096     0x00000080 /* 4096-byte page chips */
 #define OPT_LARGEPAGE    (OPT_PAGE2048 | OPT_PAGE4096) /* 2048 & 4096-byte page chips */
 #define OPT_SMALLPAGE    (OPT_PAGE256  | OPT_PAGE512)  /* 256 and 512-byte page chips */
 
-/* Remove action bits ftom state */
+/* Remove action bits from state */
 #define NS_STATE(x) ((x) & ~ACTION_MASK)
 
 /*
  * Maximum previous states which need to be saved. Currently saving is
- * only needed for page programm operation with preceeded read command
+ * only needed for page program operation with preceded read command
  * (which is only valid for 512-byte pages).
  */
 #define NS_MAX_PREVSTATES 1
@@ -380,16 +380,16 @@ static struct nandsim_operations {
         /* Read OOB */
         {OPT_SMALLPAGE, {STATE_CMD_READOOB | ACTION_OOBOFF, STATE_ADDR_PAGE | ACTION_CPY,
                         STATE_DATAOUT, STATE_READY}},
-        /* Programm page starting from the beginning */
+        /* Program page starting from the beginning */
         {OPT_ANY, {STATE_CMD_SEQIN, STATE_ADDR_PAGE, STATE_DATAIN,
                         STATE_CMD_PAGEPROG | ACTION_PRGPAGE, STATE_READY}},
-        /* Programm page starting from the beginning */
+        /* Program page starting from the beginning */
         {OPT_SMALLPAGE, {STATE_CMD_READ0, STATE_CMD_SEQIN | ACTION_ZEROOFF, STATE_ADDR_PAGE,
                               STATE_DATAIN, STATE_CMD_PAGEPROG | ACTION_PRGPAGE, STATE_READY}},
-        /* Programm page starting from the second half */
+        /* Program page starting from the second half */
         {OPT_PAGE512, {STATE_CMD_READ1, STATE_CMD_SEQIN | ACTION_HALFOFF, STATE_ADDR_PAGE,
                               STATE_DATAIN, STATE_CMD_PAGEPROG | ACTION_PRGPAGE, STATE_READY}},
-        /* Programm OOB */
+        /* Program OOB */
         {OPT_SMALLPAGE, {STATE_CMD_READOOB, STATE_CMD_SEQIN | ACTION_OOBOFF, STATE_ADDR_PAGE,
                               STATE_DATAIN, STATE_CMD_PAGEPROG | ACTION_PRGPAGE, STATE_READY}},
         /* Erase sector */
@@ -470,7 +470,7 @@ static int alloc_device(struct nandsim *ns)
                         err = -EINVAL;
                         goto err_close;
                 }
-                ns->pages_written = vmalloc(ns->geom.pgnum);
+                ns->pages_written = vzalloc(ns->geom.pgnum);
                 if (!ns->pages_written) {
                         NS_ERR("alloc_device: unable to allocate pages written array\n");
                         err = -ENOMEM;
@@ -483,7 +483,6 @@ static int alloc_device(struct nandsim *ns)
                         goto err_free;
                 }
                 ns->cfile = cfile;
-                memset(ns->pages_written, 0, ns->geom.pgnum);
                 return 0;
         }
 
@@ -1171,9 +1170,9 @@ static inline void switch_to_ready_state(struct nandsim *ns, u_char status)
  * of supported operations.
  *
  * Operation can be unknown because of the following.
- *   1. New command was accepted and this is the firs call to find the
+ *   1. New command was accepted and this is the first call to find the
  *      correspondent states chain. In this case ns->npstates = 0;
- *   2. There is several operations which begin with the same command(s)
+ *   2. There are several operations which begin with the same command(s)
  *      (for example program from the second half and read from the
  *      second half operations both begin with the READ1 command). In this
  *      case the ns->pstates[] array contains previous states.
@@ -1186,7 +1185,7 @@ static inline void switch_to_ready_state(struct nandsim *ns, u_char status)
  * ns->ops, ns->state, ns->nxstate are initialized, ns->npstate is
  * zeroed).
  *
- * If there are several maches, the current state is pushed to the
+ * If there are several matches, the current state is pushed to the
  * ns->pstates.
  *
  * The operation can be unknown only while commands are input to the chip.
@@ -1195,10 +1194,10 @@ static inline void switch_to_ready_state(struct nandsim *ns, u_char status)
  * operation is searched using the following pattern:
  *     ns->pstates[0], ... ns->pstates[ns->npstates], <address input>
  *
- * It is supposed that this pattern must either match one operation on
+ * It is supposed that this pattern must either match one operation or
  * none. There can't be ambiguity in that case.
  *
- * If no matches found, the functions does the following:
+ * If no matches found, the function does the following:
  *   1. if there are saved states present, try to ignore them and search
  *      again only using the last command. If nothing was found, switch
  *      to the STATE_READY state.
@@ -1668,7 +1667,7 @@ static int do_state_action(struct nandsim *ns, uint32_t action)
 
         case ACTION_PRGPAGE:
                 /*
-                 * Programm page - move internal buffer data to the page.
+                 * Program page - move internal buffer data to the page.
                  */
 
                 if (ns->lines.wp) {
@@ -1933,7 +1932,7 @@ static u_char ns_nand_read_byte(struct mtd_info *mtd)
                 NS_DBG("read_byte: all bytes were read\n");
 
                 /*
-                 * The OPT_AUTOINCR allows to read next conseqitive pages without
+                 * The OPT_AUTOINCR allows to read next consecutive pages without
                  * new read operation cycle.
                  */
                 if ((ns->options & OPT_AUTOINCR) && NS_STATE(ns->state) == STATE_DATAOUT) {
diff --git a/drivers/mtd/nand/pasemi_nand.c b/drivers/mtd/nand/pasemi_nand.c
index 6ddb2461d740..bb277a54986f 100644
--- a/drivers/mtd/nand/pasemi_nand.c
+++ b/drivers/mtd/nand/pasemi_nand.c
@@ -107,7 +107,7 @@ static int __devinit pasemi_nand_probe(struct platform_device *ofdev,
         if (pasemi_nand_mtd)
                 return -ENODEV;
 
-        pr_debug("pasemi_nand at %llx-%llx\n", res.start, res.end);
+        pr_debug("pasemi_nand at %pR\n", &res);
 
         /* Allocate memory for MTD device structure and private data */
         pasemi_nand_mtd = kzalloc(sizeof(struct mtd_info) +
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index 17f8518cc5eb..ea2c288df3f6 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -885,6 +885,7 @@ static int pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
         /* set info fields needed to __readid */
         info->read_id_bytes = (info->page_size == 2048) ? 4 : 2;
         info->reg_ndcr = ndcr;
+        info->cmdset = &default_cmdset;
 
         if (__readid(info, &id))
                 return -ENODEV;
@@ -915,7 +916,6 @@ static int pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
 
         info->ndtr0cs0 = nand_readl(info, NDTR0CS0);
         info->ndtr1cs0 = nand_readl(info, NDTR1CS0);
-        info->cmdset = &default_cmdset;
 
         return 0;
 }
diff --git a/drivers/mtd/nand/txx9ndfmc.c b/drivers/mtd/nand/txx9ndfmc.c
index 054a41c0ef4a..ca270a4881a4 100644
--- a/drivers/mtd/nand/txx9ndfmc.c
+++ b/drivers/mtd/nand/txx9ndfmc.c
@@ -277,8 +277,9 @@ static int txx9ndfmc_nand_scan(struct mtd_info *mtd)
         ret = nand_scan_ident(mtd, 1, NULL);
         if (!ret) {
                 if (mtd->writesize >= 512) {
-                        chip->ecc.size = mtd->writesize;
-                        chip->ecc.bytes = 3 * (mtd->writesize / 256);
+                        /* Hardware ECC 6 byte ECC per 512 Byte data */
+                        chip->ecc.size = 512;
+                        chip->ecc.bytes = 6;
                 }
                 ret = nand_scan_tail(mtd);
         }