Merge tag 'nand/for-4.16' of git://git.infradead.org/linux-mtd into mtd/next

Pull NAND changes from Boris Brezillon: " Core changes: * Fix NAND_CMD_NONE handling in nand_command[_lp]() hooks * Introduce the ->exec_op() infrastructure * Rework NAND buffers handling * Fix ECC requirements for K9F4G08U0D * Fix nand_do_read_oob() to return the number of bitflips * Mark K9F1G08U0E as not supporting subpage writes Driver changes: * MTK: Rework the driver to support new IP versions * OMAP OneNAND: Full rework to use new APIs (libgpio, dmaengine) and fix DT support * Marvell: Add a new driver to replace the pxa3xx one "
author: Boris Brezillon <boris.brezillon@free-electrons.com> 2018-01-29 03:58:36 -0500
committer: Boris Brezillon <boris.brezillon@free-electrons.com> 2018-01-29 03:58:36 -0500
commit: 571cb17b23eccc22f18c4fc0a0fc34cf0abca7ef (patch)
tree: c371417fc983700fc74fe35a017973cb8580eec2
parent: c8f22b02a8bbc74525d17dd37d39bdf599e68a79 (diff)
parent: f4c6cd1a7f2275d5bc0e494b21fff26f8dde80f0 (diff)
64 files changed, 6462 insertions, 1913 deletions
diff --git a/Documentation/devicetree/bindings/mtd/gpmc-onenand.txt b/Documentation/devicetree/bindings/mtd/gpmc-onenand.txt
index b6e8bfd024f4..e9f01a963a0a 100644
--- a/Documentation/devicetree/bindings/mtd/gpmc-onenand.txt
+++ b/Documentation/devicetree/bindings/mtd/gpmc-onenand.txt
@@ -9,13 +9,14 @@ Documentation/devicetree/bindings/memory-controllers/omap-gpmc.txt
 Required properties:
+ - compatible:          "ti,omap2-onenand"
 - reg:                 The CS line the peripheral is connected to
- - gpmc,device-width    Width of the ONENAND device connected to the GPMC
+ - gpmc,device-width:   Width of the ONENAND device connected to the GPMC
                        in bytes. Must be 1 or 2.
 Optional properties:
- - dma-channel:         DMA Channel index
+ - int-gpios:           GPIO specifier for the INT pin.
 For inline partition table parsing (optional):
@@ -35,6 +36,7 @@ Example for an OMAP3430 board:
                #size-cells = <1>;
                onenand@0 {
+                        compatible = "ti,omap2-onenand";
                        reg = <0 0 0>; /* CS0, offset 0 */
                        gpmc,device-width = <2>;
diff --git a/Documentation/devicetree/bindings/mtd/marvell-nand.txt b/Documentation/devicetree/bindings/mtd/marvell-nand.txt
new file mode 100644
index 000000000000..c08fb477b3c6
--- /dev/null
+++ b/Documentation/devicetree/bindings/mtd/marvell-nand.txt
@@ -0,0 +1,123 @@
+Marvell NAND Flash Controller (NFC)
+Required properties:
+- compatible: can be one of the following:
+    * "marvell,armada-8k-nand-controller"
+    * "marvell,armada370-nand-controller"
+    * "marvell,pxa3xx-nand-controller"
+    * "marvell,armada-8k-nand" (deprecated)
+    * "marvell,armada370-nand" (deprecated)
+    * "marvell,pxa3xx-nand" (deprecated)
+  Compatibles marked deprecated support only the old bindings described
+  at the bottom.
+- reg: NAND flash controller memory area.
+- #address-cells: shall be set to 1. Encode the NAND CS.
+- #size-cells: shall be set to 0.
+- interrupts: shall define the NAND controller interrupt.
+- clocks: shall reference the NAND controller clock.
+- marvell,system-controller: Set to retrieve the syscon node that handles
+  NAND controller related registers (only required with the
+  "marvell,armada-8k-nand[-controller]" compatibles).
+Optional properties:
+- label: see partition.txt. New platforms shall omit this property.
+- dmas: shall reference DMA channel associated to the NAND controller.
+  This property is only used with "marvell,pxa3xx-nand[-controller]"
+  compatible strings.
+- dma-names: shall be "rxtx".
+  This property is only used with "marvell,pxa3xx-nand[-controller]"
+  compatible strings.
+Optional children nodes:
+Children nodes represent the available NAND chips.
+Required properties:
+- reg: shall contain the native Chip Select ids (0-3).
+- nand-rb: see nand.txt (0-1).
+Optional properties:
+- marvell,nand-keep-config: orders the driver not to take the timings
+  from the core and leaving them completely untouched. Bootloader
+  timings will then be used.
+- label: MTD name.
+- nand-on-flash-bbt: see nand.txt.
+- nand-ecc-mode: see nand.txt. Will use hardware ECC if not specified.
+- nand-ecc-algo: see nand.txt. This property is essentially useful when
+  not using hardware ECC. Howerver, it may be added when using hardware
+  ECC for clarification but will be ignored by the driver because ECC
+  mode is chosen depending on the page size and the strength required by
+  the NAND chip. This value may be overwritten with nand-ecc-strength
+  property.
+- nand-ecc-strength: see nand.txt.
+- nand-ecc-step-size: see nand.txt. Marvell's NAND flash controller does
+  use fixed strength (1-bit for Hamming, 16-bit for BCH), so the actual
+  step size will shrink or grow in order to fit the required strength.
+  Step sizes are not completely random for all and follow certain
+  patterns described in AN-379, "Marvell SoC NFC ECC".
+See Documentation/devicetree/bindings/mtd/nand.txt for more details on
+generic bindings.
+Example:
+nand_controller: nand-controller@d0000 {
+        compatible = "marvell,armada370-nand-controller";
+        reg = <0xd0000 0x54>;
+        #address-cells = <1>;
+        #size-cells = <0>;
+        interrupts = <GIC_SPI 84 IRQ_TYPE_LEVEL_HIGH>;
+        clocks = <&coredivclk 0>;
+        nand@0 {
+                reg = <0>;
+                label = "main-storage";
+                nand-rb = <0>;
+                nand-ecc-mode = "hw";
+                marvell,nand-keep-config;
+                nand-on-flash-bbt;
+                nand-ecc-strength = <4>;
+                nand-ecc-step-size = <512>;
+                partitions {
+                        compatible = "fixed-partitions";
+                        #address-cells = <1>;
+                        #size-cells = <1>;
+                        partition@0 {
+                                label = "Rootfs";
+                                reg = <0x00000000 0x40000000>;
+                        };
+                };
+        };
+};
+Note on legacy bindings: One can find, in not-updated device trees,
+bindings slightly different than described above with other properties
+described below as well as the partitions node at the root of a so
+called "nand" node (without clear controller/chip separation).
+Legacy properties:
+- marvell,nand-enable-arbiter: To enable the arbiter, all boards blindly
+  used it, this bit was set by the bootloader for many boards and even if
+  it is marked reserved in several datasheets, it might be needed to set
+  it (otherwise it is harmless) so whether or not this property is set,
+  the bit is selected by the driver.
+- num-cs: Number of chip-select lines to use, all boards blindly set 1
+  to this and for a reason, other values would have failed. The value of
+  this property is ignored.
+Example:
+        nand0: nand@43100000 {
+                compatible = "marvell,pxa3xx-nand";
+                reg = <0x43100000 90>;
+                interrupts = <45>;
+                dmas = <&pdma 97 0>;
+                dma-names = "rxtx";
+                #address-cells = <1>;
+                marvell,nand-keep-config;
+                marvell,nand-enable-arbiter;
+                num-cs = <1>;
+                /* Partitions (optional) */
+       };
diff --git a/Documentation/devicetree/bindings/mtd/mtk-nand.txt b/Documentation/devicetree/bindings/mtd/mtk-nand.txt
index dbf9e054c11c..0025bc4c94a0 100644
--- a/Documentation/devicetree/bindings/mtd/mtk-nand.txt
+++ b/Documentation/devicetree/bindings/mtd/mtk-nand.txt
@@ -12,8 +12,10 @@ tree nodes.
 The first part of NFC is NAND Controller Interface (NFI) HW.
 Required NFI properties:
- compatible:                   Should be one of "mediatek,mt2701-nfc",
+- compatible:                   Should be one of
-                                "mediatek,mt2712-nfc".
+                                "mediatek,mt2701-nfc",
+                                "mediatek,mt2712-nfc",
+                                "mediatek,mt7622-nfc".
 - reg:                          Base physical address and size of NFI.
 - interrupts:                   Interrupts of NFI.
 - clocks:                       NFI required clocks.
@@ -142,7 +144,10 @@ Example:
 ==============
 Required BCH properties:
- compatible:   Should be one of "mediatek,mt2701-ecc", "mediatek,mt2712-ecc".
+- compatible:   Should be one of
+                "mediatek,mt2701-ecc",
+                "mediatek,mt2712-ecc",
+                "mediatek,mt7622-ecc".
 - reg:          Base physical address and size of ECC.
 - interrupts:   Interrupts of ECC.
 - clocks:       ECC required clocks.
diff --git a/Documentation/devicetree/bindings/mtd/nand.txt b/Documentation/devicetree/bindings/mtd/nand.txt
index 133f3813719c..8bb11d809429 100644
--- a/Documentation/devicetree/bindings/mtd/nand.txt
+++ b/Documentation/devicetree/bindings/mtd/nand.txt
@@ -43,6 +43,7 @@ Optional NAND chip properties:
                     This is particularly useful when only the in-band area is
                     used by the upper layers, and you want to make your NAND
                     as reliable as possible.
+- nand-rb: shall contain the native Ready/Busy ids.
 The ECC strength and ECC step size properties define the correction capability
 of a controller. Together, they say a controller can correct "{strength} bit
diff --git a/MAINTAINERS b/MAINTAINERS
index 10732ecfc937..48ae3a43ed0f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2382,13 +2382,6 @@ F:	Documentation/devicetree/bindings/input/atmel,maxtouch.txt
 F:      drivers/input/touchscreen/atmel_mxt_ts.c
 F:      include/linux/platform_data/atmel_mxt_ts.h
-ATMEL NAND DRIVER
-M:      Wenyou Yang <wenyou.yang@atmel.com>
-M:      Josh Wu <rainyfeeling@outlook.com>
-L:      linux-mtd@lists.infradead.org
-S:      Supported
-F:      drivers/mtd/nand/atmel/*
 ATMEL SAMA5D2 ADC DRIVER
 M:      Ludovic Desroches <ludovic.desroches@microchip.com>
 L:      linux-iio@vger.kernel.org
@@ -8409,6 +8402,13 @@ L:	linux-wireless@vger.kernel.org
 S:      Odd Fixes
 F:      drivers/net/wireless/marvell/mwl8k.c
+MARVELL NAND CONTROLLER DRIVER
+M:      Miquel Raynal <miquel.raynal@free-electrons.com>
+L:      linux-mtd@lists.infradead.org
+S:      Maintained
+F:      drivers/mtd/nand/marvell_nand.c
+F:      Documentation/devicetree/bindings/mtd/marvell-nand.txt
 MARVELL SOC MMC/SD/SDIO CONTROLLER DRIVER
 M:      Nicolas Pitre <nico@fluxnic.net>
 S:      Odd Fixes
@@ -9045,6 +9045,14 @@ F:	drivers/media/platform/atmel/atmel-isc.c
 F:      drivers/media/platform/atmel/atmel-isc-regs.h
 F:      devicetree/bindings/media/atmel-isc.txt
+MICROCHIP / ATMEL NAND DRIVER
+M:      Wenyou Yang <wenyou.yang@microchip.com>
+M:      Josh Wu <rainyfeeling@outlook.com>
+L:      linux-mtd@lists.infradead.org
+S:      Supported
+F:      drivers/mtd/nand/atmel/*
+F:      Documentation/devicetree/bindings/mtd/atmel-nand.txt
 MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER
 M:      Woojung Huh <Woojung.Huh@microchip.com>
 M:      Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
diff --git a/arch/arm/boot/dts/omap2420-n8x0-common.dtsi b/arch/arm/boot/dts/omap2420-n8x0-common.dtsi
index 1df3ace3af92..63b0b4921e4e 100644
--- a/arch/arm/boot/dts/omap2420-n8x0-common.dtsi
+++ b/arch/arm/boot/dts/omap2420-n8x0-common.dtsi
@@ -52,6 +52,7 @@
        onenand@0,0 {
                #address-cells = <1>;
                #size-cells = <1>;
+                compatible = "ti,omap2-onenand";
                reg = <0 0 0x20000>;    /* CS0, offset 0, IO size 128K */
                gpmc,sync-read;
diff --git a/arch/arm/boot/dts/omap3-igep.dtsi b/arch/arm/boot/dts/omap3-igep.dtsi
index 4ad7d5565906..f33cc80c9dbc 100644
--- a/arch/arm/boot/dts/omap3-igep.dtsi
+++ b/arch/arm/boot/dts/omap3-igep.dtsi
@@ -147,32 +147,32 @@
                gpmc,sync-read;
                gpmc,sync-write;
                gpmc,burst-length = <16>;
-                gpmc,burst-read;
                gpmc,burst-wrap;
+                gpmc,burst-read;
                gpmc,burst-write;
                gpmc,device-width = <2>; /* GPMC_DEVWIDTH_16BIT */
                gpmc,mux-add-data = <2>; /* GPMC_MUX_AD */
                gpmc,cs-on-ns = <0>;
-                gpmc,cs-rd-off-ns = <87>;
+                gpmc,cs-rd-off-ns = <96>;
-                gpmc,cs-wr-off-ns = <87>;
+                gpmc,cs-wr-off-ns = <96>;
                gpmc,adv-on-ns = <0>;
-                gpmc,adv-rd-off-ns = <10>;
+                gpmc,adv-rd-off-ns = <12>;
-                gpmc,adv-wr-off-ns = <10>;
+                gpmc,adv-wr-off-ns = <12>;
-                gpmc,oe-on-ns = <15>;
+                gpmc,oe-on-ns = <18>;
-                gpmc,oe-off-ns = <87>;
+                gpmc,oe-off-ns = <96>;
                gpmc,we-on-ns = <0>;
-                gpmc,we-off-ns = <87>;
+                gpmc,we-off-ns = <96>;
-                gpmc,rd-cycle-ns = <112>;
+                gpmc,rd-cycle-ns = <114>;
-                gpmc,wr-cycle-ns = <112>;
+                gpmc,wr-cycle-ns = <114>;
-                gpmc,access-ns = <81>;
+                gpmc,access-ns = <90>;
-                gpmc,page-burst-access-ns = <15>;
+                gpmc,page-burst-access-ns = <12>;
                gpmc,bus-turnaround-ns = <0>;
                gpmc,cycle2cycle-delay-ns = <0>;
                gpmc,wait-monitoring-ns = <0>;
-                gpmc,clk-activation-ns = <5>;
+                gpmc,clk-activation-ns = <6>;
                gpmc,wr-data-mux-bus-ns = <30>;
-                gpmc,wr-access-ns = <81>;
+                gpmc,wr-access-ns = <90>;
-                gpmc,sync-clk-ps = <15000>;
+                gpmc,sync-clk-ps = <12000>;
                #address-cells = <1>;
                #size-cells = <1>;
diff --git a/arch/arm/boot/dts/omap3-n900.dts b/arch/arm/boot/dts/omap3-n900.dts
index 669c51c00c00..e7c7b8e50703 100644
--- a/arch/arm/boot/dts/omap3-n900.dts
+++ b/arch/arm/boot/dts/omap3-n900.dts
@@ -838,6 +838,7 @@
        onenand@0,0 {
                #address-cells = <1>;
                #size-cells = <1>;
+                compatible = "ti,omap2-onenand";
                reg = <0 0 0x20000>;    /* CS0, offset 0, IO size 128K */
                gpmc,sync-read;
diff --git a/arch/arm/boot/dts/omap3-n950-n9.dtsi b/arch/arm/boot/dts/omap3-n950-n9.dtsi
index 12fbb3da5fce..0d9b85317529 100644
--- a/arch/arm/boot/dts/omap3-n950-n9.dtsi
+++ b/arch/arm/boot/dts/omap3-n950-n9.dtsi
@@ -367,6 +367,7 @@
        onenand@0,0 {
                #address-cells = <1>;
                #size-cells = <1>;
+                compatible = "ti,omap2-onenand";
                reg = <0 0 0x20000>;    /* CS0, offset 0, IO size 128K */
                gpmc,sync-read;
diff --git a/arch/arm/boot/dts/omap3430-sdp.dts b/arch/arm/boot/dts/omap3430-sdp.dts
index 908951eb5943..d652708f6bef 100644
--- a/arch/arm/boot/dts/omap3430-sdp.dts
+++ b/arch/arm/boot/dts/omap3430-sdp.dts
@@ -154,6 +154,7 @@
                linux,mtd-name= "samsung,kfm2g16q2m-deb8";
                #address-cells = <1>;
                #size-cells = <1>;
+                compatible = "ti,omap2-onenand";
                reg = <2 0 0x20000>;    /* CS2, offset 0, IO size 4 */
                gpmc,device-width = <2>;
diff --git a/arch/arm/configs/mvebu_v7_defconfig b/arch/arm/configs/mvebu_v7_defconfig
index 69553704f2dc..4b6e4fd47e5d 100644
--- a/arch/arm/configs/mvebu_v7_defconfig
+++ b/arch/arm/configs/mvebu_v7_defconfig
@@ -57,7 +57,7 @@ CONFIG_MTD_CFI_STAA=y
 CONFIG_MTD_PHYSMAP_OF=y
 CONFIG_MTD_M25P80=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_PXA3xx=y
+CONFIG_MTD_NAND_MARVELL=y
 CONFIG_MTD_SPI_NOR=y
 CONFIG_SRAM=y
 CONFIG_MTD_UBI=y
diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile
index 2f722a805948..c15bbcad5f67 100644
--- a/arch/arm/mach-omap2/Makefile
+++ b/arch/arm/mach-omap2/Makefile
@@ -232,6 +232,3 @@ obj-y					+= $(omap-hsmmc-m) $(omap-hsmmc-y)
 obj-y                                   += omap_phy_internal.o
 obj-$(CONFIG_MACH_OMAP2_TUSB6010)       += usb-tusb6010.o
-onenand-$(CONFIG_MTD_ONENAND_OMAP2)     := gpmc-onenand.o
-obj-y                                   += $(onenand-m) $(onenand-y)
diff --git a/arch/arm/mach-omap2/gpmc-onenand.c b/arch/arm/mach-omap2/gpmc-onenand.c
deleted file mode 100644
index 2944af820558..000000000000
--- a/arch/arm/mach-omap2/gpmc-onenand.c
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
- * linux/arch/arm/mach-omap2/gpmc-onenand.c
- *
- * Copyright (C) 2006 - 2009 Nokia Corporation
- * Contacts:    Juha Yrjola
- *              Tony Lindgren
- *
- * 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
- * published by the Free Software Foundation.
- */
-#include <linux/string.h>
-#include <linux/kernel.h>
-#include <linux/platform_device.h>
-#include <linux/mtd/onenand_regs.h>
-#include <linux/io.h>
-#include <linux/omap-gpmc.h>
-#include <linux/platform_data/mtd-onenand-omap2.h>
-#include <linux/err.h>
-#include <asm/mach/flash.h>
-#include "soc.h"
-#define ONENAND_IO_SIZE SZ_128K
-#define ONENAND_FLAG_SYNCREAD   (1 << 0)
-#define ONENAND_FLAG_SYNCWRITE  (1 << 1)
-#define ONENAND_FLAG_HF         (1 << 2)
-#define ONENAND_FLAG_VHF        (1 << 3)
-static unsigned onenand_flags;
-static unsigned latency;
-static struct omap_onenand_platform_data *gpmc_onenand_data;
-static struct resource gpmc_onenand_resource = {
-        .flags          = IORESOURCE_MEM,
-};
-static struct platform_device gpmc_onenand_device = {
-        .name           = "omap2-onenand",
-        .id             = -1,
-        .num_resources  = 1,
-        .resource       = &gpmc_onenand_resource,
-};
-static struct gpmc_settings onenand_async = {
-        .device_width   = GPMC_DEVWIDTH_16BIT,
-        .mux_add_data   = GPMC_MUX_AD,
-};
-static struct gpmc_settings onenand_sync = {
-        .burst_read     = true,
-        .burst_wrap     = true,
-        .burst_len      = GPMC_BURST_16,
-        .device_width   = GPMC_DEVWIDTH_16BIT,
-        .mux_add_data   = GPMC_MUX_AD,
-        .wait_pin       = 0,
-};
-static void omap2_onenand_calc_async_timings(struct gpmc_timings *t)
-{
-        struct gpmc_device_timings dev_t;
-        const int t_cer = 15;
-        const int t_avdp = 12;
-        const int t_aavdh = 7;
-        const int t_ce = 76;
-        const int t_aa = 76;
-        const int t_oe = 20;
-        const int t_cez = 20; /* max of t_cez, t_oez */
-        const int t_wpl = 40;
-        const int t_wph = 30;
-        memset(&dev_t, 0, sizeof(dev_t));
-        dev_t.t_avdp_r = max_t(int, t_avdp, t_cer) * 1000;
-        dev_t.t_avdp_w = dev_t.t_avdp_r;
-        dev_t.t_aavdh = t_aavdh * 1000;
-        dev_t.t_aa = t_aa * 1000;
-        dev_t.t_ce = t_ce * 1000;
-        dev_t.t_oe = t_oe * 1000;
-        dev_t.t_cez_r = t_cez * 1000;
-        dev_t.t_cez_w = dev_t.t_cez_r;
-        dev_t.t_wpl = t_wpl * 1000;
-        dev_t.t_wph = t_wph * 1000;
-        gpmc_calc_timings(t, &onenand_async, &dev_t);
-}
-static void omap2_onenand_set_async_mode(void __iomem *onenand_base)
-{
-        u32 reg;
-        /* Ensure sync read and sync write are disabled */
-        reg = readw(onenand_base + ONENAND_REG_SYS_CFG1);
-        reg &= ~ONENAND_SYS_CFG1_SYNC_READ & ~ONENAND_SYS_CFG1_SYNC_WRITE;
-        writew(reg, onenand_base + ONENAND_REG_SYS_CFG1);
-}
-static void set_onenand_cfg(void __iomem *onenand_base)
-{
-        u32 reg = ONENAND_SYS_CFG1_RDY | ONENAND_SYS_CFG1_INT;
-        reg |=  (latency << ONENAND_SYS_CFG1_BRL_SHIFT) |
-                ONENAND_SYS_CFG1_BL_16;
-        if (onenand_flags & ONENAND_FLAG_SYNCREAD)
-                reg |= ONENAND_SYS_CFG1_SYNC_READ;
-        else
-                reg &= ~ONENAND_SYS_CFG1_SYNC_READ;
-        if (onenand_flags & ONENAND_FLAG_SYNCWRITE)
-                reg |= ONENAND_SYS_CFG1_SYNC_WRITE;
-        else
-                reg &= ~ONENAND_SYS_CFG1_SYNC_WRITE;
-        if (onenand_flags & ONENAND_FLAG_HF)
-                reg |= ONENAND_SYS_CFG1_HF;
-        else
-                reg &= ~ONENAND_SYS_CFG1_HF;
-        if (onenand_flags & ONENAND_FLAG_VHF)
-                reg |= ONENAND_SYS_CFG1_VHF;
-        else
-                reg &= ~ONENAND_SYS_CFG1_VHF;
-        writew(reg, onenand_base + ONENAND_REG_SYS_CFG1);
-}
-static int omap2_onenand_get_freq(struct omap_onenand_platform_data *cfg,
-                                  void __iomem *onenand_base)
-{
-        u16 ver = readw(onenand_base + ONENAND_REG_VERSION_ID);
-        int freq;
-        switch ((ver >> 4) & 0xf) {
-        case 0:
-                freq = 40;
-                break;
-        case 1:
-                freq = 54;
-                break;
-        case 2:
-                freq = 66;
-                break;
-        case 3:
-                freq = 83;
-                break;
-        case 4:
-                freq = 104;
-                break;
-        default:
-                pr_err("onenand rate not detected, bad GPMC async timings?\n");
-                freq = 0;
-        }
-        return freq;
-}
-static void omap2_onenand_calc_sync_timings(struct gpmc_timings *t,
-                                            unsigned int flags,
-                                            int freq)
-{
-        struct gpmc_device_timings dev_t;
-        const int t_cer  = 15;
-        const int t_avdp = 12;
-        const int t_cez  = 20; /* max of t_cez, t_oez */
-        const int t_wpl  = 40;
-        const int t_wph  = 30;
-        int min_gpmc_clk_period, t_ces, t_avds, t_avdh, t_ach, t_aavdh, t_rdyo;
-        int div, gpmc_clk_ns;
-        if (flags & ONENAND_SYNC_READ)
-                onenand_flags = ONENAND_FLAG_SYNCREAD;
-        else if (flags & ONENAND_SYNC_READWRITE)
-                onenand_flags = ONENAND_FLAG_SYNCREAD | ONENAND_FLAG_SYNCWRITE;
-        switch (freq) {
-        case 104:
-                min_gpmc_clk_period = 9600; /* 104 MHz */
-                t_ces   = 3;
-                t_avds  = 4;
-                t_avdh  = 2;
-                t_ach   = 3;
-                t_aavdh = 6;
-                t_rdyo  = 6;
-                break;
-        case 83:
-                min_gpmc_clk_period = 12000; /* 83 MHz */
-                t_ces   = 5;
-                t_avds  = 4;
-                t_avdh  = 2;
-                t_ach   = 6;
-                t_aavdh = 6;
-                t_rdyo  = 9;
-                break;
-        case 66:
-                min_gpmc_clk_period = 15000; /* 66 MHz */
-                t_ces   = 6;
-                t_avds  = 5;
-                t_avdh  = 2;
-                t_ach   = 6;
-                t_aavdh = 6;
-                t_rdyo  = 11;
-                break;
-        default:
-                min_gpmc_clk_period = 18500; /* 54 MHz */
-                t_ces   = 7;
-                t_avds  = 7;
-                t_avdh  = 7;
-                t_ach   = 9;
-                t_aavdh = 7;
-                t_rdyo  = 15;
-                onenand_flags &= ~ONENAND_FLAG_SYNCWRITE;
-                break;
-        }
-        div = gpmc_calc_divider(min_gpmc_clk_period);
-        gpmc_clk_ns = gpmc_ticks_to_ns(div);
-        if (gpmc_clk_ns < 15) /* >66MHz */
-                onenand_flags |= ONENAND_FLAG_HF;
-        else
-                onenand_flags &= ~ONENAND_FLAG_HF;
-        if (gpmc_clk_ns < 12) /* >83MHz */
-                onenand_flags |= ONENAND_FLAG_VHF;
-        else
-                onenand_flags &= ~ONENAND_FLAG_VHF;
-        if (onenand_flags & ONENAND_FLAG_VHF)
-                latency = 8;
-        else if (onenand_flags & ONENAND_FLAG_HF)
-                latency = 6;
-        else if (gpmc_clk_ns >= 25) /* 40 MHz*/
-                latency = 3;
-        else
-                latency = 4;
-        /* Set synchronous read timings */
-        memset(&dev_t, 0, sizeof(dev_t));
-        if (onenand_flags & ONENAND_FLAG_SYNCREAD)
-                onenand_sync.sync_read = true;
-        if (onenand_flags & ONENAND_FLAG_SYNCWRITE) {
-                onenand_sync.sync_write = true;
-                onenand_sync.burst_write = true;
-        } else {
-                dev_t.t_avdp_w = max(t_avdp, t_cer) * 1000;
-                dev_t.t_wpl = t_wpl * 1000;
-                dev_t.t_wph = t_wph * 1000;
-                dev_t.t_aavdh = t_aavdh * 1000;
-        }
-        dev_t.ce_xdelay = true;
-        dev_t.avd_xdelay = true;
-        dev_t.oe_xdelay = true;
-        dev_t.we_xdelay = true;
-        dev_t.clk = min_gpmc_clk_period;
-        dev_t.t_bacc = dev_t.clk;
-        dev_t.t_ces = t_ces * 1000;
-        dev_t.t_avds = t_avds * 1000;
-        dev_t.t_avdh = t_avdh * 1000;
-        dev_t.t_ach = t_ach * 1000;
-        dev_t.cyc_iaa = (latency + 1);
-        dev_t.t_cez_r = t_cez * 1000;
-        dev_t.t_cez_w = dev_t.t_cez_r;
-        dev_t.cyc_aavdh_oe = 1;
-        dev_t.t_rdyo = t_rdyo * 1000 + min_gpmc_clk_period;
-        gpmc_calc_timings(t, &onenand_sync, &dev_t);
-}
-static int omap2_onenand_setup_async(void __iomem *onenand_base)
-{
-        struct gpmc_timings t;
-        int ret;
-        /*
-         * Note that we need to keep sync_write set for the call to
-         * omap2_onenand_set_async_mode() to work to detect the onenand
-         * supported clock rate for the sync timings.
-         */
-        if (gpmc_onenand_data->of_node) {
-                gpmc_read_settings_dt(gpmc_onenand_data->of_node,
-                                      &onenand_async);
-                if (onenand_async.sync_read || onenand_async.sync_write) {
-                        if (onenand_async.sync_write)
-                                gpmc_onenand_data->flags |=
-                                        ONENAND_SYNC_READWRITE;
-                        else
-                                gpmc_onenand_data->flags |= ONENAND_SYNC_READ;
-                        onenand_async.sync_read = false;
-                }
-        }
-        onenand_async.sync_write = true;
-        omap2_onenand_calc_async_timings(&t);
-        ret = gpmc_cs_program_settings(gpmc_onenand_data->cs, &onenand_async);
-        if (ret < 0)
-                return ret;
-        ret = gpmc_cs_set_timings(gpmc_onenand_data->cs, &t, &onenand_async);
-        if (ret < 0)
-                return ret;
-        omap2_onenand_set_async_mode(onenand_base);
-        return 0;
-}
-static int omap2_onenand_setup_sync(void __iomem *onenand_base, int *freq_ptr)
-{
-        int ret, freq = *freq_ptr;
-        struct gpmc_timings t;
-        if (!freq) {
-                /* Very first call freq is not known */
-                freq = omap2_onenand_get_freq(gpmc_onenand_data, onenand_base);
-                if (!freq)
-                        return -ENODEV;
-                set_onenand_cfg(onenand_base);
-        }
-        if (gpmc_onenand_data->of_node) {
-                gpmc_read_settings_dt(gpmc_onenand_data->of_node,
-                                      &onenand_sync);
-        } else {
-                /*
-                 * FIXME: Appears to be legacy code from initial ONENAND commit.
-                 * Unclear what boards this is for and if this can be removed.
-                 */
-                if (!cpu_is_omap34xx())
-                        onenand_sync.wait_on_read = true;
-        }
-        omap2_onenand_calc_sync_timings(&t, gpmc_onenand_data->flags, freq);
-        ret = gpmc_cs_program_settings(gpmc_onenand_data->cs, &onenand_sync);
-        if (ret < 0)
-                return ret;
-        ret = gpmc_cs_set_timings(gpmc_onenand_data->cs, &t, &onenand_sync);
-        if (ret < 0)
-                return ret;
-        set_onenand_cfg(onenand_base);
-        *freq_ptr = freq;
-        return 0;
-}
-static int gpmc_onenand_setup(void __iomem *onenand_base, int *freq_ptr)
-{
-        struct device *dev = &gpmc_onenand_device.dev;
-        unsigned l = ONENAND_SYNC_READ | ONENAND_SYNC_READWRITE;
-        int ret;
-        ret = omap2_onenand_setup_async(onenand_base);
-        if (ret) {
-                dev_err(dev, "unable to set to async mode\n");
-                return ret;
-        }
-        if (!(gpmc_onenand_data->flags & l))
-                return 0;
-        ret = omap2_onenand_setup_sync(onenand_base, freq_ptr);
-        if (ret)
-                dev_err(dev, "unable to set to sync mode\n");
-        return ret;
-}
-int gpmc_onenand_init(struct omap_onenand_platform_data *_onenand_data)
-{
-        int err;
-        struct device *dev = &gpmc_onenand_device.dev;
-        gpmc_onenand_data = _onenand_data;
-        gpmc_onenand_data->onenand_setup = gpmc_onenand_setup;
-        gpmc_onenand_device.dev.platform_data = gpmc_onenand_data;
-        if (cpu_is_omap24xx() &&
-                        (gpmc_onenand_data->flags & ONENAND_SYNC_READWRITE)) {
-                dev_warn(dev, "OneNAND using only SYNC_READ on 24xx\n");
-                gpmc_onenand_data->flags &= ~ONENAND_SYNC_READWRITE;
-                gpmc_onenand_data->flags |= ONENAND_SYNC_READ;
-        }
-        if (cpu_is_omap34xx())
-                gpmc_onenand_data->flags |= ONENAND_IN_OMAP34XX;
-        else
-                gpmc_onenand_data->flags &= ~ONENAND_IN_OMAP34XX;
-        err = gpmc_cs_request(gpmc_onenand_data->cs, ONENAND_IO_SIZE,
-                                (unsigned long *)&gpmc_onenand_resource.start);
-        if (err < 0) {
-                dev_err(dev, "Cannot request GPMC CS %d, error %d\n",
-                        gpmc_onenand_data->cs, err);
-                return err;
-        }
-        gpmc_onenand_resource.end = gpmc_onenand_resource.start +
-                                                        ONENAND_IO_SIZE - 1;
-        err = platform_device_register(&gpmc_onenand_device);
-        if (err) {
-                dev_err(dev, "Unable to register OneNAND device\n");
-                gpmc_cs_free(gpmc_onenand_data->cs);
-        }
-        return err;
-}
diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig
index 6356c6da34ea..b20fa9b31efe 100644
--- a/arch/arm64/configs/defconfig
+++ b/arch/arm64/configs/defconfig
@@ -161,7 +161,7 @@ CONFIG_MTD_BLOCK=y
 CONFIG_MTD_M25P80=y
 CONFIG_MTD_NAND=y
 CONFIG_MTD_NAND_DENALI_DT=y
-CONFIG_MTD_NAND_PXA3xx=y
+CONFIG_MTD_NAND_MARVELL=y
 CONFIG_MTD_SPI_NOR=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_NBD=m
diff --git a/drivers/memory/omap-gpmc.c b/drivers/memory/omap-gpmc.c
index a385a35c7de9..90a66b3f7ae1 100644
--- a/drivers/memory/omap-gpmc.c
+++ b/drivers/memory/omap-gpmc.c
@@ -32,7 +32,6 @@
 #include <linux/pm_runtime.h>
 #include <linux/platform_data/mtd-nand-omap2.h>
-#include <linux/platform_data/mtd-onenand-omap2.h>
 #include <asm/mach-types.h>
@@ -1138,6 +1137,112 @@ struct gpmc_nand_ops *gpmc_omap_get_nand_ops(struct gpmc_nand_regs *reg, int cs)
 }
 EXPORT_SYMBOL_GPL(gpmc_omap_get_nand_ops);
+static void gpmc_omap_onenand_calc_sync_timings(struct gpmc_timings *t,
+                                                struct gpmc_settings *s,
+                                                int freq, int latency)
+{
+        struct gpmc_device_timings dev_t;
+        const int t_cer  = 15;
+        const int t_avdp = 12;
+        const int t_cez  = 20; /* max of t_cez, t_oez */
+        const int t_wpl  = 40;
+        const int t_wph  = 30;
+        int min_gpmc_clk_period, t_ces, t_avds, t_avdh, t_ach, t_aavdh, t_rdyo;
+        switch (freq) {
+        case 104:
+                min_gpmc_clk_period = 9600; /* 104 MHz */
+                t_ces   = 3;
+                t_avds  = 4;
+                t_avdh  = 2;
+                t_ach   = 3;
+                t_aavdh = 6;
+                t_rdyo  = 6;
+                break;
+        case 83:
+                min_gpmc_clk_period = 12000; /* 83 MHz */
+                t_ces   = 5;
+                t_avds  = 4;
+                t_avdh  = 2;
+                t_ach   = 6;
+                t_aavdh = 6;
+                t_rdyo  = 9;
+                break;
+        case 66:
+                min_gpmc_clk_period = 15000; /* 66 MHz */
+                t_ces   = 6;
+                t_avds  = 5;
+                t_avdh  = 2;
+                t_ach   = 6;
+                t_aavdh = 6;
+                t_rdyo  = 11;
+                break;
+        default:
+                min_gpmc_clk_period = 18500; /* 54 MHz */
+                t_ces   = 7;
+                t_avds  = 7;
+                t_avdh  = 7;
+                t_ach   = 9;
+                t_aavdh = 7;
+                t_rdyo  = 15;
+                break;
+        }
+        /* Set synchronous read timings */
+        memset(&dev_t, 0, sizeof(dev_t));
+        if (!s->sync_write) {
+                dev_t.t_avdp_w = max(t_avdp, t_cer) * 1000;
+                dev_t.t_wpl = t_wpl * 1000;
+                dev_t.t_wph = t_wph * 1000;
+                dev_t.t_aavdh = t_aavdh * 1000;
+        }
+        dev_t.ce_xdelay = true;
+        dev_t.avd_xdelay = true;
+        dev_t.oe_xdelay = true;
+        dev_t.we_xdelay = true;
+        dev_t.clk = min_gpmc_clk_period;
+        dev_t.t_bacc = dev_t.clk;
+        dev_t.t_ces = t_ces * 1000;
+        dev_t.t_avds = t_avds * 1000;
+        dev_t.t_avdh = t_avdh * 1000;
+        dev_t.t_ach = t_ach * 1000;
+        dev_t.cyc_iaa = (latency + 1);
+        dev_t.t_cez_r = t_cez * 1000;
+        dev_t.t_cez_w = dev_t.t_cez_r;
+        dev_t.cyc_aavdh_oe = 1;
+        dev_t.t_rdyo = t_rdyo * 1000 + min_gpmc_clk_period;
+        gpmc_calc_timings(t, s, &dev_t);
+}
+int gpmc_omap_onenand_set_timings(struct device *dev, int cs, int freq,
+                                  int latency,
+                                  struct gpmc_onenand_info *info)
+{
+        int ret;
+        struct gpmc_timings gpmc_t;
+        struct gpmc_settings gpmc_s;
+        gpmc_read_settings_dt(dev->of_node, &gpmc_s);
+        info->sync_read = gpmc_s.sync_read;
+        info->sync_write = gpmc_s.sync_write;
+        info->burst_len = gpmc_s.burst_len;
+        if (!gpmc_s.sync_read && !gpmc_s.sync_write)
+                return 0;
+        gpmc_omap_onenand_calc_sync_timings(&gpmc_t, &gpmc_s, freq, latency);
+        ret = gpmc_cs_program_settings(cs, &gpmc_s);
+        if (ret < 0)
+                return ret;
+        return gpmc_cs_set_timings(cs, &gpmc_t, &gpmc_s);
+}
+EXPORT_SYMBOL_GPL(gpmc_omap_onenand_set_timings);
 int gpmc_get_client_irq(unsigned irq_config)
 {
        if (!gpmc_irq_domain) {
@@ -1916,41 +2021,6 @@ static void __maybe_unused gpmc_read_timings_dt(struct device_node *np,
                of_property_read_bool(np, "gpmc,time-para-granularity");
 }
-#if IS_ENABLED(CONFIG_MTD_ONENAND)
-static int gpmc_probe_onenand_child(struct platform_device *pdev,
-                                 struct device_node *child)
-{
-        u32 val;
-        struct omap_onenand_platform_data *gpmc_onenand_data;
-        if (of_property_read_u32(child, "reg", &val) < 0) {
-                dev_err(&pdev->dev, "%pOF has no 'reg' property\n",
-                        child);
-                return -ENODEV;
-        }
-        gpmc_onenand_data = devm_kzalloc(&pdev->dev, sizeof(*gpmc_onenand_data),
-                                         GFP_KERNEL);
-        if (!gpmc_onenand_data)
-                return -ENOMEM;
-        gpmc_onenand_data->cs = val;
-        gpmc_onenand_data->of_node = child;
-        gpmc_onenand_data->dma_channel = -1;
-        if (!of_property_read_u32(child, "dma-channel", &val))
-                gpmc_onenand_data->dma_channel = val;
-        return gpmc_onenand_init(gpmc_onenand_data);
-}
-#else
-static int gpmc_probe_onenand_child(struct platform_device *pdev,
-                                    struct device_node *child)
-{
-        return 0;
-}
-#endif
 /**
 * gpmc_probe_generic_child - configures the gpmc for a child device
 * @pdev:       pointer to gpmc platform device
@@ -2053,6 +2123,16 @@ static int gpmc_probe_generic_child(struct platform_device *pdev,
                }
        }
+        if (of_node_cmp(child->name, "onenand") == 0) {
+                /* Warn about older DT blobs with no compatible property */
+                if (!of_property_read_bool(child, "compatible")) {
+                        dev_warn(&pdev->dev,
+                                 "Incompatible OneNAND node: missing compatible");
+                        ret = -EINVAL;
+                        goto err;
+                }
+        }
        if (of_device_is_compatible(child, "ti,omap2-nand")) {
                /* NAND specific setup */
                val = 8;
@@ -2077,8 +2157,9 @@ static int gpmc_probe_generic_child(struct platform_device *pdev,
        } else {
                ret = of_property_read_u32(child, "bank-width",
                                           &gpmc_s.device_width);
-                if (ret < 0) {
+                if (ret < 0 && !gpmc_s.device_width) {
-                        dev_err(&pdev->dev, "%pOF has no 'bank-width' property\n",
+                        dev_err(&pdev->dev,
+                                "%pOF has no 'gpmc,device-width' property\n",
                                child);
                        goto err;
                }
@@ -2188,11 +2269,7 @@ static void gpmc_probe_dt_children(struct platform_device *pdev)
                if (!child->name)
                        continue;
-                if (of_node_cmp(child->name, "onenand") == 0)
+                ret = gpmc_probe_generic_child(pdev, child);
-                        ret = gpmc_probe_onenand_child(pdev, child);
-                else
-                        ret = gpmc_probe_generic_child(pdev, child);
                if (ret) {
                        dev_err(&pdev->dev, "failed to probe DT child '%s': %d\n",
                                child->name, ret);
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index bb48aafed9a2..e6b8c59f2c0d 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -315,6 +315,7 @@ config MTD_NAND_ATMEL
 config MTD_NAND_PXA3xx
        tristate "NAND support on PXA3xx and Armada 370/XP"
+        depends on !MTD_NAND_MARVELL
        depends on PXA3xx || ARCH_MMP || PLAT_ORION || ARCH_MVEBU
        help
@@ -323,6 +324,18 @@ config MTD_NAND_PXA3xx
          platforms (XP, 370, 375, 38x, 39x) and 64-bit Armada
          platforms (7K, 8K) (NFCv2).
+config MTD_NAND_MARVELL
+        tristate "NAND controller support on Marvell boards"
+        depends on PXA3xx || ARCH_MMP || PLAT_ORION || ARCH_MVEBU || \
+                   COMPILE_TEST
+        depends on HAS_IOMEM
+        help
+          This enables the NAND flash controller driver for Marvell boards,
+          including:
+          - PXA3xx processors (NFCv1)
+          - 32-bit Armada platforms (XP, 37x, 38x, 39x) (NFCv2)
+          - 64-bit Aramda platforms (7k, 8k) (NFCv2)
 config MTD_NAND_SLC_LPC32XX
        tristate "NXP LPC32xx SLC Controller"
        depends on ARCH_LPC32XX
@@ -376,9 +389,7 @@ config MTD_NAND_GPMI_NAND
         Enables NAND Flash support for IMX23, IMX28 or IMX6.
         The GPMI controller is very powerful, with the help of BCH
         module, it can do the hardware ECC. The GPMI supports several
-         NAND flashs at the same time. The GPMI may conflicts with other
+         NAND flashs at the same time.
-         block, such as SD card. So pay attention to it when you enable
-         the GPMI.
 config MTD_NAND_BRCMNAND
        tristate "Broadcom STB NAND controller"
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index 118a1349aad3..921634ba400c 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_MTD_NAND_OMAP2) 		+= omap2_nand.o
 obj-$(CONFIG_MTD_NAND_OMAP_BCH_BUILD)   += omap_elm.o
 obj-$(CONFIG_MTD_NAND_CM_X270)          += cmx270_nand.o
 obj-$(CONFIG_MTD_NAND_PXA3xx)           += pxa3xx_nand.o
+obj-$(CONFIG_MTD_NAND_MARVELL)          += marvell_nand.o
 obj-$(CONFIG_MTD_NAND_TMIO)             += tmio_nand.o
 obj-$(CONFIG_MTD_NAND_PLATFORM)         += plat_nand.o
 obj-$(CONFIG_MTD_NAND_PASEMI)           += pasemi_nand.o
diff --git a/drivers/mtd/nand/atmel/nand-controller.c b/drivers/mtd/nand/atmel/nand-controller.c
index 90a71a56bc23..b2f00b398490 100644
--- a/drivers/mtd/nand/atmel/nand-controller.c
+++ b/drivers/mtd/nand/atmel/nand-controller.c
@@ -841,6 +841,8 @@ static int atmel_nand_pmecc_write_pg(struct nand_chip *chip, const u8 *buf,
        struct atmel_nand *nand = to_atmel_nand(chip);
        int ret;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        ret = atmel_nand_pmecc_enable(chip, NAND_ECC_WRITE, raw);
        if (ret)
                return ret;
@@ -857,7 +859,7 @@ static int atmel_nand_pmecc_write_pg(struct nand_chip *chip, const u8 *buf,
        atmel_nand_write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int atmel_nand_pmecc_write_page(struct mtd_info *mtd,
@@ -881,6 +883,8 @@ static int atmel_nand_pmecc_read_pg(struct nand_chip *chip, u8 *buf,
        struct mtd_info *mtd = nand_to_mtd(chip);
        int ret;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        ret = atmel_nand_pmecc_enable(chip, NAND_ECC_READ, raw);
        if (ret)
                return ret;
@@ -1000,7 +1004,7 @@ static int atmel_hsmc_nand_pmecc_read_pg(struct nand_chip *chip, u8 *buf,
         * to the non-optimized one.
         */
        if (nand->activecs->rb.type != ATMEL_NAND_NATIVE_RB) {
-                chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
+                nand_read_page_op(chip, page, 0, NULL, 0);
                return atmel_nand_pmecc_read_pg(chip, buf, oob_required, page,
                                                raw);
@@ -1178,7 +1182,6 @@ static int atmel_hsmc_nand_ecc_init(struct atmel_nand *nand)
        chip->ecc.write_page = atmel_hsmc_nand_pmecc_write_page;
        chip->ecc.read_page_raw = atmel_hsmc_nand_pmecc_read_page_raw;
        chip->ecc.write_page_raw = atmel_hsmc_nand_pmecc_write_page_raw;
-        chip->ecc.options |= NAND_ECC_CUSTOM_PAGE_ACCESS;
        return 0;
 }
diff --git a/drivers/mtd/nand/bf5xx_nand.c b/drivers/mtd/nand/bf5xx_nand.c
index 5655dca6ce43..87bbd177b3e5 100644
--- a/drivers/mtd/nand/bf5xx_nand.c
+++ b/drivers/mtd/nand/bf5xx_nand.c
@@ -572,6 +572,8 @@ static void bf5xx_nand_dma_write_buf(struct mtd_info *mtd,
 static int bf5xx_nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                uint8_t *buf, int oob_required, int page)
 {
+        nand_read_page_op(chip, page, 0, NULL, 0);
        bf5xx_nand_read_buf(mtd, buf, mtd->writesize);
        bf5xx_nand_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -582,10 +584,10 @@ static int bf5xx_nand_write_page_raw(struct mtd_info *mtd,
                struct nand_chip *chip, const uint8_t *buf, int oob_required,
                int page)
 {
-        bf5xx_nand_write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        bf5xx_nand_write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /*
diff --git a/drivers/mtd/nand/brcmnand/brcmnand.c b/drivers/mtd/nand/brcmnand/brcmnand.c
index e0eb51d8c012..b81ddbaae149 100644
--- a/drivers/mtd/nand/brcmnand/brcmnand.c
+++ b/drivers/mtd/nand/brcmnand/brcmnand.c
@@ -1071,7 +1071,7 @@ static void brcmnand_wp(struct mtd_info *mtd, int wp)
                        return;
                brcmnand_set_wp(ctrl, wp);
-                chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+                nand_status_op(chip, NULL);
                /* NAND_STATUS_WP 0x00 = protected, 0x80 = not protected */
                ret = bcmnand_ctrl_poll_status(ctrl,
                                               NAND_CTRL_RDY |
@@ -1453,7 +1453,7 @@ static uint8_t brcmnand_read_byte(struct mtd_info *mtd)
                /* At FC_BYTES boundary, switch to next column */
                if (host->last_byte > 0 && offs == 0)
-                        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, addr, -1);
+                        nand_change_read_column_op(chip, addr, NULL, 0, false);
                ret = ctrl->flash_cache[offs];
                break;
@@ -1681,7 +1681,7 @@ static int brcmstb_nand_verify_erased_page(struct mtd_info *mtd,
        int ret;
        if (!buf) {
-                buf = chip->buffers->databuf;
+                buf = chip->data_buf;
                /* Invalidate page cache */
                chip->pagebuf = -1;
        }
@@ -1689,7 +1689,6 @@ static int brcmstb_nand_verify_erased_page(struct mtd_info *mtd,
        sas = mtd->oobsize / chip->ecc.steps;
        /* read without ecc for verification */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
        ret = chip->ecc.read_page_raw(mtd, chip, buf, true, page);
        if (ret)
                return ret;
@@ -1793,6 +1792,8 @@ static int brcmnand_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        struct brcmnand_host *host = nand_get_controller_data(chip);
        u8 *oob = oob_required ? (u8 *)chip->oob_poi : NULL;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        return brcmnand_read(mtd, chip, host->last_addr,
                        mtd->writesize >> FC_SHIFT, (u32 *)buf, oob);
 }
@@ -1804,6 +1805,8 @@ static int brcmnand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
        u8 *oob = oob_required ? (u8 *)chip->oob_poi : NULL;
        int ret;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        brcmnand_set_ecc_enabled(host, 0);
        ret = brcmnand_read(mtd, chip, host->last_addr,
                        mtd->writesize >> FC_SHIFT, (u32 *)buf, oob);
@@ -1909,8 +1912,10 @@ static int brcmnand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        struct brcmnand_host *host = nand_get_controller_data(chip);
        void *oob = oob_required ? chip->oob_poi : NULL;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        brcmnand_write(mtd, chip, host->last_addr, (const u32 *)buf, oob);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int brcmnand_write_page_raw(struct mtd_info *mtd,
@@ -1920,10 +1925,12 @@ static int brcmnand_write_page_raw(struct mtd_info *mtd,
        struct brcmnand_host *host = nand_get_controller_data(chip);
        void *oob = oob_required ? chip->oob_poi : NULL;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        brcmnand_set_ecc_enabled(host, 0);
        brcmnand_write(mtd, chip, host->last_addr, (const u32 *)buf, oob);
        brcmnand_set_ecc_enabled(host, 1);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int brcmnand_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
@@ -2193,16 +2200,9 @@ static int brcmnand_setup_dev(struct brcmnand_host *host)
        if (ctrl->nand_version >= 0x0702)
                tmp |= ACC_CONTROL_RD_ERASED;
        tmp &= ~ACC_CONTROL_FAST_PGM_RDIN;
-        if (ctrl->features & BRCMNAND_HAS_PREFETCH) {
+        if (ctrl->features & BRCMNAND_HAS_PREFETCH)
-                /*
+                tmp &= ~ACC_CONTROL_PREFETCH;
-                 * FIXME: Flash DMA + prefetch may see spurious erased-page ECC
-                 * errors
-                 */
-                if (has_flash_dma(ctrl))
-                        tmp &= ~ACC_CONTROL_PREFETCH;
-                else
-                        tmp |= ACC_CONTROL_PREFETCH;
-        }
        nand_writereg(ctrl, offs, tmp);
        return 0;
@@ -2230,6 +2230,9 @@ static int brcmnand_init_cs(struct brcmnand_host *host, struct device_node *dn)
        nand_set_controller_data(chip, host);
        mtd->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "brcmnand.%d",
                                   host->cs);
+        if (!mtd->name)
+                return -ENOMEM;
        mtd->owner = THIS_MODULE;
        mtd->dev.parent = &pdev->dev;
@@ -2369,12 +2372,11 @@ static int brcmnand_resume(struct device *dev)
        list_for_each_entry(host, &ctrl->host_list, node) {
                struct nand_chip *chip = &host->chip;
-                struct mtd_info *mtd = nand_to_mtd(chip);
                brcmnand_save_restore_cs_config(host, 1);
                /* Reset the chip, required by some chips after power-up */
-                chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+                nand_reset_op(chip);
        }
        return 0;
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index bc558c438a57..567ff972d5fc 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -353,23 +353,15 @@ static void cafe_nand_bug(struct mtd_info *mtd)
 static int cafe_nand_write_oob(struct mtd_info *mtd,
                               struct nand_chip *chip, int page)
 {
-        int status = 0;
+        return nand_prog_page_op(chip, page, mtd->writesize, chip->oob_poi,
+                                 mtd->oobsize);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
-        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 /* Don't use -- use nand_read_oob_std for now */
 static int cafe_nand_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
                              int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
 }
 /**
 * cafe_nand_read_page_syndrome - [REPLACEABLE] hardware ecc syndrome based page read
@@ -391,7 +383,7 @@ static int cafe_nand_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                     cafe_readl(cafe, NAND_ECC_RESULT),
                     cafe_readl(cafe, NAND_ECC_SYN01));
-        chip->read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        if (checkecc && cafe_readl(cafe, NAND_ECC_RESULT) & (1<<18)) {
@@ -549,13 +541,13 @@ static int cafe_nand_write_page_lowlevel(struct mtd_info *mtd,
 {
        struct cafe_priv *cafe = nand_get_controller_data(chip);
-        chip->write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
        /* Set up ECC autogeneration */
        cafe->ctl2 |= (1<<30);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int cafe_nand_block_bad(struct mtd_info *mtd, loff_t ofs)
@@ -613,7 +605,6 @@ static int cafe_nand_probe(struct pci_dev *pdev,
        uint32_t ctrl;
        int err = 0;
        int old_dma;
-        struct nand_buffers *nbuf;
        /* Very old versions shared the same PCI ident for all three
           functions on the chip. Verify the class too... */
@@ -661,7 +652,6 @@ static int cafe_nand_probe(struct pci_dev *pdev,
        /* Enable the following for a flash based bad block table */
        cafe->nand.bbt_options = NAND_BBT_USE_FLASH;
-        cafe->nand.options = NAND_OWN_BUFFERS;
        if (skipbbt) {
                cafe->nand.options |= NAND_SKIP_BBTSCAN;
@@ -731,32 +721,20 @@ static int cafe_nand_probe(struct pci_dev *pdev,
        if (err)
                goto out_irq;
-        cafe->dmabuf = dma_alloc_coherent(&cafe->pdev->dev,
+        cafe->dmabuf = dma_alloc_coherent(&cafe->pdev->dev, 2112,
-                                2112 + sizeof(struct nand_buffers) +
+                                          &cafe->dmaaddr, GFP_KERNEL);
-                                mtd->writesize + mtd->oobsize,
-                                &cafe->dmaaddr, GFP_KERNEL);
        if (!cafe->dmabuf) {
                err = -ENOMEM;
                goto out_irq;
        }
-        cafe->nand.buffers = nbuf = (void *)cafe->dmabuf + 2112;
        /* Set up DMA address */
-        cafe_writel(cafe, cafe->dmaaddr & 0xffffffff, NAND_DMA_ADDR0);
+        cafe_writel(cafe, lower_32_bits(cafe->dmaaddr), NAND_DMA_ADDR0);
-        if (sizeof(cafe->dmaaddr) > 4)
+        cafe_writel(cafe, upper_32_bits(cafe->dmaaddr), NAND_DMA_ADDR1);
-                /* Shift in two parts to shut the compiler up */
-                cafe_writel(cafe, (cafe->dmaaddr >> 16) >> 16, NAND_DMA_ADDR1);
-        else
-                cafe_writel(cafe, 0, NAND_DMA_ADDR1);
        cafe_dev_dbg(&cafe->pdev->dev, "Set DMA address to %x (virt %p)\n",
                cafe_readl(cafe, NAND_DMA_ADDR0), cafe->dmabuf);
-        /* this driver does not need the @ecccalc and @ecccode */
-        nbuf->ecccalc = NULL;
-        nbuf->ecccode = NULL;
-        nbuf->databuf = (uint8_t *)(nbuf + 1);
        /* Restore the DMA flag */
        usedma = old_dma;
@@ -801,10 +779,7 @@ static int cafe_nand_probe(struct pci_dev *pdev,
        goto out;
 out_free_dma:
-        dma_free_coherent(&cafe->pdev->dev,
+        dma_free_coherent(&cafe->pdev->dev, 2112, cafe->dmabuf, cafe->dmaaddr);
-                        2112 + sizeof(struct nand_buffers) +
-                        mtd->writesize + mtd->oobsize,
-                        cafe->dmabuf, cafe->dmaaddr);
 out_irq:
        /* Disable NAND IRQ in global IRQ mask register */
        cafe_writel(cafe, ~1 & cafe_readl(cafe, GLOBAL_IRQ_MASK), GLOBAL_IRQ_MASK);
@@ -829,10 +804,7 @@ static void cafe_nand_remove(struct pci_dev *pdev)
        nand_release(mtd);
        free_rs(cafe->rs);
        pci_iounmap(pdev, cafe->mmio);
-        dma_free_coherent(&cafe->pdev->dev,
+        dma_free_coherent(&cafe->pdev->dev, 2112, cafe->dmabuf, cafe->dmaaddr);
-                        2112 + sizeof(struct nand_buffers) +
-                        mtd->writesize + mtd->oobsize,
-                        cafe->dmabuf, cafe->dmaaddr);
        kfree(cafe);
 }
diff --git a/drivers/mtd/nand/denali.c b/drivers/mtd/nand/denali.c
index 5124f8ae8c04..313c7f50621b 100644
--- a/drivers/mtd/nand/denali.c
+++ b/drivers/mtd/nand/denali.c
@@ -330,16 +330,12 @@ static int denali_check_erased_page(struct mtd_info *mtd,
                                    unsigned long uncor_ecc_flags,
                                    unsigned int max_bitflips)
 {
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        struct denali_nand_info *denali = mtd_to_denali(mtd);
+        uint8_t *ecc_code = chip->oob_poi + denali->oob_skip_bytes;
        int ecc_steps = chip->ecc.steps;
        int ecc_size = chip->ecc.size;
        int ecc_bytes = chip->ecc.bytes;
-        int i, ret, stat;
+        int i, stat;
-        ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
-                                         chip->ecc.total);
-        if (ret)
-                return ret;
        for (i = 0; i < ecc_steps; i++) {
                if (!(uncor_ecc_flags & BIT(i)))
@@ -645,8 +641,6 @@ static void denali_oob_xfer(struct mtd_info *mtd, struct nand_chip *chip,
                            int page, int write)
 {
        struct denali_nand_info *denali = mtd_to_denali(mtd);
-        unsigned int start_cmd = write ? NAND_CMD_SEQIN : NAND_CMD_READ0;
-        unsigned int rnd_cmd = write ? NAND_CMD_RNDIN : NAND_CMD_RNDOUT;
        int writesize = mtd->writesize;
        int oobsize = mtd->oobsize;
        uint8_t *bufpoi = chip->oob_poi;
@@ -658,11 +652,11 @@ static void denali_oob_xfer(struct mtd_info *mtd, struct nand_chip *chip,
        int i, pos, len;
        /* BBM at the beginning of the OOB area */
-        chip->cmdfunc(mtd, start_cmd, writesize, page);
        if (write)
-                chip->write_buf(mtd, bufpoi, oob_skip);
+                nand_prog_page_begin_op(chip, page, writesize, bufpoi,
+                                        oob_skip);
        else
-                chip->read_buf(mtd, bufpoi, oob_skip);
+                nand_read_page_op(chip, page, writesize, bufpoi, oob_skip);
        bufpoi += oob_skip;
        /* OOB ECC */
@@ -675,30 +669,35 @@ static void denali_oob_xfer(struct mtd_info *mtd, struct nand_chip *chip,
                else if (pos + len > writesize)
                        len = writesize - pos;
-                chip->cmdfunc(mtd, rnd_cmd, pos, -1);
                if (write)
-                        chip->write_buf(mtd, bufpoi, len);
+                        nand_change_write_column_op(chip, pos, bufpoi, len,
+                                                    false);
                else
-                        chip->read_buf(mtd, bufpoi, len);
+                        nand_change_read_column_op(chip, pos, bufpoi, len,
+                                                   false);
                bufpoi += len;
                if (len < ecc_bytes) {
                        len = ecc_bytes - len;
-                        chip->cmdfunc(mtd, rnd_cmd, writesize + oob_skip, -1);
                        if (write)
-                                chip->write_buf(mtd, bufpoi, len);
+                                nand_change_write_column_op(chip, writesize +
+                                                            oob_skip, bufpoi,
+                                                            len, false);
                        else
-                                chip->read_buf(mtd, bufpoi, len);
+                                nand_change_read_column_op(chip, writesize +
+                                                           oob_skip, bufpoi,
+                                                           len, false);
                        bufpoi += len;
                }
        }
        /* OOB free */
        len = oobsize - (bufpoi - chip->oob_poi);
-        chip->cmdfunc(mtd, rnd_cmd, size - len, -1);
        if (write)
-                chip->write_buf(mtd, bufpoi, len);
+                nand_change_write_column_op(chip, size - len, bufpoi, len,
+                                            false);
        else
-                chip->read_buf(mtd, bufpoi, len);
+                nand_change_read_column_op(chip, size - len, bufpoi, len,
+                                           false);
 }
 static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
@@ -710,12 +709,12 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
        int ecc_steps = chip->ecc.steps;
        int ecc_size = chip->ecc.size;
        int ecc_bytes = chip->ecc.bytes;
-        void *dma_buf = denali->buf;
+        void *tmp_buf = denali->buf;
        int oob_skip = denali->oob_skip_bytes;
        size_t size = writesize + oobsize;
        int ret, i, pos, len;
-        ret = denali_data_xfer(denali, dma_buf, size, page, 1, 0);
+        ret = denali_data_xfer(denali, tmp_buf, size, page, 1, 0);
        if (ret)
                return ret;
@@ -730,11 +729,11 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        else if (pos + len > writesize)
                                len = writesize - pos;
-                        memcpy(buf, dma_buf + pos, len);
+                        memcpy(buf, tmp_buf + pos, len);
                        buf += len;
                        if (len < ecc_size) {
                                len = ecc_size - len;
-                                memcpy(buf, dma_buf + writesize + oob_skip,
+                                memcpy(buf, tmp_buf + writesize + oob_skip,
                                       len);
                                buf += len;
                        }
@@ -745,7 +744,7 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                uint8_t *oob = chip->oob_poi;
                /* BBM at the beginning of the OOB area */
-                memcpy(oob, dma_buf + writesize, oob_skip);
+                memcpy(oob, tmp_buf + writesize, oob_skip);
                oob += oob_skip;
                /* OOB ECC */
@@ -758,11 +757,11 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        else if (pos + len > writesize)
                                len = writesize - pos;
-                        memcpy(oob, dma_buf + pos, len);
+                        memcpy(oob, tmp_buf + pos, len);
                        oob += len;
                        if (len < ecc_bytes) {
                                len = ecc_bytes - len;
-                                memcpy(oob, dma_buf + writesize + oob_skip,
+                                memcpy(oob, tmp_buf + writesize + oob_skip,
                                       len);
                                oob += len;
                        }
@@ -770,7 +769,7 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                /* OOB free */
                len = oobsize - (oob - chip->oob_poi);
-                memcpy(oob, dma_buf + size - len, len);
+                memcpy(oob, tmp_buf + size - len, len);
        }
        return 0;
@@ -788,16 +787,12 @@ static int denali_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
                            int page)
 {
        struct denali_nand_info *denali = mtd_to_denali(mtd);
-        int status;
        denali_reset_irq(denali);
        denali_oob_xfer(mtd, chip, page, 1);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
@@ -841,7 +836,7 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
        int ecc_steps = chip->ecc.steps;
        int ecc_size = chip->ecc.size;
        int ecc_bytes = chip->ecc.bytes;
-        void *dma_buf = denali->buf;
+        void *tmp_buf = denali->buf;
        int oob_skip = denali->oob_skip_bytes;
        size_t size = writesize + oobsize;
        int i, pos, len;
@@ -851,7 +846,7 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
         * This simplifies the logic.
         */
        if (!buf || !oob_required)
-                memset(dma_buf, 0xff, size);
+                memset(tmp_buf, 0xff, size);
        /* Arrange the buffer for syndrome payload/ecc layout */
        if (buf) {
@@ -864,11 +859,11 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        else if (pos + len > writesize)
                                len = writesize - pos;
-                        memcpy(dma_buf + pos, buf, len);
+                        memcpy(tmp_buf + pos, buf, len);
                        buf += len;
                        if (len < ecc_size) {
                                len = ecc_size - len;
-                                memcpy(dma_buf + writesize + oob_skip, buf,
+                                memcpy(tmp_buf + writesize + oob_skip, buf,
                                       len);
                                buf += len;
                        }
@@ -879,7 +874,7 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                const uint8_t *oob = chip->oob_poi;
                /* BBM at the beginning of the OOB area */
-                memcpy(dma_buf + writesize, oob, oob_skip);
+                memcpy(tmp_buf + writesize, oob, oob_skip);
                oob += oob_skip;
                /* OOB ECC */
@@ -892,11 +887,11 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        else if (pos + len > writesize)
                                len = writesize - pos;
-                        memcpy(dma_buf + pos, oob, len);
+                        memcpy(tmp_buf + pos, oob, len);
                        oob += len;
                        if (len < ecc_bytes) {
                                len = ecc_bytes - len;
-                                memcpy(dma_buf + writesize + oob_skip, oob,
+                                memcpy(tmp_buf + writesize + oob_skip, oob,
                                       len);
                                oob += len;
                        }
@@ -904,10 +899,10 @@ static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                /* OOB free */
                len = oobsize - (oob - chip->oob_poi);
-                memcpy(dma_buf + size - len, oob, len);
+                memcpy(tmp_buf + size - len, oob, len);
        }
-        return denali_data_xfer(denali, dma_buf, size, page, 1, 1);
+        return denali_data_xfer(denali, tmp_buf, size, page, 1, 1);
 }
 static int denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
@@ -951,7 +946,7 @@ static int denali_erase(struct mtd_info *mtd, int page)
        irq_status = denali_wait_for_irq(denali,
                                         INTR__ERASE_COMP | INTR__ERASE_FAIL);
-        return irq_status & INTR__ERASE_COMP ? 0 : NAND_STATUS_FAIL;
+        return irq_status & INTR__ERASE_COMP ? 0 : -EIO;
 }
 static int denali_setup_data_interface(struct mtd_info *mtd, int chipnr,
@@ -1359,7 +1354,6 @@ int denali_init(struct denali_nand_info *denali)
                chip->read_buf = denali_read_buf;
                chip->write_buf = denali_write_buf;
        }
-        chip->ecc.options |= NAND_ECC_CUSTOM_PAGE_ACCESS;
        chip->ecc.read_page = denali_read_page;
        chip->ecc.read_page_raw = denali_read_page_raw;
        chip->ecc.write_page = denali_write_page;
diff --git a/drivers/mtd/nand/denali.h b/drivers/mtd/nand/denali.h
index 2911066dacac..9ad33d237378 100644
--- a/drivers/mtd/nand/denali.h
+++ b/drivers/mtd/nand/denali.h
@@ -329,7 +329,7 @@ struct denali_nand_info {
 #define DENALI_CAP_DMA_64BIT                    BIT(1)
 int denali_calc_ecc_bytes(int step_size, int strength);
-extern int denali_init(struct denali_nand_info *denali);
+int denali_init(struct denali_nand_info *denali);
-extern void denali_remove(struct denali_nand_info *denali);
+void denali_remove(struct denali_nand_info *denali);
 #endif /* __DENALI_H__ */
diff --git a/drivers/mtd/nand/denali_pci.c b/drivers/mtd/nand/denali_pci.c
index 57fb7ae31412..49cb3e1f8bd0 100644
--- a/drivers/mtd/nand/denali_pci.c
+++ b/drivers/mtd/nand/denali_pci.c
@@ -125,3 +125,7 @@ static struct pci_driver denali_pci_driver = {
        .remove = denali_pci_remove,
 };
 module_pci_driver(denali_pci_driver);
+MODULE_DESCRIPTION("PCI driver for Denali NAND controller");
+MODULE_AUTHOR("Intel Corporation and its suppliers");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index 72671dc52e2e..6bc93ea66f50 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -448,7 +448,7 @@ static int doc200x_wait(struct mtd_info *mtd, struct nand_chip *this)
        int status;
        DoC_WaitReady(doc);
-        this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        nand_status_op(this, NULL);
        DoC_WaitReady(doc);
        status = (int)this->read_byte(mtd);
@@ -595,7 +595,7 @@ static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
        /* Assert ChipEnable and deassert WriteProtect */
        WriteDOC((DOC_FLASH_CE), docptr, Mplus_FlashSelect);
-        this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        nand_reset_op(this);
        doc->curchip = chip;
        doc->curfloor = floor;
diff --git a/drivers/mtd/nand/docg4.c b/drivers/mtd/nand/docg4.c
index 2436cbc71662..72f1327c4430 100644
--- a/drivers/mtd/nand/docg4.c
+++ b/drivers/mtd/nand/docg4.c
@@ -785,6 +785,8 @@ static int read_page(struct mtd_info *mtd, struct nand_chip *nand,
        dev_dbg(doc->dev, "%s: page %08x\n", __func__, page);
+        nand_read_page_op(nand, page, 0, NULL, 0);
        writew(DOC_ECCCONF0_READ_MODE |
               DOC_ECCCONF0_ECC_ENABLE |
               DOC_ECCCONF0_UNKNOWN |
@@ -864,7 +866,7 @@ static int docg4_read_oob(struct mtd_info *mtd, struct nand_chip *nand,
        dev_dbg(doc->dev, "%s: page %x\n", __func__, page);
-        docg4_command(mtd, NAND_CMD_READ0, nand->ecc.size, page);
+        nand_read_page_op(nand, page, nand->ecc.size, NULL, 0);
        writew(DOC_ECCCONF0_READ_MODE | DOCG4_OOB_SIZE, docptr + DOC_ECCCONF0);
        write_nop(docptr);
@@ -900,6 +902,7 @@ static int docg4_erase_block(struct mtd_info *mtd, int page)
        struct docg4_priv *doc = nand_get_controller_data(nand);
        void __iomem *docptr = doc->virtadr;
        uint16_t g4_page;
+        int status;
        dev_dbg(doc->dev, "%s: page %04x\n", __func__, page);
@@ -939,11 +942,15 @@ static int docg4_erase_block(struct mtd_info *mtd, int page)
        poll_status(doc);
        write_nop(docptr);
-        return nand->waitfunc(mtd, nand);
+        status = nand->waitfunc(mtd, nand);
+        if (status < 0)
+                return status;
+        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 static int write_page(struct mtd_info *mtd, struct nand_chip *nand,
-                       const uint8_t *buf, bool use_ecc)
+                      const uint8_t *buf, int page, bool use_ecc)
 {
        struct docg4_priv *doc = nand_get_controller_data(nand);
        void __iomem *docptr = doc->virtadr;
@@ -951,6 +958,8 @@ static int write_page(struct mtd_info *mtd, struct nand_chip *nand,
        dev_dbg(doc->dev, "%s...\n", __func__);
+        nand_prog_page_begin_op(nand, page, 0, NULL, 0);
        writew(DOC_ECCCONF0_ECC_ENABLE |
               DOC_ECCCONF0_UNKNOWN |
               DOCG4_BCH_SIZE,
@@ -995,19 +1004,19 @@ static int write_page(struct mtd_info *mtd, struct nand_chip *nand,
        writew(0, docptr + DOC_DATAEND);
        write_nop(docptr);
-        return 0;
+        return nand_prog_page_end_op(nand);
 }
 static int docg4_write_page_raw(struct mtd_info *mtd, struct nand_chip *nand,
                                const uint8_t *buf, int oob_required, int page)
 {
-        return write_page(mtd, nand, buf, false);
+        return write_page(mtd, nand, buf, page, false);
 }
 static int docg4_write_page(struct mtd_info *mtd, struct nand_chip *nand,
                             const uint8_t *buf, int oob_required, int page)
 {
-        return write_page(mtd, nand, buf, true);
+        return write_page(mtd, nand, buf, page, true);
 }
 static int docg4_write_oob(struct mtd_info *mtd, struct nand_chip *nand,
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 17db2f90aa2c..8b6dcd739ecb 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -713,7 +713,7 @@ static int fsl_elbc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        struct fsl_lbc_ctrl *ctrl = priv->ctrl;
        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = ctrl->nand;
-        fsl_elbc_read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        if (oob_required)
                fsl_elbc_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -729,10 +729,10 @@ static int fsl_elbc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
 static int fsl_elbc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                                const uint8_t *buf, int oob_required, int page)
 {
-        fsl_elbc_write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        fsl_elbc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /* ECC will be calculated automatically, and errors will be detected in
@@ -742,10 +742,10 @@ static int fsl_elbc_write_subpage(struct mtd_info *mtd, struct nand_chip *chip,
                                uint32_t offset, uint32_t data_len,
                                const uint8_t *buf, int oob_required, int page)
 {
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        fsl_elbc_write_buf(mtd, buf, mtd->writesize);
        fsl_elbc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return nand_prog_page_end_op(chip);
-        return 0;
 }
 static int fsl_elbc_chip_init(struct fsl_elbc_mtd *priv)
diff --git a/drivers/mtd/nand/fsl_ifc_nand.c b/drivers/mtd/nand/fsl_ifc_nand.c
index 9e03bac7f34c..4872a7ba6503 100644
--- a/drivers/mtd/nand/fsl_ifc_nand.c
+++ b/drivers/mtd/nand/fsl_ifc_nand.c
@@ -688,7 +688,7 @@ static int fsl_ifc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        struct fsl_ifc_ctrl *ctrl = priv->ctrl;
        struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl;
-        fsl_ifc_read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        if (oob_required)
                fsl_ifc_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -711,10 +711,10 @@ static int fsl_ifc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
 static int fsl_ifc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                               const uint8_t *buf, int oob_required, int page)
 {
-        fsl_ifc_write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        fsl_ifc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int fsl_ifc_chip_init_tail(struct mtd_info *mtd)
@@ -916,6 +916,13 @@ static int fsl_ifc_chip_init(struct fsl_ifc_mtd *priv)
        if (ctrl->version >= FSL_IFC_VERSION_1_1_0)
                fsl_ifc_sram_init(priv);
+        /*
+         * As IFC version 2.0.0 has 16KB of internal SRAM as compared to older
+         * versions which had 8KB. Hence bufnum mask needs to be updated.
+         */
+        if (ctrl->version >= FSL_IFC_VERSION_2_0_0)
+                priv->bufnum_mask = (priv->bufnum_mask * 2) + 1;
        return 0;
 }
diff --git a/drivers/mtd/nand/fsmc_nand.c b/drivers/mtd/nand/fsmc_nand.c
index eac15d9bf49e..f49ed46fa770 100644
--- a/drivers/mtd/nand/fsmc_nand.c
+++ b/drivers/mtd/nand/fsmc_nand.c
@@ -684,8 +684,8 @@ static int fsmc_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
        uint8_t *p = buf;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        uint8_t *ecc_code = chip->ecc.code_buf;
        int off, len, group = 0;
        /*
         * ecc_oob is intentionally taken as uint16_t. In 16bit devices, we
@@ -697,7 +697,7 @@ static int fsmc_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        unsigned int max_bitflips = 0;
        for (i = 0, s = 0; s < eccsteps; s++, i += eccbytes, p += eccsize) {
-                chip->cmdfunc(mtd, NAND_CMD_READ0, s * eccsize, page);
+                nand_read_page_op(chip, page, s * eccsize, NULL, 0);
                chip->ecc.hwctl(mtd, NAND_ECC_READ);
                chip->read_buf(mtd, p, eccsize);
@@ -720,8 +720,7 @@ static int fsmc_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                        if (chip->options & NAND_BUSWIDTH_16)
                                len = roundup(len, 2);
-                        chip->cmdfunc(mtd, NAND_CMD_READOOB, off, page);
+                        nand_read_oob_op(chip, page, off, oob + j, len);
-                        chip->read_buf(mtd, oob + j, len);
                        j += len;
                }
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
index 50f8d4a1b983..ab9a0a2ed3b2 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -1029,11 +1029,13 @@ static void block_mark_swapping(struct gpmi_nand_data *this,
        p[1] = (p[1] & mask) | (from_oob >> (8 - bit));
 }
-static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
+static int gpmi_ecc_read_page_data(struct nand_chip *chip,
-                                uint8_t *buf, int oob_required, int page)
+                                   uint8_t *buf, int oob_required,
+                                   int page)
 {
        struct gpmi_nand_data *this = nand_get_controller_data(chip);
        struct bch_geometry *nfc_geo = &this->bch_geometry;
+        struct mtd_info *mtd = nand_to_mtd(chip);
        void          *payload_virt;
        dma_addr_t    payload_phys;
        void          *auxiliary_virt;
@@ -1097,8 +1099,8 @@ static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                        eccbytes = DIV_ROUND_UP(offset + eccbits, 8);
                        offset /= 8;
                        eccbytes -= offset;
-                        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, offset, -1);
+                        nand_change_read_column_op(chip, offset, eccbuf,
-                        chip->read_buf(mtd, eccbuf, eccbytes);
+                                                   eccbytes, false);
                        /*
                         * ECC data are not byte aligned and we may have
@@ -1176,6 +1178,14 @@ static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        return max_bitflips;
 }
+static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
+                              uint8_t *buf, int oob_required, int page)
+{
+        nand_read_page_op(chip, page, 0, NULL, 0);
+        return gpmi_ecc_read_page_data(chip, buf, oob_required, page);
+}
 /* Fake a virtual small page for the subpage read */
 static int gpmi_ecc_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
                        uint32_t offs, uint32_t len, uint8_t *buf, int page)
@@ -1220,12 +1230,12 @@ static int gpmi_ecc_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
        meta = geo->metadata_size;
        if (first) {
                col = meta + (size + ecc_parity_size) * first;
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, col, -1);
                meta = 0;
                buf = buf + first * size;
        }
+        nand_read_page_op(chip, page, col, NULL, 0);
        /* Save the old environment */
        r1_old = r1_new = readl(bch_regs + HW_BCH_FLASH0LAYOUT0);
        r2_old = r2_new = readl(bch_regs + HW_BCH_FLASH0LAYOUT1);
@@ -1254,7 +1264,7 @@ static int gpmi_ecc_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
        /* Read the subpage now */
        this->swap_block_mark = false;
-        max_bitflips = gpmi_ecc_read_page(mtd, chip, buf, 0, page);
+        max_bitflips = gpmi_ecc_read_page_data(chip, buf, 0, page);
        /* Restore */
        writel(r1_old, bch_regs + HW_BCH_FLASH0LAYOUT0);
@@ -1277,6 +1287,9 @@ static int gpmi_ecc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        int        ret;
        dev_dbg(this->dev, "ecc write page.\n");
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        if (this->swap_block_mark) {
                /*
                 * If control arrives here, we're doing block mark swapping.
@@ -1338,7 +1351,10 @@ exit_auxiliary:
                                payload_virt, payload_phys);
        }
-        return 0;
+        if (ret)
+                return ret;
+        return nand_prog_page_end_op(chip);
 }
 /*
@@ -1411,7 +1427,7 @@ static int gpmi_ecc_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
        memset(chip->oob_poi, ~0, mtd->oobsize);
        /* Read out the conventional OOB. */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
+        nand_read_page_op(chip, page, mtd->writesize, NULL, 0);
        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        /*
@@ -1421,7 +1437,7 @@ static int gpmi_ecc_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
         */
        if (GPMI_IS_MX23(this)) {
                /* Read the block mark into the first byte of the OOB buffer. */
-                chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+                nand_read_page_op(chip, page, 0, NULL, 0);
                chip->oob_poi[0] = chip->read_byte(mtd);
        }
@@ -1432,7 +1448,6 @@ static int
 gpmi_ecc_write_oob(struct mtd_info *mtd, struct nand_chip *chip, int page)
 {
        struct mtd_oob_region of = { };
-        int status = 0;
        /* Do we have available oob area? */
        mtd_ooblayout_free(mtd, 0, &of);
@@ -1442,12 +1457,8 @@ gpmi_ecc_write_oob(struct mtd_info *mtd, struct nand_chip *chip, int page)
        if (!nand_is_slc(chip))
                return -EPERM;
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize + of.offset, page);
+        return nand_prog_page_op(chip, page, mtd->writesize + of.offset,
-        chip->write_buf(mtd, chip->oob_poi + of.offset, of.length);
+                                 chip->oob_poi + of.offset, of.length);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 /*
@@ -1477,8 +1488,8 @@ static int gpmi_ecc_read_page_raw(struct mtd_info *mtd,
        uint8_t *oob = chip->oob_poi;
        int step;
-        chip->read_buf(mtd, tmp_buf,
+        nand_read_page_op(chip, page, 0, tmp_buf,
-                       mtd->writesize + mtd->oobsize);
+                          mtd->writesize + mtd->oobsize);
        /*
         * If required, swap the bad block marker and the data stored in the
@@ -1487,12 +1498,8 @@ static int gpmi_ecc_read_page_raw(struct mtd_info *mtd,
         * See the layout description for a detailed explanation on why this
         * is needed.
         */
-        if (this->swap_block_mark) {
+        if (this->swap_block_mark)
-                u8 swap = tmp_buf[0];
+                swap(tmp_buf[0], tmp_buf[mtd->writesize]);
-                tmp_buf[0] = tmp_buf[mtd->writesize];
-                tmp_buf[mtd->writesize] = swap;
-        }
        /*
         * Copy the metadata section into the oob buffer (this section is
@@ -1615,31 +1622,22 @@ static int gpmi_ecc_write_page_raw(struct mtd_info *mtd,
         * See the layout description for a detailed explanation on why this
         * is needed.
         */
-        if (this->swap_block_mark) {
+        if (this->swap_block_mark)
-                u8 swap = tmp_buf[0];
+                swap(tmp_buf[0], tmp_buf[mtd->writesize]);
-                tmp_buf[0] = tmp_buf[mtd->writesize];
-                tmp_buf[mtd->writesize] = swap;
-        }
-        chip->write_buf(mtd, tmp_buf, mtd->writesize + mtd->oobsize);
+        return nand_prog_page_op(chip, page, 0, tmp_buf,
+                                 mtd->writesize + mtd->oobsize);
-        return 0;
 }
 static int gpmi_ecc_read_oob_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                 int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
        return gpmi_ecc_read_page_raw(mtd, chip, NULL, 1, page);
 }
 static int gpmi_ecc_write_oob_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                 int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
        return gpmi_ecc_write_page_raw(mtd, chip, NULL, 1, page);
 }
@@ -1649,7 +1647,7 @@ static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
        struct gpmi_nand_data *this = nand_get_controller_data(chip);
        int ret = 0;
        uint8_t *block_mark;
-        int column, page, status, chipnr;
+        int column, page, chipnr;
        chipnr = (int)(ofs >> chip->chip_shift);
        chip->select_chip(mtd, chipnr);
@@ -1663,13 +1661,7 @@ static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
        /* Shift to get page */
        page = (int)(ofs >> chip->page_shift);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, column, page);
+        ret = nand_prog_page_op(chip, page, column, block_mark, 1);
-        chip->write_buf(mtd, block_mark, 1);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        if (status & NAND_STATUS_FAIL)
-                ret = -EIO;
        chip->select_chip(mtd, -1);
@@ -1712,7 +1704,7 @@ static int mx23_check_transcription_stamp(struct gpmi_nand_data *this)
        unsigned int search_area_size_in_strides;
        unsigned int stride;
        unsigned int page;
-        uint8_t *buffer = chip->buffers->databuf;
+        uint8_t *buffer = chip->data_buf;
        int saved_chip_number;
        int found_an_ncb_fingerprint = false;
@@ -1737,7 +1729,7 @@ static int mx23_check_transcription_stamp(struct gpmi_nand_data *this)
                 * Read the NCB fingerprint. The fingerprint is four bytes long
                 * and starts in the 12th byte of the page.
                 */
-                chip->cmdfunc(mtd, NAND_CMD_READ0, 12, page);
+                nand_read_page_op(chip, page, 12, NULL, 0);
                chip->read_buf(mtd, buffer, strlen(fingerprint));
                /* Look for the fingerprint. */
@@ -1771,7 +1763,7 @@ static int mx23_write_transcription_stamp(struct gpmi_nand_data *this)
        unsigned int block;
        unsigned int stride;
        unsigned int page;
-        uint8_t      *buffer = chip->buffers->databuf;
+        uint8_t      *buffer = chip->data_buf;
        int saved_chip_number;
        int status;
@@ -1797,17 +1789,10 @@ static int mx23_write_transcription_stamp(struct gpmi_nand_data *this)
        dev_dbg(dev, "Erasing the search area...\n");
        for (block = 0; block < search_area_size_in_blocks; block++) {
-                /* Compute the page address. */
-                page = block * block_size_in_pages;
                /* Erase this block. */
                dev_dbg(dev, "\tErasing block 0x%x\n", block);
-                chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+                status = nand_erase_op(chip, block);
-                chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
+                if (status)
-                /* Wait for the erase to finish. */
-                status = chip->waitfunc(mtd, chip);
-                if (status & NAND_STATUS_FAIL)
                        dev_err(dev, "[%s] Erase failed.\n", __func__);
        }
@@ -1823,13 +1808,9 @@ static int mx23_write_transcription_stamp(struct gpmi_nand_data *this)
                /* Write the first page of the current stride. */
                dev_dbg(dev, "Writing an NCB fingerprint in page 0x%x\n", page);
-                chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
-                chip->ecc.write_page_raw(mtd, chip, buffer, 0, page);
-                chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-                /* Wait for the write to finish. */
+                status = chip->ecc.write_page_raw(mtd, chip, buffer, 0, page);
-                status = chip->waitfunc(mtd, chip);
+                if (status)
-                if (status & NAND_STATUS_FAIL)
                        dev_err(dev, "[%s] Write failed.\n", __func__);
        }
@@ -1884,7 +1865,7 @@ static int mx23_boot_init(struct gpmi_nand_data  *this)
                /* Send the command to read the conventional block mark. */
                chip->select_chip(mtd, chipnr);
-                chip->cmdfunc(mtd, NAND_CMD_READ0, mtd->writesize, page);
+                nand_read_page_op(chip, page, mtd->writesize, NULL, 0);
                block_mark = chip->read_byte(mtd);
                chip->select_chip(mtd, -1);
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
index a45e4ce13d10..06c1f993912c 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
@@ -268,31 +268,31 @@ struct timing_threshold {
 };
 /* Common Services */
-extern int common_nfc_set_geometry(struct gpmi_nand_data *);
+int common_nfc_set_geometry(struct gpmi_nand_data *);
-extern struct dma_chan *get_dma_chan(struct gpmi_nand_data *);
+struct dma_chan *get_dma_chan(struct gpmi_nand_data *);
-extern void prepare_data_dma(struct gpmi_nand_data *,
+void prepare_data_dma(struct gpmi_nand_data *,
-                                enum dma_data_direction dr);
+                      enum dma_data_direction dr);
-extern int start_dma_without_bch_irq(struct gpmi_nand_data *,
+int start_dma_without_bch_irq(struct gpmi_nand_data *,
-                                struct dma_async_tx_descriptor *);
+                              struct dma_async_tx_descriptor *);
-extern int start_dma_with_bch_irq(struct gpmi_nand_data *,
+int start_dma_with_bch_irq(struct gpmi_nand_data *,
-                                struct dma_async_tx_descriptor *);
+                           struct dma_async_tx_descriptor *);
 /* GPMI-NAND helper function library */
-extern int gpmi_init(struct gpmi_nand_data *);
+int gpmi_init(struct gpmi_nand_data *);
-extern int gpmi_extra_init(struct gpmi_nand_data *);
+int gpmi_extra_init(struct gpmi_nand_data *);
-extern void gpmi_clear_bch(struct gpmi_nand_data *);
+void gpmi_clear_bch(struct gpmi_nand_data *);
-extern void gpmi_dump_info(struct gpmi_nand_data *);
+void gpmi_dump_info(struct gpmi_nand_data *);
-extern int bch_set_geometry(struct gpmi_nand_data *);
+int bch_set_geometry(struct gpmi_nand_data *);
-extern int gpmi_is_ready(struct gpmi_nand_data *, unsigned chip);
+int gpmi_is_ready(struct gpmi_nand_data *, unsigned chip);
-extern int gpmi_send_command(struct gpmi_nand_data *);
+int gpmi_send_command(struct gpmi_nand_data *);
-extern void gpmi_begin(struct gpmi_nand_data *);
+void gpmi_begin(struct gpmi_nand_data *);
-extern void gpmi_end(struct gpmi_nand_data *);
+void gpmi_end(struct gpmi_nand_data *);
-extern int gpmi_read_data(struct gpmi_nand_data *);
+int gpmi_read_data(struct gpmi_nand_data *);
-extern int gpmi_send_data(struct gpmi_nand_data *);
+int gpmi_send_data(struct gpmi_nand_data *);
-extern int gpmi_send_page(struct gpmi_nand_data *,
+int gpmi_send_page(struct gpmi_nand_data *,
-                        dma_addr_t payload, dma_addr_t auxiliary);
+                   dma_addr_t payload, dma_addr_t auxiliary);
-extern int gpmi_read_page(struct gpmi_nand_data *,
+int gpmi_read_page(struct gpmi_nand_data *,
-                        dma_addr_t payload, dma_addr_t auxiliary);
+                   dma_addr_t payload, dma_addr_t auxiliary);
 void gpmi_copy_bits(u8 *dst, size_t dst_bit_off,
                    const u8 *src, size_t src_bit_off,
diff --git a/drivers/mtd/nand/hisi504_nand.c b/drivers/mtd/nand/hisi504_nand.c
index 0897261c3e17..cb862793ab6d 100644
--- a/drivers/mtd/nand/hisi504_nand.c
+++ b/drivers/mtd/nand/hisi504_nand.c
@@ -544,7 +544,7 @@ static int hisi_nand_read_page_hwecc(struct mtd_info *mtd,
        int max_bitflips = 0, stat = 0, stat_max = 0, status_ecc;
        int stat_1, stat_2;
-        chip->read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        /* errors which can not be corrected by ECC */
@@ -574,8 +574,7 @@ static int hisi_nand_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
 {
        struct hinfc_host *host = nand_get_controller_data(chip);
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        if (host->irq_status & HINFC504_INTS_UE) {
                host->irq_status = 0;
@@ -590,11 +589,11 @@ static int hisi_nand_write_page_hwecc(struct mtd_info *mtd,
                struct nand_chip *chip, const uint8_t *buf, int oob_required,
                int page)
 {
-        chip->write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        if (oob_required)
                chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static void hisi_nfc_host_init(struct hinfc_host *host)
diff --git a/drivers/mtd/nand/jz4740_nand.c b/drivers/mtd/nand/jz4740_nand.c
index ad827d4af3e9..613b00a9604b 100644
--- a/drivers/mtd/nand/jz4740_nand.c
+++ b/drivers/mtd/nand/jz4740_nand.c
@@ -313,6 +313,7 @@ static int jz_nand_detect_bank(struct platform_device *pdev,
        uint32_t ctrl;
        struct nand_chip *chip = &nand->chip;
        struct mtd_info *mtd = nand_to_mtd(chip);
+        u8 id[2];
        /* Request I/O resource. */
        sprintf(res_name, "bank%d", bank);
@@ -335,17 +336,16 @@ static int jz_nand_detect_bank(struct platform_device *pdev,
                /* Retrieve the IDs from the first chip. */
                chip->select_chip(mtd, 0);
-                chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+                nand_reset_op(chip);
-                chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
+                nand_readid_op(chip, 0, id, sizeof(id));
-                *nand_maf_id = chip->read_byte(mtd);
+                *nand_maf_id = id[0];
-                *nand_dev_id = chip->read_byte(mtd);
+                *nand_dev_id = id[1];
        } else {
                /* Detect additional chip. */
                chip->select_chip(mtd, chipnr);
-                chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+                nand_reset_op(chip);
-                chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
+                nand_readid_op(chip, 0, id, sizeof(id));
-                if (*nand_maf_id != chip->read_byte(mtd)
+                if (*nand_maf_id != id[0] || *nand_dev_id != id[1]) {
-                 || *nand_dev_id != chip->read_byte(mtd)) {
                        ret = -ENODEV;
                        goto notfound_id;
                }
diff --git a/drivers/mtd/nand/lpc32xx_mlc.c b/drivers/mtd/nand/lpc32xx_mlc.c
index 5796468db653..e357948a7505 100644
--- a/drivers/mtd/nand/lpc32xx_mlc.c
+++ b/drivers/mtd/nand/lpc32xx_mlc.c
@@ -461,7 +461,7 @@ static int lpc32xx_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        }
        /* Writing Command and Address */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+        nand_read_page_op(chip, page, 0, NULL, 0);
        /* For all sub-pages */
        for (i = 0; i < host->mlcsubpages; i++) {
@@ -522,6 +522,8 @@ static int lpc32xx_write_page_lowlevel(struct mtd_info *mtd,
                memcpy(dma_buf, buf, mtd->writesize);
        }
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        for (i = 0; i < host->mlcsubpages; i++) {
                /* Start Encode */
                writeb(0x00, MLC_ECC_ENC_REG(host->io_base));
@@ -550,7 +552,8 @@ static int lpc32xx_write_page_lowlevel(struct mtd_info *mtd,
                /* Wait for Controller Ready */
                lpc32xx_waitfunc_controller(mtd, chip);
        }
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int lpc32xx_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
diff --git a/drivers/mtd/nand/lpc32xx_slc.c b/drivers/mtd/nand/lpc32xx_slc.c
index b61f28a1554d..5f7cc6da0a7f 100644
--- a/drivers/mtd/nand/lpc32xx_slc.c
+++ b/drivers/mtd/nand/lpc32xx_slc.c
@@ -399,10 +399,7 @@ static void lpc32xx_nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int
 static int lpc32xx_nand_read_oob_syndrome(struct mtd_info *mtd,
                                          struct nand_chip *chip, int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
 }
 /*
@@ -411,17 +408,8 @@ static int lpc32xx_nand_read_oob_syndrome(struct mtd_info *mtd,
 static int lpc32xx_nand_write_oob_syndrome(struct mtd_info *mtd,
        struct nand_chip *chip, int page)
 {
-        int status;
+        return nand_prog_page_op(chip, page, mtd->writesize, chip->oob_poi,
+                                 mtd->oobsize);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
-        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        /* Send command to program the OOB data */
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 /*
@@ -632,7 +620,7 @@ static int lpc32xx_nand_read_page_syndrome(struct mtd_info *mtd,
        uint8_t *oobecc, tmpecc[LPC32XX_ECC_SAVE_SIZE];
        /* Issue read command */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+        nand_read_page_op(chip, page, 0, NULL, 0);
        /* Read data and oob, calculate ECC */
        status = lpc32xx_xfer(mtd, buf, chip->ecc.steps, 1);
@@ -675,7 +663,7 @@ static int lpc32xx_nand_read_page_raw_syndrome(struct mtd_info *mtd,
                                               int page)
 {
        /* Issue read command */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+        nand_read_page_op(chip, page, 0, NULL, 0);
        /* Raw reads can just use the FIFO interface */
        chip->read_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
@@ -698,6 +686,8 @@ static int lpc32xx_nand_write_page_syndrome(struct mtd_info *mtd,
        uint8_t *pb;
        int error;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        /* Write data, calculate ECC on outbound data */
        error = lpc32xx_xfer(mtd, (uint8_t *)buf, chip->ecc.steps, 0);
        if (error)
@@ -716,7 +706,8 @@ static int lpc32xx_nand_write_page_syndrome(struct mtd_info *mtd,
        /* Write ECC data to device */
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /*
@@ -729,9 +720,11 @@ static int lpc32xx_nand_write_page_raw_syndrome(struct mtd_info *mtd,
                                                int oob_required, int page)
 {
        /* Raw writes can just use the FIFO interface */
-        chip->write_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
+        nand_prog_page_begin_op(chip, page, 0, buf,
+                                chip->ecc.size * chip->ecc.steps);
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int lpc32xx_nand_dma_setup(struct lpc32xx_nand_host *host)
diff --git a/drivers/mtd/nand/marvell_nand.c b/drivers/mtd/nand/marvell_nand.c
new file mode 100644
index 000000000000..2196f2a233d6
--- /dev/null
+++ b/drivers/mtd/nand/marvell_nand.c
@@ -0,0 +1,2896 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Marvell NAND flash controller driver
+ *
+ * Copyright (C) 2017 Marvell
+ * Author: Miquel RAYNAL <miquel.raynal@free-electrons.com>
+ *
+ */
+#include <linux/module.h>
+#include <linux/clk.h>
+#include <linux/mtd/rawnand.h>
+#include <linux/of_platform.h>
+#include <linux/iopoll.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+#include <asm/unaligned.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/dma/pxa-dma.h>
+#include <linux/platform_data/mtd-nand-pxa3xx.h>
+/* Data FIFO granularity, FIFO reads/writes must be a multiple of this length */
+#define FIFO_DEPTH              8
+#define FIFO_REP(x)             (x / sizeof(u32))
+#define BCH_SEQ_READS           (32 / FIFO_DEPTH)
+/* NFC does not support transfers of larger chunks at a time */
+#define MAX_CHUNK_SIZE          2112
+/* NFCv1 cannot read more that 7 bytes of ID */
+#define NFCV1_READID_LEN        7
+/* Polling is done at a pace of POLL_PERIOD us until POLL_TIMEOUT is reached */
+#define POLL_PERIOD             0
+#define POLL_TIMEOUT            100000
+/* Interrupt maximum wait period in ms */
+#define IRQ_TIMEOUT             1000
+/* Latency in clock cycles between SoC pins and NFC logic */
+#define MIN_RD_DEL_CNT          3
+/* Maximum number of contiguous address cycles */
+#define MAX_ADDRESS_CYC_NFCV1   5
+#define MAX_ADDRESS_CYC_NFCV2   7
+/* System control registers/bits to enable the NAND controller on some SoCs */
+#define GENCONF_SOC_DEVICE_MUX  0x208
+#define GENCONF_SOC_DEVICE_MUX_NFC_EN BIT(0)
+#define GENCONF_SOC_DEVICE_MUX_ECC_CLK_RST BIT(20)
+#define GENCONF_SOC_DEVICE_MUX_ECC_CORE_RST BIT(21)
+#define GENCONF_SOC_DEVICE_MUX_NFC_INT_EN BIT(25)
+#define GENCONF_CLK_GATING_CTRL 0x220
+#define GENCONF_CLK_GATING_CTRL_ND_GATE BIT(2)
+#define GENCONF_ND_CLK_CTRL     0x700
+#define GENCONF_ND_CLK_CTRL_EN  BIT(0)
+/* NAND controller data flash control register */
+#define NDCR                    0x00
+#define NDCR_ALL_INT            GENMASK(11, 0)
+#define NDCR_CS1_CMDDM          BIT(7)
+#define NDCR_CS0_CMDDM          BIT(8)
+#define NDCR_RDYM               BIT(11)
+#define NDCR_ND_ARB_EN          BIT(12)
+#define NDCR_RA_START           BIT(15)
+#define NDCR_RD_ID_CNT(x)       (min_t(unsigned int, x, 0x7) << 16)
+#define NDCR_PAGE_SZ(x)         (x >= 2048 ? BIT(24) : 0)
+#define NDCR_DWIDTH_M           BIT(26)
+#define NDCR_DWIDTH_C           BIT(27)
+#define NDCR_ND_RUN             BIT(28)
+#define NDCR_DMA_EN             BIT(29)
+#define NDCR_ECC_EN             BIT(30)
+#define NDCR_SPARE_EN           BIT(31)
+#define NDCR_GENERIC_FIELDS_MASK (~(NDCR_RA_START | NDCR_PAGE_SZ(2048) | \
+                                    NDCR_DWIDTH_M | NDCR_DWIDTH_C))
+/* NAND interface timing parameter 0 register */
+#define NDTR0                   0x04
+#define NDTR0_TRP(x)            ((min_t(unsigned int, x, 0xF) & 0x7) << 0)
+#define NDTR0_TRH(x)            (min_t(unsigned int, x, 0x7) << 3)
+#define NDTR0_ETRP(x)           ((min_t(unsigned int, x, 0xF) & 0x8) << 3)
+#define NDTR0_SEL_NRE_EDGE      BIT(7)
+#define NDTR0_TWP(x)            (min_t(unsigned int, x, 0x7) << 8)
+#define NDTR0_TWH(x)            (min_t(unsigned int, x, 0x7) << 11)
+#define NDTR0_TCS(x)            (min_t(unsigned int, x, 0x7) << 16)
+#define NDTR0_TCH(x)            (min_t(unsigned int, x, 0x7) << 19)
+#define NDTR0_RD_CNT_DEL(x)     (min_t(unsigned int, x, 0xF) << 22)
+#define NDTR0_SELCNTR           BIT(26)
+#define NDTR0_TADL(x)           (min_t(unsigned int, x, 0x1F) << 27)
+/* NAND interface timing parameter 1 register */
+#define NDTR1                   0x0C
+#define NDTR1_TAR(x)            (min_t(unsigned int, x, 0xF) << 0)
+#define NDTR1_TWHR(x)           (min_t(unsigned int, x, 0xF) << 4)
+#define NDTR1_TRHW(x)           (min_t(unsigned int, x / 16, 0x3) << 8)
+#define NDTR1_PRESCALE          BIT(14)
+#define NDTR1_WAIT_MODE         BIT(15)
+#define NDTR1_TR(x)             (min_t(unsigned int, x, 0xFFFF) << 16)
+/* NAND controller status register */
+#define NDSR                    0x14
+#define NDSR_WRCMDREQ           BIT(0)
+#define NDSR_RDDREQ             BIT(1)
+#define NDSR_WRDREQ             BIT(2)
+#define NDSR_CORERR             BIT(3)
+#define NDSR_UNCERR             BIT(4)
+#define NDSR_CMDD(cs)           BIT(8 - cs)
+#define NDSR_RDY(rb)            BIT(11 + rb)
+#define NDSR_ERRCNT(x)          ((x >> 16) & 0x1F)
+/* NAND ECC control register */
+#define NDECCCTRL               0x28
+#define NDECCCTRL_BCH_EN        BIT(0)
+/* NAND controller data buffer register */
+#define NDDB                    0x40
+/* NAND controller command buffer 0 register */
+#define NDCB0                   0x48
+#define NDCB0_CMD1(x)           ((x & 0xFF) << 0)
+#define NDCB0_CMD2(x)           ((x & 0xFF) << 8)
+#define NDCB0_ADDR_CYC(x)       ((x & 0x7) << 16)
+#define NDCB0_ADDR_GET_NUM_CYC(x) (((x) >> 16) & 0x7)
+#define NDCB0_DBC               BIT(19)
+#define NDCB0_CMD_TYPE(x)       ((x & 0x7) << 21)
+#define NDCB0_CSEL              BIT(24)
+#define NDCB0_RDY_BYP           BIT(27)
+#define NDCB0_LEN_OVRD          BIT(28)
+#define NDCB0_CMD_XTYPE(x)      ((x & 0x7) << 29)
+/* NAND controller command buffer 1 register */
+#define NDCB1                   0x4C
+#define NDCB1_COLS(x)           ((x & 0xFFFF) << 0)
+#define NDCB1_ADDRS_PAGE(x)     (x << 16)
+/* NAND controller command buffer 2 register */
+#define NDCB2                   0x50
+#define NDCB2_ADDR5_PAGE(x)     (((x >> 16) & 0xFF) << 0)
+#define NDCB2_ADDR5_CYC(x)      ((x & 0xFF) << 0)
+/* NAND controller command buffer 3 register */
+#define NDCB3                   0x54
+#define NDCB3_ADDR6_CYC(x)      ((x & 0xFF) << 16)
+#define NDCB3_ADDR7_CYC(x)      ((x & 0xFF) << 24)
+/* NAND controller command buffer 0 register 'type' and 'xtype' fields */
+#define TYPE_READ               0
+#define TYPE_WRITE              1
+#define TYPE_ERASE              2
+#define TYPE_READ_ID            3
+#define TYPE_STATUS             4
+#define TYPE_RESET              5
+#define TYPE_NAKED_CMD          6
+#define TYPE_NAKED_ADDR         7
+#define TYPE_MASK               7
+#define XTYPE_MONOLITHIC_RW     0
+#define XTYPE_LAST_NAKED_RW     1
+#define XTYPE_FINAL_COMMAND     3
+#define XTYPE_READ              4
+#define XTYPE_WRITE_DISPATCH    4
+#define XTYPE_NAKED_RW          5
+#define XTYPE_COMMAND_DISPATCH  6
+#define XTYPE_MASK              7
+/**
+ * Marvell ECC engine works differently than the others, in order to limit the
+ * size of the IP, hardware engineers chose to set a fixed strength at 16 bits
+ * per subpage, and depending on a the desired strength needed by the NAND chip,
+ * a particular layout mixing data/spare/ecc is defined, with a possible last
+ * chunk smaller that the others.
+ *
+ * @writesize:          Full page size on which the layout applies
+ * @chunk:              Desired ECC chunk size on which the layout applies
+ * @strength:           Desired ECC strength (per chunk size bytes) on which the
+ *                      layout applies
+ * @nchunks:            Total number of chunks
+ * @full_chunk_cnt:     Number of full-sized chunks, which is the number of
+ *                      repetitions of the pattern:
+ *                      (data_bytes + spare_bytes + ecc_bytes).
+ * @data_bytes:         Number of data bytes per chunk
+ * @spare_bytes:        Number of spare bytes per chunk
+ * @ecc_bytes:          Number of ecc bytes per chunk
+ * @last_data_bytes:    Number of data bytes in the last chunk
+ * @last_spare_bytes:   Number of spare bytes in the last chunk
+ * @last_ecc_bytes:     Number of ecc bytes in the last chunk
+ */
+struct marvell_hw_ecc_layout {
+        /* Constraints */
+        int writesize;
+        int chunk;
+        int strength;
+        /* Corresponding layout */
+        int nchunks;
+        int full_chunk_cnt;
+        int data_bytes;
+        int spare_bytes;
+        int ecc_bytes;
+        int last_data_bytes;
+        int last_spare_bytes;
+        int last_ecc_bytes;
+};
+#define MARVELL_LAYOUT(ws, dc, ds, nc, fcc, db, sb, eb, ldb, lsb, leb)  \
+        {                                                               \
+                .writesize = ws,                                        \
+                .chunk = dc,                                            \
+                .strength = ds,                                         \
+                .nchunks = nc,                                          \
+                .full_chunk_cnt = fcc,                                  \
+                .data_bytes = db,                                       \
+                .spare_bytes = sb,                                      \
+                .ecc_bytes = eb,                                        \
+                .last_data_bytes = ldb,                                 \
+                .last_spare_bytes = lsb,                                \
+                .last_ecc_bytes = leb,                                  \
+        }
+/* Layouts explained in AN-379_Marvell_SoC_NFC_ECC */
+static const struct marvell_hw_ecc_layout marvell_nfc_layouts[] = {
+        MARVELL_LAYOUT(  512,   512,  1,  1,  1,  512,  8,  8,  0,  0,  0),
+        MARVELL_LAYOUT( 2048,   512,  1,  1,  1, 2048, 40, 24,  0,  0,  0),
+        MARVELL_LAYOUT( 2048,   512,  4,  1,  1, 2048, 32, 30,  0,  0,  0),
+        MARVELL_LAYOUT( 4096,   512,  4,  2,  2, 2048, 32, 30,  0,  0,  0),
+        MARVELL_LAYOUT( 4096,   512,  8,  5,  4, 1024,  0, 30,  0, 64, 30),
+};
+/**
+ * The Nand Flash Controller has up to 4 CE and 2 RB pins. The CE selection
+ * is made by a field in NDCB0 register, and in another field in NDCB2 register.
+ * The datasheet describes the logic with an error: ADDR5 field is once
+ * declared at the beginning of NDCB2, and another time at its end. Because the
+ * ADDR5 field of NDCB2 may be used by other bytes, it would be more logical
+ * to use the last bit of this field instead of the first ones.
+ *
+ * @cs:                 Wanted CE lane.
+ * @ndcb0_csel:         Value of the NDCB0 register with or without the flag
+ *                      selecting the wanted CE lane. This is set once when
+ *                      the Device Tree is probed.
+ * @rb:                 Ready/Busy pin for the flash chip
+ */
+struct marvell_nand_chip_sel {
+        unsigned int cs;
+        u32 ndcb0_csel;
+        unsigned int rb;
+};
+/**
+ * NAND chip structure: stores NAND chip device related information
+ *
+ * @chip:               Base NAND chip structure
+ * @node:               Used to store NAND chips into a list
+ * @layout              NAND layout when using hardware ECC
+ * @ndcr:               Controller register value for this NAND chip
+ * @ndtr0:              Timing registers 0 value for this NAND chip
+ * @ndtr1:              Timing registers 1 value for this NAND chip
+ * @selected_die:       Current active CS
+ * @nsels:              Number of CS lines required by the NAND chip
+ * @sels:               Array of CS lines descriptions
+ */
+struct marvell_nand_chip {
+        struct nand_chip chip;
+        struct list_head node;
+        const struct marvell_hw_ecc_layout *layout;
+        u32 ndcr;
+        u32 ndtr0;
+        u32 ndtr1;
+        int addr_cyc;
+        int selected_die;
+        unsigned int nsels;
+        struct marvell_nand_chip_sel sels[0];
+};
+static inline struct marvell_nand_chip *to_marvell_nand(struct nand_chip *chip)
+{
+        return container_of(chip, struct marvell_nand_chip, chip);
+}
+static inline struct marvell_nand_chip_sel *to_nand_sel(struct marvell_nand_chip
+                                                        *nand)
+{
+        return &nand->sels[nand->selected_die];
+}
+/**
+ * NAND controller capabilities for distinction between compatible strings
+ *
+ * @max_cs_nb:          Number of Chip Select lines available
+ * @max_rb_nb:          Number of Ready/Busy lines available
+ * @need_system_controller: Indicates if the SoC needs to have access to the
+ *                      system controller (ie. to enable the NAND controller)
+ * @legacy_of_bindings: Indicates if DT parsing must be done using the old
+ *                      fashion way
+ * @is_nfcv2:           NFCv2 has numerous enhancements compared to NFCv1, ie.
+ *                      BCH error detection and correction algorithm,
+ *                      NDCB3 register has been added
+ * @use_dma:            Use dma for data transfers
+ */
+struct marvell_nfc_caps {
+        unsigned int max_cs_nb;
+        unsigned int max_rb_nb;
+        bool need_system_controller;
+        bool legacy_of_bindings;
+        bool is_nfcv2;
+        bool use_dma;
+};
+/**
+ * NAND controller structure: stores Marvell NAND controller information
+ *
+ * @controller:         Base controller structure
+ * @dev:                Parent device (used to print error messages)
+ * @regs:               NAND controller registers
+ * @ecc_clk:            ECC block clock, two times the NAND controller clock
+ * @complete:           Completion object to wait for NAND controller events
+ * @assigned_cs:        Bitmask describing already assigned CS lines
+ * @chips:              List containing all the NAND chips attached to
+ *                      this NAND controller
+ * @caps:               NAND controller capabilities for each compatible string
+ * @dma_chan:           DMA channel (NFCv1 only)
+ * @dma_buf:            32-bit aligned buffer for DMA transfers (NFCv1 only)
+ */
+struct marvell_nfc {
+        struct nand_hw_control controller;
+        struct device *dev;
+        void __iomem *regs;
+        struct clk *ecc_clk;
+        struct completion complete;
+        unsigned long assigned_cs;
+        struct list_head chips;
+        struct nand_chip *selected_chip;
+        const struct marvell_nfc_caps *caps;
+        /* DMA (NFCv1 only) */
+        bool use_dma;
+        struct dma_chan *dma_chan;
+        u8 *dma_buf;
+};
+static inline struct marvell_nfc *to_marvell_nfc(struct nand_hw_control *ctrl)
+{
+        return container_of(ctrl, struct marvell_nfc, controller);
+}
+/**
+ * NAND controller timings expressed in NAND Controller clock cycles
+ *
+ * @tRP:                ND_nRE pulse width
+ * @tRH:                ND_nRE high duration
+ * @tWP:                ND_nWE pulse time
+ * @tWH:                ND_nWE high duration
+ * @tCS:                Enable signal setup time
+ * @tCH:                Enable signal hold time
+ * @tADL:               Address to write data delay
+ * @tAR:                ND_ALE low to ND_nRE low delay
+ * @tWHR:               ND_nWE high to ND_nRE low for status read
+ * @tRHW:               ND_nRE high duration, read to write delay
+ * @tR:                 ND_nWE high to ND_nRE low for read
+ */
+struct marvell_nfc_timings {
+        /* NDTR0 fields */
+        unsigned int tRP;
+        unsigned int tRH;
+        unsigned int tWP;
+        unsigned int tWH;
+        unsigned int tCS;
+        unsigned int tCH;
+        unsigned int tADL;
+        /* NDTR1 fields */
+        unsigned int tAR;
+        unsigned int tWHR;
+        unsigned int tRHW;
+        unsigned int tR;
+};
+/**
+ * Derives a duration in numbers of clock cycles.
+ *
+ * @ps: Duration in pico-seconds
+ * @period_ns:  Clock period in nano-seconds
+ *
+ * Convert the duration in nano-seconds, then divide by the period and
+ * return the number of clock periods.
+ */
+#define TO_CYCLES(ps, period_ns) (DIV_ROUND_UP(ps / 1000, period_ns))
+/**
+ * NAND driver structure filled during the parsing of the ->exec_op() subop
+ * subset of instructions.
+ *
+ * @ndcb:               Array of values written to NDCBx registers
+ * @cle_ale_delay_ns:   Optional delay after the last CMD or ADDR cycle
+ * @rdy_timeout_ms:     Timeout for waits on Ready/Busy pin
+ * @rdy_delay_ns:       Optional delay after waiting for the RB pin
+ * @data_delay_ns:      Optional delay after the data xfer
+ * @data_instr_idx:     Index of the data instruction in the subop
+ * @data_instr:         Pointer to the data instruction in the subop
+ */
+struct marvell_nfc_op {
+        u32 ndcb[4];
+        unsigned int cle_ale_delay_ns;
+        unsigned int rdy_timeout_ms;
+        unsigned int rdy_delay_ns;
+        unsigned int data_delay_ns;
+        unsigned int data_instr_idx;
+        const struct nand_op_instr *data_instr;
+};
+/*
+ * Internal helper to conditionnally apply a delay (from the above structure,
+ * most of the time).
+ */
+static void cond_delay(unsigned int ns)
+{
+        if (!ns)
+                return;
+        if (ns < 10000)
+                ndelay(ns);
+        else
+                udelay(DIV_ROUND_UP(ns, 1000));
+}
+/*
+ * The controller has many flags that could generate interrupts, most of them
+ * are disabled and polling is used. For the very slow signals, using interrupts
+ * may relax the CPU charge.
+ */
+static void marvell_nfc_disable_int(struct marvell_nfc *nfc, u32 int_mask)
+{
+        u32 reg;
+        /* Writing 1 disables the interrupt */
+        reg = readl_relaxed(nfc->regs + NDCR);
+        writel_relaxed(reg | int_mask, nfc->regs + NDCR);
+}
+static void marvell_nfc_enable_int(struct marvell_nfc *nfc, u32 int_mask)
+{
+        u32 reg;
+        /* Writing 0 enables the interrupt */
+        reg = readl_relaxed(nfc->regs + NDCR);
+        writel_relaxed(reg & ~int_mask, nfc->regs + NDCR);
+}
+static void marvell_nfc_clear_int(struct marvell_nfc *nfc, u32 int_mask)
+{
+        writel_relaxed(int_mask, nfc->regs + NDSR);
+}
+static void marvell_nfc_force_byte_access(struct nand_chip *chip,
+                                          bool force_8bit)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 ndcr;
+        /*
+         * Callers of this function do not verify if the NAND is using a 16-bit
+         * an 8-bit bus for normal operations, so we need to take care of that
+         * here by leaving the configuration unchanged if the NAND does not have
+         * the NAND_BUSWIDTH_16 flag set.
+         */
+        if (!(chip->options & NAND_BUSWIDTH_16))
+                return;
+        ndcr = readl_relaxed(nfc->regs + NDCR);
+        if (force_8bit)
+                ndcr &= ~(NDCR_DWIDTH_M | NDCR_DWIDTH_C);
+        else
+                ndcr |= NDCR_DWIDTH_M | NDCR_DWIDTH_C;
+        writel_relaxed(ndcr, nfc->regs + NDCR);
+}
+static int marvell_nfc_wait_ndrun(struct nand_chip *chip)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 val;
+        int ret;
+        /*
+         * The command is being processed, wait for the ND_RUN bit to be
+         * cleared by the NFC. If not, we must clear it by hand.
+         */
+        ret = readl_relaxed_poll_timeout(nfc->regs + NDCR, val,
+                                         (val & NDCR_ND_RUN) == 0,
+                                         POLL_PERIOD, POLL_TIMEOUT);
+        if (ret) {
+                dev_err(nfc->dev, "Timeout on NAND controller run mode\n");
+                writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,
+                               nfc->regs + NDCR);
+                return ret;
+        }
+        return 0;
+}
+/*
+ * Any time a command has to be sent to the controller, the following sequence
+ * has to be followed:
+ * - call marvell_nfc_prepare_cmd()
+ *      -> activate the ND_RUN bit that will kind of 'start a job'
+ *      -> wait the signal indicating the NFC is waiting for a command
+ * - send the command (cmd and address cycles)
+ * - enventually send or receive the data
+ * - call marvell_nfc_end_cmd() with the corresponding flag
+ *      -> wait the flag to be triggered or cancel the job with a timeout
+ *
+ * The following helpers are here to factorize the code a bit so that
+ * specialized functions responsible for executing the actual NAND
+ * operations do not have to replicate the same code blocks.
+ */
+static int marvell_nfc_prepare_cmd(struct nand_chip *chip)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 ndcr, val;
+        int ret;
+        /* Poll ND_RUN and clear NDSR before issuing any command */
+        ret = marvell_nfc_wait_ndrun(chip);
+        if (ret) {
+                dev_err(nfc->dev, "Last operation did not succeed\n");
+                return ret;
+        }
+        ndcr = readl_relaxed(nfc->regs + NDCR);
+        writel_relaxed(readl(nfc->regs + NDSR), nfc->regs + NDSR);
+        /* Assert ND_RUN bit and wait the NFC to be ready */
+        writel_relaxed(ndcr | NDCR_ND_RUN, nfc->regs + NDCR);
+        ret = readl_relaxed_poll_timeout(nfc->regs + NDSR, val,
+                                         val & NDSR_WRCMDREQ,
+                                         POLL_PERIOD, POLL_TIMEOUT);
+        if (ret) {
+                dev_err(nfc->dev, "Timeout on WRCMDRE\n");
+                return -ETIMEDOUT;
+        }
+        /* Command may be written, clear WRCMDREQ status bit */
+        writel_relaxed(NDSR_WRCMDREQ, nfc->regs + NDSR);
+        return 0;
+}
+static void marvell_nfc_send_cmd(struct nand_chip *chip,
+                                 struct marvell_nfc_op *nfc_op)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        dev_dbg(nfc->dev, "\nNDCR:  0x%08x\n"
+                "NDCB0: 0x%08x\nNDCB1: 0x%08x\nNDCB2: 0x%08x\nNDCB3: 0x%08x\n",
+                (u32)readl_relaxed(nfc->regs + NDCR), nfc_op->ndcb[0],
+                nfc_op->ndcb[1], nfc_op->ndcb[2], nfc_op->ndcb[3]);
+        writel_relaxed(to_nand_sel(marvell_nand)->ndcb0_csel | nfc_op->ndcb[0],
+                       nfc->regs + NDCB0);
+        writel_relaxed(nfc_op->ndcb[1], nfc->regs + NDCB0);
+        writel(nfc_op->ndcb[2], nfc->regs + NDCB0);
+        /*
+         * Write NDCB0 four times only if LEN_OVRD is set or if ADDR6 or ADDR7
+         * fields are used (only available on NFCv2).
+         */
+        if (nfc_op->ndcb[0] & NDCB0_LEN_OVRD ||
+            NDCB0_ADDR_GET_NUM_CYC(nfc_op->ndcb[0]) >= 6) {
+                if (!WARN_ON_ONCE(!nfc->caps->is_nfcv2))
+                        writel(nfc_op->ndcb[3], nfc->regs + NDCB0);
+        }
+}
+static int marvell_nfc_end_cmd(struct nand_chip *chip, int flag,
+                               const char *label)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 val;
+        int ret;
+        ret = readl_relaxed_poll_timeout(nfc->regs + NDSR, val,
+                                         val & flag,
+                                         POLL_PERIOD, POLL_TIMEOUT);
+        if (ret) {
+                dev_err(nfc->dev, "Timeout on %s (NDSR: 0x%08x)\n",
+                        label, val);
+                if (nfc->dma_chan)
+                        dmaengine_terminate_all(nfc->dma_chan);
+                return ret;
+        }
+        /*
+         * DMA function uses this helper to poll on CMDD bits without wanting
+         * them to be cleared.
+         */
+        if (nfc->use_dma && (readl_relaxed(nfc->regs + NDCR) & NDCR_DMA_EN))
+                return 0;
+        writel_relaxed(flag, nfc->regs + NDSR);
+        return 0;
+}
+static int marvell_nfc_wait_cmdd(struct nand_chip *chip)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        int cs_flag = NDSR_CMDD(to_nand_sel(marvell_nand)->ndcb0_csel);
+        return marvell_nfc_end_cmd(chip, cs_flag, "CMDD");
+}
+static int marvell_nfc_wait_op(struct nand_chip *chip, unsigned int timeout_ms)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        int ret;
+        /* Timeout is expressed in ms */
+        if (!timeout_ms)
+                timeout_ms = IRQ_TIMEOUT;
+        init_completion(&nfc->complete);
+        marvell_nfc_enable_int(nfc, NDCR_RDYM);
+        ret = wait_for_completion_timeout(&nfc->complete,
+                                          msecs_to_jiffies(timeout_ms));
+        marvell_nfc_disable_int(nfc, NDCR_RDYM);
+        marvell_nfc_clear_int(nfc, NDSR_RDY(0) | NDSR_RDY(1));
+        if (!ret) {
+                dev_err(nfc->dev, "Timeout waiting for RB signal\n");
+                return -ETIMEDOUT;
+        }
+        return 0;
+}
+static void marvell_nfc_select_chip(struct mtd_info *mtd, int die_nr)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 ndcr_generic;
+        if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die)
+                return;
+        if (die_nr < 0 || die_nr >= marvell_nand->nsels) {
+                nfc->selected_chip = NULL;
+                marvell_nand->selected_die = -1;
+                return;
+        }
+        /*
+         * Do not change the timing registers when using the DT property
+         * marvell,nand-keep-config; in that case ->ndtr0 and ->ndtr1 from the
+         * marvell_nand structure are supposedly empty.
+         */
+        writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0);
+        writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1);
+        /*
+         * Reset the NDCR register to a clean state for this particular chip,
+         * also clear ND_RUN bit.
+         */
+        ndcr_generic = readl_relaxed(nfc->regs + NDCR) &
+                       NDCR_GENERIC_FIELDS_MASK & ~NDCR_ND_RUN;
+        writel_relaxed(ndcr_generic | marvell_nand->ndcr, nfc->regs + NDCR);
+        /* Also reset the interrupt status register */
+        marvell_nfc_clear_int(nfc, NDCR_ALL_INT);
+        nfc->selected_chip = chip;
+        marvell_nand->selected_die = die_nr;
+}
+static irqreturn_t marvell_nfc_isr(int irq, void *dev_id)
+{
+        struct marvell_nfc *nfc = dev_id;
+        u32 st = readl_relaxed(nfc->regs + NDSR);
+        u32 ien = (~readl_relaxed(nfc->regs + NDCR)) & NDCR_ALL_INT;
+        /*
+         * RDY interrupt mask is one bit in NDCR while there are two status
+         * bit in NDSR (RDY[cs0/cs2] and RDY[cs1/cs3]).
+         */
+        if (st & NDSR_RDY(1))
+                st |= NDSR_RDY(0);
+        if (!(st & ien))
+                return IRQ_NONE;
+        marvell_nfc_disable_int(nfc, st & NDCR_ALL_INT);
+        if (!(st & (NDSR_RDDREQ | NDSR_WRDREQ | NDSR_WRCMDREQ)))
+                complete(&nfc->complete);
+        return IRQ_HANDLED;
+}
+/* HW ECC related functions */
+static void marvell_nfc_enable_hw_ecc(struct nand_chip *chip)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 ndcr = readl_relaxed(nfc->regs + NDCR);
+        if (!(ndcr & NDCR_ECC_EN)) {
+                writel_relaxed(ndcr | NDCR_ECC_EN, nfc->regs + NDCR);
+                /*
+                 * When enabling BCH, set threshold to 0 to always know the
+                 * number of corrected bitflips.
+                 */
+                if (chip->ecc.algo == NAND_ECC_BCH)
+                        writel_relaxed(NDECCCTRL_BCH_EN, nfc->regs + NDECCCTRL);
+        }
+}
+static void marvell_nfc_disable_hw_ecc(struct nand_chip *chip)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        u32 ndcr = readl_relaxed(nfc->regs + NDCR);
+        if (ndcr & NDCR_ECC_EN) {
+                writel_relaxed(ndcr & ~NDCR_ECC_EN, nfc->regs + NDCR);
+                if (chip->ecc.algo == NAND_ECC_BCH)
+                        writel_relaxed(0, nfc->regs + NDECCCTRL);
+        }
+}
+/* DMA related helpers */
+static void marvell_nfc_enable_dma(struct marvell_nfc *nfc)
+{
+        u32 reg;
+        reg = readl_relaxed(nfc->regs + NDCR);
+        writel_relaxed(reg | NDCR_DMA_EN, nfc->regs + NDCR);
+}
+static void marvell_nfc_disable_dma(struct marvell_nfc *nfc)
+{
+        u32 reg;
+        reg = readl_relaxed(nfc->regs + NDCR);
+        writel_relaxed(reg & ~NDCR_DMA_EN, nfc->regs + NDCR);
+}
+/* Read/write PIO/DMA accessors */
+static int marvell_nfc_xfer_data_dma(struct marvell_nfc *nfc,
+                                     enum dma_data_direction direction,
+                                     unsigned int len)
+{
+        unsigned int dma_len = min_t(int, ALIGN(len, 32), MAX_CHUNK_SIZE);
+        struct dma_async_tx_descriptor *tx;
+        struct scatterlist sg;
+        dma_cookie_t cookie;
+        int ret;
+        marvell_nfc_enable_dma(nfc);
+        /* Prepare the DMA transfer */
+        sg_init_one(&sg, nfc->dma_buf, dma_len);
+        dma_map_sg(nfc->dma_chan->device->dev, &sg, 1, direction);
+        tx = dmaengine_prep_slave_sg(nfc->dma_chan, &sg, 1,
+                                     direction == DMA_FROM_DEVICE ?
+                                     DMA_DEV_TO_MEM : DMA_MEM_TO_DEV,
+                                     DMA_PREP_INTERRUPT);
+        if (!tx) {
+                dev_err(nfc->dev, "Could not prepare DMA S/G list\n");
+                return -ENXIO;
+        }
+        /* Do the task and wait for it to finish */
+        cookie = dmaengine_submit(tx);
+        ret = dma_submit_error(cookie);
+        if (ret)
+                return -EIO;
+        dma_async_issue_pending(nfc->dma_chan);
+        ret = marvell_nfc_wait_cmdd(nfc->selected_chip);
+        dma_unmap_sg(nfc->dma_chan->device->dev, &sg, 1, direction);
+        marvell_nfc_disable_dma(nfc);
+        if (ret) {
+                dev_err(nfc->dev, "Timeout waiting for DMA (status: %d)\n",
+                        dmaengine_tx_status(nfc->dma_chan, cookie, NULL));
+                dmaengine_terminate_all(nfc->dma_chan);
+                return -ETIMEDOUT;
+        }
+        return 0;
+}
+static int marvell_nfc_xfer_data_in_pio(struct marvell_nfc *nfc, u8 *in,
+                                        unsigned int len)
+{
+        unsigned int last_len = len % FIFO_DEPTH;
+        unsigned int last_full_offset = round_down(len, FIFO_DEPTH);
+        int i;
+        for (i = 0; i < last_full_offset; i += FIFO_DEPTH)
+                ioread32_rep(nfc->regs + NDDB, in + i, FIFO_REP(FIFO_DEPTH));
+        if (last_len) {
+                u8 tmp_buf[FIFO_DEPTH];
+                ioread32_rep(nfc->regs + NDDB, tmp_buf, FIFO_REP(FIFO_DEPTH));
+                memcpy(in + last_full_offset, tmp_buf, last_len);
+        }
+        return 0;
+}
+static int marvell_nfc_xfer_data_out_pio(struct marvell_nfc *nfc, const u8 *out,
+                                         unsigned int len)
+{
+        unsigned int last_len = len % FIFO_DEPTH;
+        unsigned int last_full_offset = round_down(len, FIFO_DEPTH);
+        int i;
+        for (i = 0; i < last_full_offset; i += FIFO_DEPTH)
+                iowrite32_rep(nfc->regs + NDDB, out + i, FIFO_REP(FIFO_DEPTH));
+        if (last_len) {
+                u8 tmp_buf[FIFO_DEPTH];
+                memcpy(tmp_buf, out + last_full_offset, last_len);
+                iowrite32_rep(nfc->regs + NDDB, tmp_buf, FIFO_REP(FIFO_DEPTH));
+        }
+        return 0;
+}
+static void marvell_nfc_check_empty_chunk(struct nand_chip *chip,
+                                          u8 *data, int data_len,
+                                          u8 *spare, int spare_len,
+                                          u8 *ecc, int ecc_len,
+                                          unsigned int *max_bitflips)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        int bf;
+        /*
+         * Blank pages (all 0xFF) that have not been written may be recognized
+         * as bad if bitflips occur, so whenever an uncorrectable error occurs,
+         * check if the entire page (with ECC bytes) is actually blank or not.
+         */
+        if (!data)
+                data_len = 0;
+        if (!spare)
+                spare_len = 0;
+        if (!ecc)
+                ecc_len = 0;
+        bf = nand_check_erased_ecc_chunk(data, data_len, ecc, ecc_len,
+                                         spare, spare_len, chip->ecc.strength);
+        if (bf < 0) {
+                mtd->ecc_stats.failed++;
+                return;
+        }
+        /* Update the stats and max_bitflips */
+        mtd->ecc_stats.corrected += bf;
+        *max_bitflips = max_t(unsigned int, *max_bitflips, bf);
+}
+/*
+ * Check a chunk is correct or not according to hardware ECC engine.
+ * mtd->ecc_stats.corrected is updated, as well as max_bitflips, however
+ * mtd->ecc_stats.failure is not, the function will instead return a non-zero
+ * value indicating that a check on the emptyness of the subpage must be
+ * performed before declaring the subpage corrupted.
+ */
+static int marvell_nfc_hw_ecc_correct(struct nand_chip *chip,
+                                      unsigned int *max_bitflips)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        int bf = 0;
+        u32 ndsr;
+        ndsr = readl_relaxed(nfc->regs + NDSR);
+        /* Check uncorrectable error flag */
+        if (ndsr & NDSR_UNCERR) {
+                writel_relaxed(ndsr, nfc->regs + NDSR);
+                /*
+                 * Do not increment ->ecc_stats.failed now, instead, return a
+                 * non-zero value to indicate that this chunk was apparently
+                 * bad, and it should be check to see if it empty or not. If
+                 * the chunk (with ECC bytes) is not declared empty, the calling
+                 * function must increment the failure count.
+                 */
+                return -EBADMSG;
+        }
+        /* Check correctable error flag */
+        if (ndsr & NDSR_CORERR) {
+                writel_relaxed(ndsr, nfc->regs + NDSR);
+                if (chip->ecc.algo == NAND_ECC_BCH)
+                        bf = NDSR_ERRCNT(ndsr);
+                else
+                        bf = 1;
+        }
+        /* Update the stats and max_bitflips */
+        mtd->ecc_stats.corrected += bf;
+        *max_bitflips = max_t(unsigned int, *max_bitflips, bf);
+        return 0;
+}
+/* Hamming read helpers */
+static int marvell_nfc_hw_ecc_hmg_do_read_page(struct nand_chip *chip,
+                                               u8 *data_buf, u8 *oob_buf,
+                                               bool raw, int page)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        struct marvell_nfc_op nfc_op = {
+                .ndcb[0] = NDCB0_CMD_TYPE(TYPE_READ) |
+                           NDCB0_ADDR_CYC(marvell_nand->addr_cyc) |
+                           NDCB0_DBC |
+                           NDCB0_CMD1(NAND_CMD_READ0) |
+                           NDCB0_CMD2(NAND_CMD_READSTART),
+                .ndcb[1] = NDCB1_ADDRS_PAGE(page),
+                .ndcb[2] = NDCB2_ADDR5_PAGE(page),
+        };
+        unsigned int oob_bytes = lt->spare_bytes + (raw ? lt->ecc_bytes : 0);
+        int ret;
+        /* NFCv2 needs more information about the operation being executed */
+        if (nfc->caps->is_nfcv2)
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_MONOLITHIC_RW);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_RDDREQ,
+                                  "RDDREQ while draining FIFO (data/oob)");
+        if (ret)
+                return ret;
+        /*
+         * Read the page then the OOB area. Unlike what is shown in current
+         * documentation, spare bytes are protected by the ECC engine, and must
+         * be at the beginning of the OOB area or running this driver on legacy
+         * systems will prevent the discovery of the BBM/BBT.
+         */
+        if (nfc->use_dma) {
+                marvell_nfc_xfer_data_dma(nfc, DMA_FROM_DEVICE,
+                                          lt->data_bytes + oob_bytes);
+                memcpy(data_buf, nfc->dma_buf, lt->data_bytes);
+                memcpy(oob_buf, nfc->dma_buf + lt->data_bytes, oob_bytes);
+        } else {
+                marvell_nfc_xfer_data_in_pio(nfc, data_buf, lt->data_bytes);
+                marvell_nfc_xfer_data_in_pio(nfc, oob_buf, oob_bytes);
+        }
+        ret = marvell_nfc_wait_cmdd(chip);
+        return ret;
+}
+static int marvell_nfc_hw_ecc_hmg_read_page_raw(struct mtd_info *mtd,
+                                                struct nand_chip *chip, u8 *buf,
+                                                int oob_required, int page)
+{
+        return marvell_nfc_hw_ecc_hmg_do_read_page(chip, buf, chip->oob_poi,
+                                                   true, page);
+}
+static int marvell_nfc_hw_ecc_hmg_read_page(struct mtd_info *mtd,
+                                            struct nand_chip *chip,
+                                            u8 *buf, int oob_required,
+                                            int page)
+{
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        unsigned int full_sz = lt->data_bytes + lt->spare_bytes + lt->ecc_bytes;
+        int max_bitflips = 0, ret;
+        u8 *raw_buf;
+        marvell_nfc_enable_hw_ecc(chip);
+        marvell_nfc_hw_ecc_hmg_do_read_page(chip, buf, chip->oob_poi, false,
+                                            page);
+        ret = marvell_nfc_hw_ecc_correct(chip, &max_bitflips);
+        marvell_nfc_disable_hw_ecc(chip);
+        if (!ret)
+                return max_bitflips;
+        /*
+         * When ECC failures are detected, check if the full page has been
+         * written or not. Ignore the failure if it is actually empty.
+         */
+        raw_buf = kmalloc(full_sz, GFP_KERNEL);
+        if (!raw_buf)
+                return -ENOMEM;
+        marvell_nfc_hw_ecc_hmg_do_read_page(chip, raw_buf, raw_buf +
+                                            lt->data_bytes, true, page);
+        marvell_nfc_check_empty_chunk(chip, raw_buf, full_sz, NULL, 0, NULL, 0,
+                                      &max_bitflips);
+        kfree(raw_buf);
+        return max_bitflips;
+}
+/*
+ * Spare area in Hamming layouts is not protected by the ECC engine (even if
+ * it appears before the ECC bytes when reading), the ->read_oob_raw() function
+ * also stands for ->read_oob().
+ */
+static int marvell_nfc_hw_ecc_hmg_read_oob_raw(struct mtd_info *mtd,
+                                               struct nand_chip *chip, int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        return marvell_nfc_hw_ecc_hmg_do_read_page(chip, chip->data_buf,
+                                                   chip->oob_poi, true, page);
+}
+/* Hamming write helpers */
+static int marvell_nfc_hw_ecc_hmg_do_write_page(struct nand_chip *chip,
+                                                const u8 *data_buf,
+                                                const u8 *oob_buf, bool raw,
+                                                int page)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        struct marvell_nfc_op nfc_op = {
+                .ndcb[0] = NDCB0_CMD_TYPE(TYPE_WRITE) |
+                           NDCB0_ADDR_CYC(marvell_nand->addr_cyc) |
+                           NDCB0_CMD1(NAND_CMD_SEQIN) |
+                           NDCB0_CMD2(NAND_CMD_PAGEPROG) |
+                           NDCB0_DBC,
+                .ndcb[1] = NDCB1_ADDRS_PAGE(page),
+                .ndcb[2] = NDCB2_ADDR5_PAGE(page),
+        };
+        unsigned int oob_bytes = lt->spare_bytes + (raw ? lt->ecc_bytes : 0);
+        int ret;
+        /* NFCv2 needs more information about the operation being executed */
+        if (nfc->caps->is_nfcv2)
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_MONOLITHIC_RW);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_WRDREQ,
+                                  "WRDREQ while loading FIFO (data)");
+        if (ret)
+                return ret;
+        /* Write the page then the OOB area */
+        if (nfc->use_dma) {
+                memcpy(nfc->dma_buf, data_buf, lt->data_bytes);
+                memcpy(nfc->dma_buf + lt->data_bytes, oob_buf, oob_bytes);
+                marvell_nfc_xfer_data_dma(nfc, DMA_TO_DEVICE, lt->data_bytes +
+                                          lt->ecc_bytes + lt->spare_bytes);
+        } else {
+                marvell_nfc_xfer_data_out_pio(nfc, data_buf, lt->data_bytes);
+                marvell_nfc_xfer_data_out_pio(nfc, oob_buf, oob_bytes);
+        }
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        ret = marvell_nfc_wait_op(chip,
+                                  chip->data_interface.timings.sdr.tPROG_max);
+        return ret;
+}
+static int marvell_nfc_hw_ecc_hmg_write_page_raw(struct mtd_info *mtd,
+                                                 struct nand_chip *chip,
+                                                 const u8 *buf,
+                                                 int oob_required, int page)
+{
+        return marvell_nfc_hw_ecc_hmg_do_write_page(chip, buf, chip->oob_poi,
+                                                    true, page);
+}
+static int marvell_nfc_hw_ecc_hmg_write_page(struct mtd_info *mtd,
+                                             struct nand_chip *chip,
+                                             const u8 *buf,
+                                             int oob_required, int page)
+{
+        int ret;
+        marvell_nfc_enable_hw_ecc(chip);
+        ret = marvell_nfc_hw_ecc_hmg_do_write_page(chip, buf, chip->oob_poi,
+                                                   false, page);
+        marvell_nfc_disable_hw_ecc(chip);
+        return ret;
+}
+/*
+ * Spare area in Hamming layouts is not protected by the ECC engine (even if
+ * it appears before the ECC bytes when reading), the ->write_oob_raw() function
+ * also stands for ->write_oob().
+ */
+static int marvell_nfc_hw_ecc_hmg_write_oob_raw(struct mtd_info *mtd,
+                                                struct nand_chip *chip,
+                                                int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        memset(chip->data_buf, 0xFF, mtd->writesize);
+        return marvell_nfc_hw_ecc_hmg_do_write_page(chip, chip->data_buf,
+                                                    chip->oob_poi, true, page);
+}
+/* BCH read helpers */
+static int marvell_nfc_hw_ecc_bch_read_page_raw(struct mtd_info *mtd,
+                                                struct nand_chip *chip, u8 *buf,
+                                                int oob_required, int page)
+{
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        u8 *oob = chip->oob_poi;
+        int chunk_size = lt->data_bytes + lt->spare_bytes + lt->ecc_bytes;
+        int ecc_offset = (lt->full_chunk_cnt * lt->spare_bytes) +
+                lt->last_spare_bytes;
+        int data_len = lt->data_bytes;
+        int spare_len = lt->spare_bytes;
+        int ecc_len = lt->ecc_bytes;
+        int chunk;
+        if (oob_required)
+                memset(chip->oob_poi, 0xFF, mtd->oobsize);
+        nand_read_page_op(chip, page, 0, NULL, 0);
+        for (chunk = 0; chunk < lt->nchunks; chunk++) {
+                /* Update last chunk length */
+                if (chunk >= lt->full_chunk_cnt) {
+                        data_len = lt->last_data_bytes;
+                        spare_len = lt->last_spare_bytes;
+                        ecc_len = lt->last_ecc_bytes;
+                }
+                /* Read data bytes*/
+                nand_change_read_column_op(chip, chunk * chunk_size,
+                                           buf + (lt->data_bytes * chunk),
+                                           data_len, false);
+                /* Read spare bytes */
+                nand_read_data_op(chip, oob + (lt->spare_bytes * chunk),
+                                  spare_len, false);
+                /* Read ECC bytes */
+                nand_read_data_op(chip, oob + ecc_offset +
+                                  (ALIGN(lt->ecc_bytes, 32) * chunk),
+                                  ecc_len, false);
+        }
+        return 0;
+}
+static void marvell_nfc_hw_ecc_bch_read_chunk(struct nand_chip *chip, int chunk,
+                                              u8 *data, unsigned int data_len,
+                                              u8 *spare, unsigned int spare_len,
+                                              int page)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        int i, ret;
+        struct marvell_nfc_op nfc_op = {
+                .ndcb[0] = NDCB0_CMD_TYPE(TYPE_READ) |
+                           NDCB0_ADDR_CYC(marvell_nand->addr_cyc) |
+                           NDCB0_LEN_OVRD,
+                .ndcb[1] = NDCB1_ADDRS_PAGE(page),
+                .ndcb[2] = NDCB2_ADDR5_PAGE(page),
+                .ndcb[3] = data_len + spare_len,
+        };
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return;
+        if (chunk == 0)
+                nfc_op.ndcb[0] |= NDCB0_DBC |
+                                  NDCB0_CMD1(NAND_CMD_READ0) |
+                                  NDCB0_CMD2(NAND_CMD_READSTART);
+        /*
+         * Trigger the naked read operation only on the last chunk.
+         * Otherwise, use monolithic read.
+         */
+        if (lt->nchunks == 1 || (chunk < lt->nchunks - 1))
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_MONOLITHIC_RW);
+        else
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_LAST_NAKED_RW);
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        /*
+         * According to the datasheet, when reading from NDDB
+         * with BCH enabled, after each 32 bytes reads, we
+         * have to make sure that the NDSR.RDDREQ bit is set.
+         *
+         * Drain the FIFO, 8 32-bit reads at a time, and skip
+         * the polling on the last read.
+         *
+         * Length is a multiple of 32 bytes, hence it is a multiple of 8 too.
+         */
+        for (i = 0; i < data_len; i += FIFO_DEPTH * BCH_SEQ_READS) {
+                marvell_nfc_end_cmd(chip, NDSR_RDDREQ,
+                                    "RDDREQ while draining FIFO (data)");
+                marvell_nfc_xfer_data_in_pio(nfc, data,
+                                             FIFO_DEPTH * BCH_SEQ_READS);
+                data += FIFO_DEPTH * BCH_SEQ_READS;
+        }
+        for (i = 0; i < spare_len; i += FIFO_DEPTH * BCH_SEQ_READS) {
+                marvell_nfc_end_cmd(chip, NDSR_RDDREQ,
+                                    "RDDREQ while draining FIFO (OOB)");
+                marvell_nfc_xfer_data_in_pio(nfc, spare,
+                                             FIFO_DEPTH * BCH_SEQ_READS);
+                spare += FIFO_DEPTH * BCH_SEQ_READS;
+        }
+}
+static int marvell_nfc_hw_ecc_bch_read_page(struct mtd_info *mtd,
+                                            struct nand_chip *chip,
+                                            u8 *buf, int oob_required,
+                                            int page)
+{
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        int data_len = lt->data_bytes, spare_len = lt->spare_bytes, ecc_len;
+        u8 *data = buf, *spare = chip->oob_poi, *ecc;
+        int max_bitflips = 0;
+        u32 failure_mask = 0;
+        int chunk, ecc_offset_in_page, ret;
+        /*
+         * With BCH, OOB is not fully used (and thus not read entirely), not
+         * expected bytes could show up at the end of the OOB buffer if not
+         * explicitly erased.
+         */
+        if (oob_required)
+                memset(chip->oob_poi, 0xFF, mtd->oobsize);
+        marvell_nfc_enable_hw_ecc(chip);
+        for (chunk = 0; chunk < lt->nchunks; chunk++) {
+                /* Update length for the last chunk */
+                if (chunk >= lt->full_chunk_cnt) {
+                        data_len = lt->last_data_bytes;
+                        spare_len = lt->last_spare_bytes;
+                }
+                /* Read the chunk and detect number of bitflips */
+                marvell_nfc_hw_ecc_bch_read_chunk(chip, chunk, data, data_len,
+                                                  spare, spare_len, page);
+                ret = marvell_nfc_hw_ecc_correct(chip, &max_bitflips);
+                if (ret)
+                        failure_mask |= BIT(chunk);
+                data += data_len;
+                spare += spare_len;
+        }
+        marvell_nfc_disable_hw_ecc(chip);
+        if (!failure_mask)
+                return max_bitflips;
+        /*
+         * Please note that dumping the ECC bytes during a normal read with OOB
+         * area would add a significant overhead as ECC bytes are "consumed" by
+         * the controller in normal mode and must be re-read in raw mode. To
+         * avoid dropping the performances, we prefer not to include them. The
+         * user should re-read the page in raw mode if ECC bytes are required.
+         *
+         * However, for any subpage read error reported by ->correct(), the ECC
+         * bytes must be read in raw mode and the full subpage must be checked
+         * to see if it is entirely empty of if there was an actual error.
+         */
+        for (chunk = 0; chunk < lt->nchunks; chunk++) {
+                /* No failure reported for this chunk, move to the next one */
+                if (!(failure_mask & BIT(chunk)))
+                        continue;
+                /* Derive ECC bytes positions (in page/buffer) and length */
+                ecc = chip->oob_poi +
+                        (lt->full_chunk_cnt * lt->spare_bytes) +
+                        lt->last_spare_bytes +
+                        (chunk * ALIGN(lt->ecc_bytes, 32));
+                ecc_offset_in_page =
+                        (chunk * (lt->data_bytes + lt->spare_bytes +
+                                  lt->ecc_bytes)) +
+                        (chunk < lt->full_chunk_cnt ?
+                         lt->data_bytes + lt->spare_bytes :
+                         lt->last_data_bytes + lt->last_spare_bytes);
+                ecc_len = chunk < lt->full_chunk_cnt ?
+                        lt->ecc_bytes : lt->last_ecc_bytes;
+                /* Do the actual raw read of the ECC bytes */
+                nand_change_read_column_op(chip, ecc_offset_in_page,
+                                           ecc, ecc_len, false);
+                /* Derive data/spare bytes positions (in buffer) and length */
+                data = buf + (chunk * lt->data_bytes);
+                data_len = chunk < lt->full_chunk_cnt ?
+                        lt->data_bytes : lt->last_data_bytes;
+                spare = chip->oob_poi + (chunk * (lt->spare_bytes +
+                                                  lt->ecc_bytes));
+                spare_len = chunk < lt->full_chunk_cnt ?
+                        lt->spare_bytes : lt->last_spare_bytes;
+                /* Check the entire chunk (data + spare + ecc) for emptyness */
+                marvell_nfc_check_empty_chunk(chip, data, data_len, spare,
+                                              spare_len, ecc, ecc_len,
+                                              &max_bitflips);
+        }
+        return max_bitflips;
+}
+static int marvell_nfc_hw_ecc_bch_read_oob_raw(struct mtd_info *mtd,
+                                               struct nand_chip *chip, int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        return chip->ecc.read_page_raw(mtd, chip, chip->data_buf, true, page);
+}
+static int marvell_nfc_hw_ecc_bch_read_oob(struct mtd_info *mtd,
+                                           struct nand_chip *chip, int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        return chip->ecc.read_page(mtd, chip, chip->data_buf, true, page);
+}
+/* BCH write helpers */
+static int marvell_nfc_hw_ecc_bch_write_page_raw(struct mtd_info *mtd,
+                                                 struct nand_chip *chip,
+                                                 const u8 *buf,
+                                                 int oob_required, int page)
+{
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        int full_chunk_size = lt->data_bytes + lt->spare_bytes + lt->ecc_bytes;
+        int data_len = lt->data_bytes;
+        int spare_len = lt->spare_bytes;
+        int ecc_len = lt->ecc_bytes;
+        int spare_offset = 0;
+        int ecc_offset = (lt->full_chunk_cnt * lt->spare_bytes) +
+                lt->last_spare_bytes;
+        int chunk;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
+        for (chunk = 0; chunk < lt->nchunks; chunk++) {
+                if (chunk >= lt->full_chunk_cnt) {
+                        data_len = lt->last_data_bytes;
+                        spare_len = lt->last_spare_bytes;
+                        ecc_len = lt->last_ecc_bytes;
+                }
+                /* Point to the column of the next chunk */
+                nand_change_write_column_op(chip, chunk * full_chunk_size,
+                                            NULL, 0, false);
+                /* Write the data */
+                nand_write_data_op(chip, buf + (chunk * lt->data_bytes),
+                                   data_len, false);
+                if (!oob_required)
+                        continue;
+                /* Write the spare bytes */
+                if (spare_len)
+                        nand_write_data_op(chip, chip->oob_poi + spare_offset,
+                                           spare_len, false);
+                /* Write the ECC bytes */
+                if (ecc_len)
+                        nand_write_data_op(chip, chip->oob_poi + ecc_offset,
+                                           ecc_len, false);
+                spare_offset += spare_len;
+                ecc_offset += ALIGN(ecc_len, 32);
+        }
+        return nand_prog_page_end_op(chip);
+}
+static int
+marvell_nfc_hw_ecc_bch_write_chunk(struct nand_chip *chip, int chunk,
+                                   const u8 *data, unsigned int data_len,
+                                   const u8 *spare, unsigned int spare_len,
+                                   int page)
+{
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        int ret;
+        struct marvell_nfc_op nfc_op = {
+                .ndcb[0] = NDCB0_CMD_TYPE(TYPE_WRITE) | NDCB0_LEN_OVRD,
+                .ndcb[3] = data_len + spare_len,
+        };
+        /*
+         * First operation dispatches the CMD_SEQIN command, issue the address
+         * cycles and asks for the first chunk of data.
+         * All operations in the middle (if any) will issue a naked write and
+         * also ask for data.
+         * Last operation (if any) asks for the last chunk of data through a
+         * last naked write.
+         */
+        if (chunk == 0) {
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_WRITE_DISPATCH) |
+                                  NDCB0_ADDR_CYC(marvell_nand->addr_cyc) |
+                                  NDCB0_CMD1(NAND_CMD_SEQIN);
+                nfc_op.ndcb[1] |= NDCB1_ADDRS_PAGE(page);
+                nfc_op.ndcb[2] |= NDCB2_ADDR5_PAGE(page);
+        } else if (chunk < lt->nchunks - 1) {
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_NAKED_RW);
+        } else {
+                nfc_op.ndcb[0] |= NDCB0_CMD_XTYPE(XTYPE_LAST_NAKED_RW);
+        }
+        /* Always dispatch the PAGEPROG command on the last chunk */
+        if (chunk == lt->nchunks - 1)
+                nfc_op.ndcb[0] |= NDCB0_CMD2(NAND_CMD_PAGEPROG) | NDCB0_DBC;
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_WRDREQ,
+                                  "WRDREQ while loading FIFO (data)");
+        if (ret)
+                return ret;
+        /* Transfer the contents */
+        iowrite32_rep(nfc->regs + NDDB, data, FIFO_REP(data_len));
+        iowrite32_rep(nfc->regs + NDDB, spare, FIFO_REP(spare_len));
+        return 0;
+}
+static int marvell_nfc_hw_ecc_bch_write_page(struct mtd_info *mtd,
+                                             struct nand_chip *chip,
+                                             const u8 *buf,
+                                             int oob_required, int page)
+{
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        const u8 *data = buf;
+        const u8 *spare = chip->oob_poi;
+        int data_len = lt->data_bytes;
+        int spare_len = lt->spare_bytes;
+        int chunk, ret;
+        /* Spare data will be written anyway, so clear it to avoid garbage */
+        if (!oob_required)
+                memset(chip->oob_poi, 0xFF, mtd->oobsize);
+        marvell_nfc_enable_hw_ecc(chip);
+        for (chunk = 0; chunk < lt->nchunks; chunk++) {
+                if (chunk >= lt->full_chunk_cnt) {
+                        data_len = lt->last_data_bytes;
+                        spare_len = lt->last_spare_bytes;
+                }
+                marvell_nfc_hw_ecc_bch_write_chunk(chip, chunk, data, data_len,
+                                                   spare, spare_len, page);
+                data += data_len;
+                spare += spare_len;
+                /*
+                 * Waiting only for CMDD or PAGED is not enough, ECC are
+                 * partially written. No flag is set once the operation is
+                 * really finished but the ND_RUN bit is cleared, so wait for it
+                 * before stepping into the next command.
+                 */
+                marvell_nfc_wait_ndrun(chip);
+        }
+        ret = marvell_nfc_wait_op(chip,
+                                  chip->data_interface.timings.sdr.tPROG_max);
+        marvell_nfc_disable_hw_ecc(chip);
+        if (ret)
+                return ret;
+        return 0;
+}
+static int marvell_nfc_hw_ecc_bch_write_oob_raw(struct mtd_info *mtd,
+                                                struct nand_chip *chip,
+                                                int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        memset(chip->data_buf, 0xFF, mtd->writesize);
+        return chip->ecc.write_page_raw(mtd, chip, chip->data_buf, true, page);
+}
+static int marvell_nfc_hw_ecc_bch_write_oob(struct mtd_info *mtd,
+                                            struct nand_chip *chip, int page)
+{
+        /* Invalidate page cache */
+        chip->pagebuf = -1;
+        memset(chip->data_buf, 0xFF, mtd->writesize);
+        return chip->ecc.write_page(mtd, chip, chip->data_buf, true, page);
+}
+/* NAND framework ->exec_op() hooks and related helpers */
+static void marvell_nfc_parse_instructions(struct nand_chip *chip,
+                                           const struct nand_subop *subop,
+                                           struct marvell_nfc_op *nfc_op)
+{
+        const struct nand_op_instr *instr = NULL;
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        bool first_cmd = true;
+        unsigned int op_id;
+        int i;
+        /* Reset the input structure as most of its fields will be OR'ed */
+        memset(nfc_op, 0, sizeof(struct marvell_nfc_op));
+        for (op_id = 0; op_id < subop->ninstrs; op_id++) {
+                unsigned int offset, naddrs;
+                const u8 *addrs;
+                int len = nand_subop_get_data_len(subop, op_id);
+                instr = &subop->instrs[op_id];
+                switch (instr->type) {
+                case NAND_OP_CMD_INSTR:
+                        if (first_cmd)
+                                nfc_op->ndcb[0] |=
+                                        NDCB0_CMD1(instr->ctx.cmd.opcode);
+                        else
+                                nfc_op->ndcb[0] |=
+                                        NDCB0_CMD2(instr->ctx.cmd.opcode) |
+                                        NDCB0_DBC;
+                        nfc_op->cle_ale_delay_ns = instr->delay_ns;
+                        first_cmd = false;
+                        break;
+                case NAND_OP_ADDR_INSTR:
+                        offset = nand_subop_get_addr_start_off(subop, op_id);
+                        naddrs = nand_subop_get_num_addr_cyc(subop, op_id);
+                        addrs = &instr->ctx.addr.addrs[offset];
+                        nfc_op->ndcb[0] |= NDCB0_ADDR_CYC(naddrs);
+                        for (i = 0; i < min_t(unsigned int, 4, naddrs); i++)
+                                nfc_op->ndcb[1] |= addrs[i] << (8 * i);
+                        if (naddrs >= 5)
+                                nfc_op->ndcb[2] |= NDCB2_ADDR5_CYC(addrs[4]);
+                        if (naddrs >= 6)
+                                nfc_op->ndcb[3] |= NDCB3_ADDR6_CYC(addrs[5]);
+                        if (naddrs == 7)
+                                nfc_op->ndcb[3] |= NDCB3_ADDR7_CYC(addrs[6]);
+                        nfc_op->cle_ale_delay_ns = instr->delay_ns;
+                        break;
+                case NAND_OP_DATA_IN_INSTR:
+                        nfc_op->data_instr = instr;
+                        nfc_op->data_instr_idx = op_id;
+                        nfc_op->ndcb[0] |= NDCB0_CMD_TYPE(TYPE_READ);
+                        if (nfc->caps->is_nfcv2) {
+                                nfc_op->ndcb[0] |=
+                                        NDCB0_CMD_XTYPE(XTYPE_MONOLITHIC_RW) |
+                                        NDCB0_LEN_OVRD;
+                                nfc_op->ndcb[3] |= round_up(len, FIFO_DEPTH);
+                        }
+                        nfc_op->data_delay_ns = instr->delay_ns;
+                        break;
+                case NAND_OP_DATA_OUT_INSTR:
+                        nfc_op->data_instr = instr;
+                        nfc_op->data_instr_idx = op_id;
+                        nfc_op->ndcb[0] |= NDCB0_CMD_TYPE(TYPE_WRITE);
+                        if (nfc->caps->is_nfcv2) {
+                                nfc_op->ndcb[0] |=
+                                        NDCB0_CMD_XTYPE(XTYPE_MONOLITHIC_RW) |
+                                        NDCB0_LEN_OVRD;
+                                nfc_op->ndcb[3] |= round_up(len, FIFO_DEPTH);
+                        }
+                        nfc_op->data_delay_ns = instr->delay_ns;
+                        break;
+                case NAND_OP_WAITRDY_INSTR:
+                        nfc_op->rdy_timeout_ms = instr->ctx.waitrdy.timeout_ms;
+                        nfc_op->rdy_delay_ns = instr->delay_ns;
+                        break;
+                }
+        }
+}
+static int marvell_nfc_xfer_data_pio(struct nand_chip *chip,
+                                     const struct nand_subop *subop,
+                                     struct marvell_nfc_op *nfc_op)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct nand_op_instr *instr = nfc_op->data_instr;
+        unsigned int op_id = nfc_op->data_instr_idx;
+        unsigned int len = nand_subop_get_data_len(subop, op_id);
+        unsigned int offset = nand_subop_get_data_start_off(subop, op_id);
+        bool reading = (instr->type == NAND_OP_DATA_IN_INSTR);
+        int ret;
+        if (instr->ctx.data.force_8bit)
+                marvell_nfc_force_byte_access(chip, true);
+        if (reading) {
+                u8 *in = instr->ctx.data.buf.in + offset;
+                ret = marvell_nfc_xfer_data_in_pio(nfc, in, len);
+        } else {
+                const u8 *out = instr->ctx.data.buf.out + offset;
+                ret = marvell_nfc_xfer_data_out_pio(nfc, out, len);
+        }
+        if (instr->ctx.data.force_8bit)
+                marvell_nfc_force_byte_access(chip, false);
+        return ret;
+}
+static int marvell_nfc_monolithic_access_exec(struct nand_chip *chip,
+                                              const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        bool reading;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        reading = (nfc_op.data_instr->type == NAND_OP_DATA_IN_INSTR);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_RDDREQ | NDSR_WRDREQ,
+                                  "RDDREQ/WRDREQ while draining raw data");
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.cle_ale_delay_ns);
+        if (reading) {
+                if (nfc_op.rdy_timeout_ms) {
+                        ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+                        if (ret)
+                                return ret;
+                }
+                cond_delay(nfc_op.rdy_delay_ns);
+        }
+        marvell_nfc_xfer_data_pio(chip, subop, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.data_delay_ns);
+        if (!reading) {
+                if (nfc_op.rdy_timeout_ms) {
+                        ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+                        if (ret)
+                                return ret;
+                }
+                cond_delay(nfc_op.rdy_delay_ns);
+        }
+        /*
+         * NDCR ND_RUN bit should be cleared automatically at the end of each
+         * operation but experience shows that the behavior is buggy when it
+         * comes to writes (with LEN_OVRD). Clear it by hand in this case.
+         */
+        if (!reading) {
+                struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+                writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,
+                               nfc->regs + NDCR);
+        }
+        return 0;
+}
+static int marvell_nfc_naked_access_exec(struct nand_chip *chip,
+                                         const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        /*
+         * Naked access are different in that they need to be flagged as naked
+         * by the controller. Reset the controller registers fields that inform
+         * on the type and refill them according to the ongoing operation.
+         */
+        nfc_op.ndcb[0] &= ~(NDCB0_CMD_TYPE(TYPE_MASK) |
+                            NDCB0_CMD_XTYPE(XTYPE_MASK));
+        switch (subop->instrs[0].type) {
+        case NAND_OP_CMD_INSTR:
+                nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_NAKED_CMD);
+                break;
+        case NAND_OP_ADDR_INSTR:
+                nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_NAKED_ADDR);
+                break;
+        case NAND_OP_DATA_IN_INSTR:
+                nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_READ) |
+                                  NDCB0_CMD_XTYPE(XTYPE_LAST_NAKED_RW);
+                break;
+        case NAND_OP_DATA_OUT_INSTR:
+                nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_WRITE) |
+                                  NDCB0_CMD_XTYPE(XTYPE_LAST_NAKED_RW);
+                break;
+        default:
+                /* This should never happen */
+                break;
+        }
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        if (!nfc_op.data_instr) {
+                ret = marvell_nfc_wait_cmdd(chip);
+                cond_delay(nfc_op.cle_ale_delay_ns);
+                return ret;
+        }
+        ret = marvell_nfc_end_cmd(chip, NDSR_RDDREQ | NDSR_WRDREQ,
+                                  "RDDREQ/WRDREQ while draining raw data");
+        if (ret)
+                return ret;
+        marvell_nfc_xfer_data_pio(chip, subop, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        /*
+         * NDCR ND_RUN bit should be cleared automatically at the end of each
+         * operation but experience shows that the behavior is buggy when it
+         * comes to writes (with LEN_OVRD). Clear it by hand in this case.
+         */
+        if (subop->instrs[0].type == NAND_OP_DATA_OUT_INSTR) {
+                struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+                writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,
+                               nfc->regs + NDCR);
+        }
+        return 0;
+}
+static int marvell_nfc_naked_waitrdy_exec(struct nand_chip *chip,
+                                          const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+        cond_delay(nfc_op.rdy_delay_ns);
+        return ret;
+}
+static int marvell_nfc_read_id_type_exec(struct nand_chip *chip,
+                                         const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        nfc_op.ndcb[0] &= ~NDCB0_CMD_TYPE(TYPE_READ);
+        nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_READ_ID);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_RDDREQ,
+                                  "RDDREQ while reading ID");
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.cle_ale_delay_ns);
+        if (nfc_op.rdy_timeout_ms) {
+                ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+                if (ret)
+                        return ret;
+        }
+        cond_delay(nfc_op.rdy_delay_ns);
+        marvell_nfc_xfer_data_pio(chip, subop, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.data_delay_ns);
+        return 0;
+}
+static int marvell_nfc_read_status_exec(struct nand_chip *chip,
+                                        const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        nfc_op.ndcb[0] &= ~NDCB0_CMD_TYPE(TYPE_READ);
+        nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_STATUS);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_end_cmd(chip, NDSR_RDDREQ,
+                                  "RDDREQ while reading status");
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.cle_ale_delay_ns);
+        if (nfc_op.rdy_timeout_ms) {
+                ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+                if (ret)
+                        return ret;
+        }
+        cond_delay(nfc_op.rdy_delay_ns);
+        marvell_nfc_xfer_data_pio(chip, subop, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.data_delay_ns);
+        return 0;
+}
+static int marvell_nfc_reset_cmd_type_exec(struct nand_chip *chip,
+                                           const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_RESET);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.cle_ale_delay_ns);
+        ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.rdy_delay_ns);
+        return 0;
+}
+static int marvell_nfc_erase_cmd_type_exec(struct nand_chip *chip,
+                                           const struct nand_subop *subop)
+{
+        struct marvell_nfc_op nfc_op;
+        int ret;
+        marvell_nfc_parse_instructions(chip, subop, &nfc_op);
+        nfc_op.ndcb[0] |= NDCB0_CMD_TYPE(TYPE_ERASE);
+        ret = marvell_nfc_prepare_cmd(chip);
+        if (ret)
+                return ret;
+        marvell_nfc_send_cmd(chip, &nfc_op);
+        ret = marvell_nfc_wait_cmdd(chip);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.cle_ale_delay_ns);
+        ret = marvell_nfc_wait_op(chip, nfc_op.rdy_timeout_ms);
+        if (ret)
+                return ret;
+        cond_delay(nfc_op.rdy_delay_ns);
+        return 0;
+}
+static const struct nand_op_parser marvell_nfcv2_op_parser = NAND_OP_PARSER(
+        /* Monolithic reads/writes */
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_monolithic_access_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_ADDR_ELEM(true, MAX_ADDRESS_CYC_NFCV2),
+                NAND_OP_PARSER_PAT_CMD_ELEM(true),
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(true),
+                NAND_OP_PARSER_PAT_DATA_IN_ELEM(false, MAX_CHUNK_SIZE)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_monolithic_access_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ADDRESS_CYC_NFCV2),
+                NAND_OP_PARSER_PAT_DATA_OUT_ELEM(false, MAX_CHUNK_SIZE),
+                NAND_OP_PARSER_PAT_CMD_ELEM(true),
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(true)),
+        /* Naked commands */
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_access_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_access_exec,
+                NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ADDRESS_CYC_NFCV2)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_access_exec,
+                NAND_OP_PARSER_PAT_DATA_IN_ELEM(false, MAX_CHUNK_SIZE)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_access_exec,
+                NAND_OP_PARSER_PAT_DATA_OUT_ELEM(false, MAX_CHUNK_SIZE)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_waitrdy_exec,
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)),
+        );
+static const struct nand_op_parser marvell_nfcv1_op_parser = NAND_OP_PARSER(
+        /* Naked commands not supported, use a function for each pattern */
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_read_id_type_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ADDRESS_CYC_NFCV1),
+                NAND_OP_PARSER_PAT_DATA_IN_ELEM(false, 8)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_erase_cmd_type_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_ADDR_ELEM(false, MAX_ADDRESS_CYC_NFCV1),
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_read_status_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_DATA_IN_ELEM(false, 1)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_reset_cmd_type_exec,
+                NAND_OP_PARSER_PAT_CMD_ELEM(false),
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)),
+        NAND_OP_PARSER_PATTERN(
+                marvell_nfc_naked_waitrdy_exec,
+                NAND_OP_PARSER_PAT_WAITRDY_ELEM(false)),
+        );
+static int marvell_nfc_exec_op(struct nand_chip *chip,
+                               const struct nand_operation *op,
+                               bool check_only)
+{
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        if (nfc->caps->is_nfcv2)
+                return nand_op_parser_exec_op(chip, &marvell_nfcv2_op_parser,
+                                              op, check_only);
+        else
+                return nand_op_parser_exec_op(chip, &marvell_nfcv1_op_parser,
+                                              op, check_only);
+}
+/*
+ * Layouts were broken in old pxa3xx_nand driver, these are supposed to be
+ * usable.
+ */
+static int marvell_nand_ooblayout_ecc(struct mtd_info *mtd, int section,
+                                      struct mtd_oob_region *oobregion)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        if (section)
+                return -ERANGE;
+        oobregion->length = (lt->full_chunk_cnt * lt->ecc_bytes) +
+                            lt->last_ecc_bytes;
+        oobregion->offset = mtd->oobsize - oobregion->length;
+        return 0;
+}
+static int marvell_nand_ooblayout_free(struct mtd_info *mtd, int section,
+                                       struct mtd_oob_region *oobregion)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        const struct marvell_hw_ecc_layout *lt = to_marvell_nand(chip)->layout;
+        if (section)
+                return -ERANGE;
+        /*
+         * Bootrom looks in bytes 0 & 5 for bad blocks for the
+         * 4KB page / 4bit BCH combination.
+         */
+        if (mtd->writesize == SZ_4K && lt->data_bytes == SZ_2K)
+                oobregion->offset = 6;
+        else
+                oobregion->offset = 2;
+        oobregion->length = (lt->full_chunk_cnt * lt->spare_bytes) +
+                            lt->last_spare_bytes - oobregion->offset;
+        return 0;
+}
+static const struct mtd_ooblayout_ops marvell_nand_ooblayout_ops = {
+        .ecc = marvell_nand_ooblayout_ecc,
+        .free = marvell_nand_ooblayout_free,
+};
+static int marvell_nand_hw_ecc_ctrl_init(struct mtd_info *mtd,
+                                         struct nand_ecc_ctrl *ecc)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        const struct marvell_hw_ecc_layout *l;
+        int i;
+        if (!nfc->caps->is_nfcv2 &&
+            (mtd->writesize + mtd->oobsize > MAX_CHUNK_SIZE)) {
+                dev_err(nfc->dev,
+                        "NFCv1: writesize (%d) cannot be bigger than a chunk (%d)\n",
+                        mtd->writesize, MAX_CHUNK_SIZE - mtd->oobsize);
+                return -ENOTSUPP;
+        }
+        to_marvell_nand(chip)->layout = NULL;
+        for (i = 0; i < ARRAY_SIZE(marvell_nfc_layouts); i++) {
+                l = &marvell_nfc_layouts[i];
+                if (mtd->writesize == l->writesize &&
+                    ecc->size == l->chunk && ecc->strength == l->strength) {
+                        to_marvell_nand(chip)->layout = l;
+                        break;
+                }
+        }
+        if (!to_marvell_nand(chip)->layout ||
+            (!nfc->caps->is_nfcv2 && ecc->strength > 1)) {
+                dev_err(nfc->dev,
+                        "ECC strength %d at page size %d is not supported\n",
+                        ecc->strength, mtd->writesize);
+                return -ENOTSUPP;
+        }
+        mtd_set_ooblayout(mtd, &marvell_nand_ooblayout_ops);
+        ecc->steps = l->nchunks;
+        ecc->size = l->data_bytes;
+        if (ecc->strength == 1) {
+                chip->ecc.algo = NAND_ECC_HAMMING;
+                ecc->read_page_raw = marvell_nfc_hw_ecc_hmg_read_page_raw;
+                ecc->read_page = marvell_nfc_hw_ecc_hmg_read_page;
+                ecc->read_oob_raw = marvell_nfc_hw_ecc_hmg_read_oob_raw;
+                ecc->read_oob = ecc->read_oob_raw;
+                ecc->write_page_raw = marvell_nfc_hw_ecc_hmg_write_page_raw;
+                ecc->write_page = marvell_nfc_hw_ecc_hmg_write_page;
+                ecc->write_oob_raw = marvell_nfc_hw_ecc_hmg_write_oob_raw;
+                ecc->write_oob = ecc->write_oob_raw;
+        } else {
+                chip->ecc.algo = NAND_ECC_BCH;
+                ecc->strength = 16;
+                ecc->read_page_raw = marvell_nfc_hw_ecc_bch_read_page_raw;
+                ecc->read_page = marvell_nfc_hw_ecc_bch_read_page;
+                ecc->read_oob_raw = marvell_nfc_hw_ecc_bch_read_oob_raw;
+                ecc->read_oob = marvell_nfc_hw_ecc_bch_read_oob;
+                ecc->write_page_raw = marvell_nfc_hw_ecc_bch_write_page_raw;
+                ecc->write_page = marvell_nfc_hw_ecc_bch_write_page;
+                ecc->write_oob_raw = marvell_nfc_hw_ecc_bch_write_oob_raw;
+                ecc->write_oob = marvell_nfc_hw_ecc_bch_write_oob;
+        }
+        return 0;
+}
+static int marvell_nand_ecc_init(struct mtd_info *mtd,
+                                 struct nand_ecc_ctrl *ecc)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        int ret;
+        if (ecc->mode != NAND_ECC_NONE && (!ecc->size || !ecc->strength)) {
+                if (chip->ecc_step_ds && chip->ecc_strength_ds) {
+                        ecc->size = chip->ecc_step_ds;
+                        ecc->strength = chip->ecc_strength_ds;
+                } else {
+                        dev_info(nfc->dev,
+                                 "No minimum ECC strength, using 1b/512B\n");
+                        ecc->size = 512;
+                        ecc->strength = 1;
+                }
+        }
+        switch (ecc->mode) {
+        case NAND_ECC_HW:
+                ret = marvell_nand_hw_ecc_ctrl_init(mtd, ecc);
+                if (ret)
+                        return ret;
+                break;
+        case NAND_ECC_NONE:
+        case NAND_ECC_SOFT:
+                if (!nfc->caps->is_nfcv2 && mtd->writesize != SZ_512 &&
+                    mtd->writesize != SZ_2K) {
+                        dev_err(nfc->dev, "NFCv1 cannot write %d bytes pages\n",
+                                mtd->writesize);
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+static u8 bbt_pattern[] = {'M', 'V', 'B', 'b', 't', '0' };
+static u8 bbt_mirror_pattern[] = {'1', 't', 'b', 'B', 'V', 'M' };
+static struct nand_bbt_descr bbt_main_descr = {
+        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
+                   NAND_BBT_2BIT | NAND_BBT_VERSION,
+        .offs = 8,
+        .len = 6,
+        .veroffs = 14,
+        .maxblocks = 8, /* Last 8 blocks in each chip */
+        .pattern = bbt_pattern
+};
+static struct nand_bbt_descr bbt_mirror_descr = {
+        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE |
+                   NAND_BBT_2BIT | NAND_BBT_VERSION,
+        .offs = 8,
+        .len = 6,
+        .veroffs = 14,
+        .maxblocks = 8, /* Last 8 blocks in each chip */
+        .pattern = bbt_mirror_pattern
+};
+static int marvell_nfc_setup_data_interface(struct mtd_info *mtd, int chipnr,
+                                            const struct nand_data_interface
+                                            *conf)
+{
+        struct nand_chip *chip = mtd_to_nand(mtd);
+        struct marvell_nand_chip *marvell_nand = to_marvell_nand(chip);
+        struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);
+        unsigned int period_ns = 1000000000 / clk_get_rate(nfc->ecc_clk) * 2;
+        const struct nand_sdr_timings *sdr;
+        struct marvell_nfc_timings nfc_tmg;
+        int read_delay;
+        sdr = nand_get_sdr_timings(conf);
+        if (IS_ERR(sdr))
+                return PTR_ERR(sdr);
+        /*
+         * SDR timings are given in pico-seconds while NFC timings must be
+         * expressed in NAND controller clock cycles, which is half of the
+         * frequency of the accessible ECC clock retrieved by clk_get_rate().
+         * This is not written anywhere in the datasheet but was observed
+         * with an oscilloscope.
+         *
+         * NFC datasheet gives equations from which thoses calculations
+         * are derived, they tend to be slightly more restrictives than the
+         * given core timings and may improve the overall speed.
+         */
+        nfc_tmg.tRP = TO_CYCLES(DIV_ROUND_UP(sdr->tRC_min, 2), period_ns) - 1;
+        nfc_tmg.tRH = nfc_tmg.tRP;
+        nfc_tmg.tWP = TO_CYCLES(DIV_ROUND_UP(sdr->tWC_min, 2), period_ns) - 1;
+        nfc_tmg.tWH = nfc_tmg.tWP;
+        nfc_tmg.tCS = TO_CYCLES(sdr->tCS_min, period_ns);
+        nfc_tmg.tCH = TO_CYCLES(sdr->tCH_min, period_ns) - 1;
+        nfc_tmg.tADL = TO_CYCLES(sdr->tADL_min, period_ns);
+        /*
+         * Read delay is the time of propagation from SoC pins to NFC internal
+         * logic. With non-EDO timings, this is MIN_RD_DEL_CNT clock cycles. In
+         * EDO mode, an additional delay of tRH must be taken into account so
+         * the data is sampled on the falling edge instead of the rising edge.
+         */
+        read_delay = sdr->tRC_min >= 30000 ?
+                MIN_RD_DEL_CNT : MIN_RD_DEL_CNT + nfc_tmg.tRH;
+        nfc_tmg.tAR = TO_CYCLES(sdr->tAR_min, period_ns);
+        /*
+         * tWHR and tRHW are supposed to be read to write delays (and vice
+         * versa) but in some cases, ie. when doing a change column, they must
+         * be greater than that to be sure tCCS delay is respected.
+         */
+        nfc_tmg.tWHR = TO_CYCLES(max_t(int, sdr->tWHR_min, sdr->tCCS_min),
+                                 period_ns) - 2,
+        nfc_tmg.tRHW = TO_CYCLES(max_t(int, sdr->tRHW_min, sdr->tCCS_min),
+                                 period_ns);
+        /* Use WAIT_MODE (wait for RB line) instead of only relying on delays */
+        nfc_tmg.tR = TO_CYCLES(sdr->tWB_max, period_ns);
+        if (chipnr < 0)
+                return 0;
+        marvell_nand->ndtr0 =
+                NDTR0_TRP(nfc_tmg.tRP) |
+                NDTR0_TRH(nfc_tmg.tRH) |
+                NDTR0_ETRP(nfc_tmg.tRP) |
+                NDTR0_TWP(nfc_tmg.tWP) |
+                NDTR0_TWH(nfc_tmg.tWH) |
+                NDTR0_TCS(nfc_tmg.tCS) |
+                NDTR0_TCH(nfc_tmg.tCH) |
+                NDTR0_RD_CNT_DEL(read_delay) |
+                NDTR0_SELCNTR |
+                NDTR0_TADL(nfc_tmg.tADL);
+        marvell_nand->ndtr1 =
+                NDTR1_TAR(nfc_tmg.tAR) |
+                NDTR1_TWHR(nfc_tmg.tWHR) |
+                NDTR1_TRHW(nfc_tmg.tRHW) |
+                NDTR1_WAIT_MODE |
+                NDTR1_TR(nfc_tmg.tR);
+        return 0;
+}
+static int marvell_nand_chip_init(struct device *dev, struct marvell_nfc *nfc,
+                                  struct device_node *np)
+{
+        struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(dev);
+        struct marvell_nand_chip *marvell_nand;
+        struct mtd_info *mtd;
+        struct nand_chip *chip;
+        int nsels, ret, i;
+        u32 cs, rb;
+        /*
+         * The legacy "num-cs" property indicates the number of CS on the only
+         * chip connected to the controller (legacy bindings does not support
+         * more than one chip). CS are only incremented one by one while the RB
+         * pin is always the #0.
+         *
+         * When not using legacy bindings, a couple of "reg" and "nand-rb"
+         * properties must be filled. For each chip, expressed as a subnode,
+         * "reg" points to the CS lines and "nand-rb" to the RB line.
+         */
+        if (pdata) {
+                nsels = 1;
+        } else if (nfc->caps->legacy_of_bindings &&
+                   !of_get_property(np, "num-cs", &nsels)) {
+                dev_err(dev, "missing num-cs property\n");
+                return -EINVAL;
+        } else if (!of_get_property(np, "reg", &nsels)) {
+                dev_err(dev, "missing reg property\n");
+                return -EINVAL;
+        }
+        if (!pdata)
+                nsels /= sizeof(u32);
+        if (!nsels) {
+                dev_err(dev, "invalid reg property size\n");
+                return -EINVAL;
+        }
+        /* Alloc the nand chip structure */
+        marvell_nand = devm_kzalloc(dev, sizeof(*marvell_nand) +
+                                    (nsels *
+                                     sizeof(struct marvell_nand_chip_sel)),
+                                    GFP_KERNEL);
+        if (!marvell_nand) {
+                dev_err(dev, "could not allocate chip structure\n");
+                return -ENOMEM;
+        }
+        marvell_nand->nsels = nsels;
+        marvell_nand->selected_die = -1;
+        for (i = 0; i < nsels; i++) {
+                if (pdata || nfc->caps->legacy_of_bindings) {
+                        /*
+                         * Legacy bindings use the CS lines in natural
+                         * order (0, 1, ...)
+                         */
+                        cs = i;
+                } else {
+                        /* Retrieve CS id */
+                        ret = of_property_read_u32_index(np, "reg", i, &cs);
+                        if (ret) {
+                                dev_err(dev, "could not retrieve reg property: %d\n",
+                                        ret);
+                                return ret;
+                        }
+                }
+                if (cs >= nfc->caps->max_cs_nb) {
+                        dev_err(dev, "invalid reg value: %u (max CS = %d)\n",
+                                cs, nfc->caps->max_cs_nb);
+                        return -EINVAL;
+                }
+                if (test_and_set_bit(cs, &nfc->assigned_cs)) {
+                        dev_err(dev, "CS %d already assigned\n", cs);
+                        return -EINVAL;
+                }
+                /*
+                 * The cs variable represents the chip select id, which must be
+                 * converted in bit fields for NDCB0 and NDCB2 to select the
+                 * right chip. Unfortunately, due to a lack of information on
+                 * the subject and incoherent documentation, the user should not
+                 * use CS1 and CS3 at all as asserting them is not supported in
+                 * a reliable way (due to multiplexing inside ADDR5 field).
+                 */
+                marvell_nand->sels[i].cs = cs;
+                switch (cs) {
+                case 0:
+                case 2:
+                        marvell_nand->sels[i].ndcb0_csel = 0;
+                        break;
+                case 1:
+                case 3:
+                        marvell_nand->sels[i].ndcb0_csel = NDCB0_CSEL;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                /* Retrieve RB id */
+                if (pdata || nfc->caps->legacy_of_bindings) {
+                        /* Legacy bindings always use RB #0 */
+                        rb = 0;
+                } else {
+                        ret = of_property_read_u32_index(np, "nand-rb", i,
+                                                         &rb);
+                        if (ret) {
+                                dev_err(dev,
+                                        "could not retrieve RB property: %d\n",
+                                        ret);
+                                return ret;
+                        }
+                }
+                if (rb >= nfc->caps->max_rb_nb) {
+                        dev_err(dev, "invalid reg value: %u (max RB = %d)\n",
+                                rb, nfc->caps->max_rb_nb);
+                        return -EINVAL;
+                }
+                marvell_nand->sels[i].rb = rb;
+        }
+        chip = &marvell_nand->chip;
+        chip->controller = &nfc->controller;
+        nand_set_flash_node(chip, np);
+        chip->exec_op = marvell_nfc_exec_op;
+        chip->select_chip = marvell_nfc_select_chip;
+        if (nfc->caps->is_nfcv2 &&
+            !of_property_read_bool(np, "marvell,nand-keep-config"))
+                chip->setup_data_interface = marvell_nfc_setup_data_interface;
+        mtd = nand_to_mtd(chip);
+        mtd->dev.parent = dev;
+        /*
+         * Default to HW ECC engine mode. If the nand-ecc-mode property is given
+         * in the DT node, this entry will be overwritten in nand_scan_ident().
+         */
+        chip->ecc.mode = NAND_ECC_HW;
+        /*
+         * Save a reference value for timing registers before
+         * ->setup_data_interface() is called.
+         */
+        marvell_nand->ndtr0 = readl_relaxed(nfc->regs + NDTR0);
+        marvell_nand->ndtr1 = readl_relaxed(nfc->regs + NDTR1);
+        chip->options |= NAND_BUSWIDTH_AUTO;
+        ret = nand_scan_ident(mtd, marvell_nand->nsels, NULL);
+        if (ret) {
+                dev_err(dev, "could not identify the nand chip\n");
+                return ret;
+        }
+        if (pdata && pdata->flash_bbt)
+                chip->bbt_options |= NAND_BBT_USE_FLASH;
+        if (chip->bbt_options & NAND_BBT_USE_FLASH) {
+                /*
+                 * We'll use a bad block table stored in-flash and don't
+                 * allow writing the bad block marker to the flash.
+                 */
+                chip->bbt_options |= NAND_BBT_NO_OOB_BBM;
+                chip->bbt_td = &bbt_main_descr;
+                chip->bbt_md = &bbt_mirror_descr;
+        }
+        /* Save the chip-specific fields of NDCR */
+        marvell_nand->ndcr = NDCR_PAGE_SZ(mtd->writesize);
+        if (chip->options & NAND_BUSWIDTH_16)
+                marvell_nand->ndcr |= NDCR_DWIDTH_M | NDCR_DWIDTH_C;
+        /*
+         * On small page NANDs, only one cycle is needed to pass the
+         * column address.
+         */
+        if (mtd->writesize <= 512) {
+                marvell_nand->addr_cyc = 1;
+        } else {
+                marvell_nand->addr_cyc = 2;
+                marvell_nand->ndcr |= NDCR_RA_START;
+        }
+        /*
+         * Now add the number of cycles needed to pass the row
+         * address.
+         *
+         * Addressing a chip using CS 2 or 3 should also need the third row
+         * cycle but due to inconsistance in the documentation and lack of
+         * hardware to test this situation, this case is not supported.
+         */
+        if (chip->options & NAND_ROW_ADDR_3)
+                marvell_nand->addr_cyc += 3;
+        else
+                marvell_nand->addr_cyc += 2;
+        if (pdata) {
+                chip->ecc.size = pdata->ecc_step_size;
+                chip->ecc.strength = pdata->ecc_strength;
+        }
+        ret = marvell_nand_ecc_init(mtd, &chip->ecc);
+        if (ret) {
+                dev_err(dev, "ECC init failed: %d\n", ret);
+                return ret;
+        }
+        if (chip->ecc.mode == NAND_ECC_HW) {
+                /*
+                 * Subpage write not available with hardware ECC, prohibit also
+                 * subpage read as in userspace subpage access would still be
+                 * allowed and subpage write, if used, would lead to numerous
+                 * uncorrectable ECC errors.
+                 */
+                chip->options |= NAND_NO_SUBPAGE_WRITE;
+        }
+        if (pdata || nfc->caps->legacy_of_bindings) {
+                /*
+                 * We keep the MTD name unchanged to avoid breaking platforms
+                 * where the MTD cmdline parser is used and the bootloader
+                 * has not been updated to use the new naming scheme.
+                 */
+                mtd->name = "pxa3xx_nand-0";
+        } else if (!mtd->name) {
+                /*
+                 * If the new bindings are used and the bootloader has not been
+                 * updated to pass a new mtdparts parameter on the cmdline, you
+                 * should define the following property in your NAND node, ie:
+                 *
+                 *      label = "main-storage";
+                 *
+                 * This way, mtd->name will be set by the core when
+                 * nand_set_flash_node() is called.
+                 */
+                mtd->name = devm_kasprintf(nfc->dev, GFP_KERNEL,
+                                           "%s:nand.%d", dev_name(nfc->dev),
+                                           marvell_nand->sels[0].cs);
+                if (!mtd->name) {
+                        dev_err(nfc->dev, "Failed to allocate mtd->name\n");
+                        return -ENOMEM;
+                }
+        }
+        ret = nand_scan_tail(mtd);
+        if (ret) {
+                dev_err(dev, "nand_scan_tail failed: %d\n", ret);
+                return ret;
+        }
+        if (pdata)
+                /* Legacy bindings support only one chip */
+                ret = mtd_device_register(mtd, pdata->parts[0],
+                                          pdata->nr_parts[0]);
+        else
+                ret = mtd_device_register(mtd, NULL, 0);
+        if (ret) {
+                dev_err(dev, "failed to register mtd device: %d\n", ret);
+                nand_release(mtd);
+                return ret;
+        }
+        list_add_tail(&marvell_nand->node, &nfc->chips);
+        return 0;
+}
+static int marvell_nand_chips_init(struct device *dev, struct marvell_nfc *nfc)
+{
+        struct device_node *np = dev->of_node;
+        struct device_node *nand_np;
+        int max_cs = nfc->caps->max_cs_nb;
+        int nchips;
+        int ret;
+        if (!np)
+                nchips = 1;
+        else
+                nchips = of_get_child_count(np);
+        if (nchips > max_cs) {
+                dev_err(dev, "too many NAND chips: %d (max = %d CS)\n", nchips,
+                        max_cs);
+                return -EINVAL;
+        }
+        /*
+         * Legacy bindings do not use child nodes to exhibit NAND chip
+         * properties and layout. Instead, NAND properties are mixed with the
+         * controller ones, and partitions are defined as direct subnodes of the
+         * NAND controller node.
+         */
+        if (nfc->caps->legacy_of_bindings) {
+                ret = marvell_nand_chip_init(dev, nfc, np);
+                return ret;
+        }
+        for_each_child_of_node(np, nand_np) {
+                ret = marvell_nand_chip_init(dev, nfc, nand_np);
+                if (ret) {
+                        of_node_put(nand_np);
+                        return ret;
+                }
+        }
+        return 0;
+}
+static void marvell_nand_chips_cleanup(struct marvell_nfc *nfc)
+{
+        struct marvell_nand_chip *entry, *temp;
+        list_for_each_entry_safe(entry, temp, &nfc->chips, node) {
+                nand_release(nand_to_mtd(&entry->chip));
+                list_del(&entry->node);
+        }
+}
+static int marvell_nfc_init_dma(struct marvell_nfc *nfc)
+{
+        struct platform_device *pdev = container_of(nfc->dev,
+                                                    struct platform_device,
+                                                    dev);
+        struct dma_slave_config config = {};
+        struct resource *r;
+        dma_cap_mask_t mask;
+        struct pxad_param param;
+        int ret;
+        if (!IS_ENABLED(CONFIG_PXA_DMA)) {
+                dev_warn(nfc->dev,
+                         "DMA not enabled in configuration\n");
+                return -ENOTSUPP;
+        }
+        ret = dma_set_mask_and_coherent(nfc->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
+        r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (!r) {
+                dev_err(nfc->dev, "No resource defined for data DMA\n");
+                return -ENXIO;
+        }
+        param.drcmr = r->start;
+        param.prio = PXAD_PRIO_LOWEST;
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        nfc->dma_chan =
+                dma_request_slave_channel_compat(mask, pxad_filter_fn,
+                                                 &param, nfc->dev,
+                                                 "data");
+        if (!nfc->dma_chan) {
+                dev_err(nfc->dev,
+                        "Unable to request data DMA channel\n");
+                return -ENODEV;
+        }
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r)
+                return -ENXIO;
+        config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        config.src_addr = r->start + NDDB;
+        config.dst_addr = r->start + NDDB;
+        config.src_maxburst = 32;
+        config.dst_maxburst = 32;
+        ret = dmaengine_slave_config(nfc->dma_chan, &config);
+        if (ret < 0) {
+                dev_err(nfc->dev, "Failed to configure DMA channel\n");
+                return ret;
+        }
+        /*
+         * DMA must act on length multiple of 32 and this length may be
+         * bigger than the destination buffer. Use this buffer instead
+         * for DMA transfers and then copy the desired amount of data to
+         * the provided buffer.
+         */
+        nfc->dma_buf = kmalloc(MAX_CHUNK_SIZE, GFP_KERNEL | GFP_DMA);
+        if (!nfc->dma_buf)
+                return -ENOMEM;
+        nfc->use_dma = true;
+        return 0;
+}
+static int marvell_nfc_init(struct marvell_nfc *nfc)
+{
+        struct device_node *np = nfc->dev->of_node;
+        /*
+         * Some SoCs like A7k/A8k need to enable manually the NAND
+         * controller, gated clocks and reset bits to avoid being bootloader
+         * dependent. This is done through the use of the System Functions
+         * registers.
+         */
+        if (nfc->caps->need_system_controller) {
+                struct regmap *sysctrl_base =
+                        syscon_regmap_lookup_by_phandle(np,
+                                                        "marvell,system-controller");
+                u32 reg;
+                if (IS_ERR(sysctrl_base))
+                        return PTR_ERR(sysctrl_base);
+                reg = GENCONF_SOC_DEVICE_MUX_NFC_EN |
+                      GENCONF_SOC_DEVICE_MUX_ECC_CLK_RST |
+                      GENCONF_SOC_DEVICE_MUX_ECC_CORE_RST |
+                      GENCONF_SOC_DEVICE_MUX_NFC_INT_EN;
+                regmap_write(sysctrl_base, GENCONF_SOC_DEVICE_MUX, reg);
+                regmap_read(sysctrl_base, GENCONF_CLK_GATING_CTRL, &reg);
+                reg |= GENCONF_CLK_GATING_CTRL_ND_GATE;
+                regmap_write(sysctrl_base, GENCONF_CLK_GATING_CTRL, reg);
+                regmap_read(sysctrl_base, GENCONF_ND_CLK_CTRL, &reg);
+                reg |= GENCONF_ND_CLK_CTRL_EN;
+                regmap_write(sysctrl_base, GENCONF_ND_CLK_CTRL, reg);
+        }
+        /* Configure the DMA if appropriate */
+        if (!nfc->caps->is_nfcv2)
+                marvell_nfc_init_dma(nfc);
+        /*
+         * ECC operations and interruptions are only enabled when specifically
+         * needed. ECC shall not be activated in the early stages (fails probe).
+         * Arbiter flag, even if marked as "reserved", must be set (empirical).
+         * SPARE_EN bit must always be set or ECC bytes will not be at the same
+         * offset in the read page and this will fail the protection.
+         */
+        writel_relaxed(NDCR_ALL_INT | NDCR_ND_ARB_EN | NDCR_SPARE_EN |
+                       NDCR_RD_ID_CNT(NFCV1_READID_LEN), nfc->regs + NDCR);
+        writel_relaxed(0xFFFFFFFF, nfc->regs + NDSR);
+        writel_relaxed(0, nfc->regs + NDECCCTRL);
+        return 0;
+}
+static int marvell_nfc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct resource *r;
+        struct marvell_nfc *nfc;
+        int ret;
+        int irq;
+        nfc = devm_kzalloc(&pdev->dev, sizeof(struct marvell_nfc),
+                           GFP_KERNEL);
+        if (!nfc)
+                return -ENOMEM;
+        nfc->dev = dev;
+        nand_hw_control_init(&nfc->controller);
+        INIT_LIST_HEAD(&nfc->chips);
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        nfc->regs = devm_ioremap_resource(dev, r);
+        if (IS_ERR(nfc->regs))
+                return PTR_ERR(nfc->regs);
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(dev, "failed to retrieve irq\n");
+                return irq;
+        }
+        nfc->ecc_clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(nfc->ecc_clk))
+                return PTR_ERR(nfc->ecc_clk);
+        ret = clk_prepare_enable(nfc->ecc_clk);
+        if (ret)
+                return ret;
+        marvell_nfc_disable_int(nfc, NDCR_ALL_INT);
+        marvell_nfc_clear_int(nfc, NDCR_ALL_INT);
+        ret = devm_request_irq(dev, irq, marvell_nfc_isr,
+                               0, "marvell-nfc", nfc);
+        if (ret)
+                goto unprepare_clk;
+        /* Get NAND controller capabilities */
+        if (pdev->id_entry)
+                nfc->caps = (void *)pdev->id_entry->driver_data;
+        else
+                nfc->caps = of_device_get_match_data(&pdev->dev);
+        if (!nfc->caps) {
+                dev_err(dev, "Could not retrieve NFC caps\n");
+                ret = -EINVAL;
+                goto unprepare_clk;
+        }
+        /* Init the controller and then probe the chips */
+        ret = marvell_nfc_init(nfc);
+        if (ret)
+                goto unprepare_clk;
+        platform_set_drvdata(pdev, nfc);
+        ret = marvell_nand_chips_init(dev, nfc);
+        if (ret)
+                goto unprepare_clk;
+        return 0;
+unprepare_clk:
+        clk_disable_unprepare(nfc->ecc_clk);
+        return ret;
+}
+static int marvell_nfc_remove(struct platform_device *pdev)
+{
+        struct marvell_nfc *nfc = platform_get_drvdata(pdev);
+        marvell_nand_chips_cleanup(nfc);
+        if (nfc->use_dma) {
+                dmaengine_terminate_all(nfc->dma_chan);
+                dma_release_channel(nfc->dma_chan);
+        }
+        clk_disable_unprepare(nfc->ecc_clk);
+        return 0;
+}
+static const struct marvell_nfc_caps marvell_armada_8k_nfc_caps = {
+        .max_cs_nb = 4,
+        .max_rb_nb = 2,
+        .need_system_controller = true,
+        .is_nfcv2 = true,
+};
+static const struct marvell_nfc_caps marvell_armada370_nfc_caps = {
+        .max_cs_nb = 4,
+        .max_rb_nb = 2,
+        .is_nfcv2 = true,
+};
+static const struct marvell_nfc_caps marvell_pxa3xx_nfc_caps = {
+        .max_cs_nb = 2,
+        .max_rb_nb = 1,
+        .use_dma = true,
+};
+static const struct marvell_nfc_caps marvell_armada_8k_nfc_legacy_caps = {
+        .max_cs_nb = 4,
+        .max_rb_nb = 2,
+        .need_system_controller = true,
+        .legacy_of_bindings = true,
+        .is_nfcv2 = true,
+};
+static const struct marvell_nfc_caps marvell_armada370_nfc_legacy_caps = {
+        .max_cs_nb = 4,
+        .max_rb_nb = 2,
+        .legacy_of_bindings = true,
+        .is_nfcv2 = true,
+};
+static const struct marvell_nfc_caps marvell_pxa3xx_nfc_legacy_caps = {
+        .max_cs_nb = 2,
+        .max_rb_nb = 1,
+        .legacy_of_bindings = true,
+        .use_dma = true,
+};
+static const struct platform_device_id marvell_nfc_platform_ids[] = {
+        {
+                .name = "pxa3xx-nand",
+                .driver_data = (kernel_ulong_t)&marvell_pxa3xx_nfc_legacy_caps,
+        },
+        { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(platform, marvell_nfc_platform_ids);
+static const struct of_device_id marvell_nfc_of_ids[] = {
+        {
+                .compatible = "marvell,armada-8k-nand-controller",
+                .data = &marvell_armada_8k_nfc_caps,
+        },
+        {
+                .compatible = "marvell,armada370-nand-controller",
+                .data = &marvell_armada370_nfc_caps,
+        },
+        {
+                .compatible = "marvell,pxa3xx-nand-controller",
+                .data = &marvell_pxa3xx_nfc_caps,
+        },
+        /* Support for old/deprecated bindings: */
+        {
+                .compatible = "marvell,armada-8k-nand",
+                .data = &marvell_armada_8k_nfc_legacy_caps,
+        },
+        {
+                .compatible = "marvell,armada370-nand",
+                .data = &marvell_armada370_nfc_legacy_caps,
+        },
+        {
+                .compatible = "marvell,pxa3xx-nand",
+                .data = &marvell_pxa3xx_nfc_legacy_caps,
+        },
+        { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, marvell_nfc_of_ids);
+static struct platform_driver marvell_nfc_driver = {
+        .driver = {
+                .name           = "marvell-nfc",
+                .of_match_table = marvell_nfc_of_ids,
+        },
+        .id_table = marvell_nfc_platform_ids,
+        .probe = marvell_nfc_probe,
+        .remove = marvell_nfc_remove,
+};
+module_platform_driver(marvell_nfc_driver);
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Marvell NAND controller driver");
diff --git a/drivers/mtd/nand/mtk_ecc.c b/drivers/mtd/nand/mtk_ecc.c
index c51d214d169e..40d86a861a70 100644
--- a/drivers/mtd/nand/mtk_ecc.c
+++ b/drivers/mtd/nand/mtk_ecc.c
@@ -34,34 +34,28 @@
 #define ECC_ENCCON              (0x00)
 #define ECC_ENCCNFG             (0x04)
-#define         ECC_MODE_SHIFT          (5)
 #define         ECC_MS_SHIFT            (16)
 #define ECC_ENCDIADDR           (0x08)
 #define ECC_ENCIDLE             (0x0C)
-#define ECC_ENCIRQ_EN           (0x80)
-#define ECC_ENCIRQ_STA          (0x84)
 #define ECC_DECCON              (0x100)
 #define ECC_DECCNFG             (0x104)
 #define         DEC_EMPTY_EN            BIT(31)
 #define         DEC_CNFG_CORRECT        (0x3 << 12)
 #define ECC_DECIDLE             (0x10C)
 #define ECC_DECENUM0            (0x114)
-#define ECC_DECDONE             (0x124)
-#define ECC_DECIRQ_EN           (0x200)
-#define ECC_DECIRQ_STA          (0x204)
 #define ECC_TIMEOUT             (500000)
 #define ECC_IDLE_REG(op)        ((op) == ECC_ENCODE ? ECC_ENCIDLE : ECC_DECIDLE)
 #define ECC_CTL_REG(op)         ((op) == ECC_ENCODE ? ECC_ENCCON : ECC_DECCON)
-#define ECC_IRQ_REG(op)         ((op) == ECC_ENCODE ? \
-                                        ECC_ENCIRQ_EN : ECC_DECIRQ_EN)
 struct mtk_ecc_caps {
        u32 err_mask;
        const u8 *ecc_strength;
+        const u32 *ecc_regs;
        u8 num_ecc_strength;
-        u32 encode_parity_reg0;
+        u8 ecc_mode_shift;
+        u32 parity_bits;
        int pg_irq_sel;
 };
@@ -89,6 +83,46 @@ static const u8 ecc_strength_mt2712[] = {
        40, 44, 48, 52, 56, 60, 68, 72, 80
 };
+static const u8 ecc_strength_mt7622[] = {
+        4, 6, 8, 10, 12, 14, 16
+};
+enum mtk_ecc_regs {
+        ECC_ENCPAR00,
+        ECC_ENCIRQ_EN,
+        ECC_ENCIRQ_STA,
+        ECC_DECDONE,
+        ECC_DECIRQ_EN,
+        ECC_DECIRQ_STA,
+};
+static int mt2701_ecc_regs[] = {
+        [ECC_ENCPAR00] =        0x10,
+        [ECC_ENCIRQ_EN] =       0x80,
+        [ECC_ENCIRQ_STA] =      0x84,
+        [ECC_DECDONE] =         0x124,
+        [ECC_DECIRQ_EN] =       0x200,
+        [ECC_DECIRQ_STA] =      0x204,
+};
+static int mt2712_ecc_regs[] = {
+        [ECC_ENCPAR00] =        0x300,
+        [ECC_ENCIRQ_EN] =       0x80,
+        [ECC_ENCIRQ_STA] =      0x84,
+        [ECC_DECDONE] =         0x124,
+        [ECC_DECIRQ_EN] =       0x200,
+        [ECC_DECIRQ_STA] =      0x204,
+};
+static int mt7622_ecc_regs[] = {
+        [ECC_ENCPAR00] =        0x10,
+        [ECC_ENCIRQ_EN] =       0x30,
+        [ECC_ENCIRQ_STA] =      0x34,
+        [ECC_DECDONE] =         0x11c,
+        [ECC_DECIRQ_EN] =       0x140,
+        [ECC_DECIRQ_STA] =      0x144,
+};
 static inline void mtk_ecc_wait_idle(struct mtk_ecc *ecc,
                                     enum mtk_ecc_operation op)
 {
@@ -107,32 +141,30 @@ static inline void mtk_ecc_wait_idle(struct mtk_ecc *ecc,
 static irqreturn_t mtk_ecc_irq(int irq, void *id)
 {
        struct mtk_ecc *ecc = id;
-        enum mtk_ecc_operation op;
        u32 dec, enc;
-        dec = readw(ecc->regs + ECC_DECIRQ_STA) & ECC_IRQ_EN;
+        dec = readw(ecc->regs + ecc->caps->ecc_regs[ECC_DECIRQ_STA])
+                    & ECC_IRQ_EN;
        if (dec) {
-                op = ECC_DECODE;
+                dec = readw(ecc->regs + ecc->caps->ecc_regs[ECC_DECDONE]);
-                dec = readw(ecc->regs + ECC_DECDONE);
                if (dec & ecc->sectors) {
                        /*
                         * Clear decode IRQ status once again to ensure that
                         * there will be no extra IRQ.
                         */
-                        readw(ecc->regs + ECC_DECIRQ_STA);
+                        readw(ecc->regs + ecc->caps->ecc_regs[ECC_DECIRQ_STA]);
                        ecc->sectors = 0;
                        complete(&ecc->done);
                } else {
                        return IRQ_HANDLED;
                }
        } else {
-                enc = readl(ecc->regs + ECC_ENCIRQ_STA) & ECC_IRQ_EN;
+                enc = readl(ecc->regs + ecc->caps->ecc_regs[ECC_ENCIRQ_STA])
-                if (enc) {
+                      & ECC_IRQ_EN;
-                        op = ECC_ENCODE;
+                if (enc)
                        complete(&ecc->done);
-                } else {
+                else
                        return IRQ_NONE;
-                }
        }
        return IRQ_HANDLED;
@@ -160,7 +192,7 @@ static int mtk_ecc_config(struct mtk_ecc *ecc, struct mtk_ecc_config *config)
                /* configure ECC encoder (in bits) */
                enc_sz = config->len << 3;
-                reg = ecc_bit | (config->mode << ECC_MODE_SHIFT);
+                reg = ecc_bit | (config->mode << ecc->caps->ecc_mode_shift);
                reg |= (enc_sz << ECC_MS_SHIFT);
                writel(reg, ecc->regs + ECC_ENCCNFG);
@@ -171,9 +203,9 @@ static int mtk_ecc_config(struct mtk_ecc *ecc, struct mtk_ecc_config *config)
        } else {
                /* configure ECC decoder (in bits) */
                dec_sz = (config->len << 3) +
-                                        config->strength * ECC_PARITY_BITS;
+                         config->strength * ecc->caps->parity_bits;
-                reg = ecc_bit | (config->mode << ECC_MODE_SHIFT);
+                reg = ecc_bit | (config->mode << ecc->caps->ecc_mode_shift);
                reg |= (dec_sz << ECC_MS_SHIFT) | DEC_CNFG_CORRECT;
                reg |= DEC_EMPTY_EN;
                writel(reg, ecc->regs + ECC_DECCNFG);
@@ -291,7 +323,12 @@ int mtk_ecc_enable(struct mtk_ecc *ecc, struct mtk_ecc_config *config)
                 */
                if (ecc->caps->pg_irq_sel && config->mode == ECC_NFI_MODE)
                        reg_val |= ECC_PG_IRQ_SEL;
-                writew(reg_val, ecc->regs + ECC_IRQ_REG(op));
+                if (op == ECC_ENCODE)
+                        writew(reg_val, ecc->regs +
+                               ecc->caps->ecc_regs[ECC_ENCIRQ_EN]);
+                else
+                        writew(reg_val, ecc->regs +
+                               ecc->caps->ecc_regs[ECC_DECIRQ_EN]);
        }
        writew(ECC_OP_ENABLE, ecc->regs + ECC_CTL_REG(op));
@@ -310,13 +347,17 @@ void mtk_ecc_disable(struct mtk_ecc *ecc)
        /* disable it */
        mtk_ecc_wait_idle(ecc, op);
-        if (op == ECC_DECODE)
+        if (op == ECC_DECODE) {
                /*
                 * Clear decode IRQ status in case there is a timeout to wait
                 * decode IRQ.
                 */
-                readw(ecc->regs + ECC_DECIRQ_STA);
+                readw(ecc->regs + ecc->caps->ecc_regs[ECC_DECDONE]);
-        writew(0, ecc->regs + ECC_IRQ_REG(op));
+                writew(0, ecc->regs + ecc->caps->ecc_regs[ECC_DECIRQ_EN]);
+        } else {
+                writew(0, ecc->regs + ecc->caps->ecc_regs[ECC_ENCIRQ_EN]);
+        }
        writew(ECC_OP_DISABLE, ecc->regs + ECC_CTL_REG(op));
        mutex_unlock(&ecc->lock);
@@ -367,11 +408,11 @@ int mtk_ecc_encode(struct mtk_ecc *ecc, struct mtk_ecc_config *config,
        mtk_ecc_wait_idle(ecc, ECC_ENCODE);
        /* Program ECC bytes to OOB: per sector oob = FDM + ECC + SPARE */
-        len = (config->strength * ECC_PARITY_BITS + 7) >> 3;
+        len = (config->strength * ecc->caps->parity_bits + 7) >> 3;
        /* write the parity bytes generated by the ECC back to temp buffer */
        __ioread32_copy(ecc->eccdata,
-                        ecc->regs + ecc->caps->encode_parity_reg0,
+                        ecc->regs + ecc->caps->ecc_regs[ECC_ENCPAR00],
                        round_up(len, 4));
        /* copy into possibly unaligned OOB region with actual length */
@@ -404,22 +445,42 @@ void mtk_ecc_adjust_strength(struct mtk_ecc *ecc, u32 *p)
 }
 EXPORT_SYMBOL(mtk_ecc_adjust_strength);
+unsigned int mtk_ecc_get_parity_bits(struct mtk_ecc *ecc)
+{
+        return ecc->caps->parity_bits;
+}
+EXPORT_SYMBOL(mtk_ecc_get_parity_bits);
 static const struct mtk_ecc_caps mtk_ecc_caps_mt2701 = {
        .err_mask = 0x3f,
        .ecc_strength = ecc_strength_mt2701,
+        .ecc_regs = mt2701_ecc_regs,
        .num_ecc_strength = 20,
-        .encode_parity_reg0 = 0x10,
+        .ecc_mode_shift = 5,
+        .parity_bits = 14,
        .pg_irq_sel = 0,
 };
 static const struct mtk_ecc_caps mtk_ecc_caps_mt2712 = {
        .err_mask = 0x7f,
        .ecc_strength = ecc_strength_mt2712,
+        .ecc_regs = mt2712_ecc_regs,
        .num_ecc_strength = 23,
-        .encode_parity_reg0 = 0x300,
+        .ecc_mode_shift = 5,
+        .parity_bits = 14,
        .pg_irq_sel = 1,
 };
+static const struct mtk_ecc_caps mtk_ecc_caps_mt7622 = {
+        .err_mask = 0x3f,
+        .ecc_strength = ecc_strength_mt7622,
+        .ecc_regs = mt7622_ecc_regs,
+        .num_ecc_strength = 7,
+        .ecc_mode_shift = 4,
+        .parity_bits = 13,
+        .pg_irq_sel = 0,
+};
 static const struct of_device_id mtk_ecc_dt_match[] = {
        {
                .compatible = "mediatek,mt2701-ecc",
@@ -427,6 +488,9 @@ static const struct of_device_id mtk_ecc_dt_match[] = {
        }, {
                .compatible = "mediatek,mt2712-ecc",
                .data = &mtk_ecc_caps_mt2712,
+        }, {
+                .compatible = "mediatek,mt7622-ecc",
+                .data = &mtk_ecc_caps_mt7622,
        },
        {},
 };
@@ -452,7 +516,7 @@ static int mtk_ecc_probe(struct platform_device *pdev)
        max_eccdata_size = ecc->caps->num_ecc_strength - 1;
        max_eccdata_size = ecc->caps->ecc_strength[max_eccdata_size];
-        max_eccdata_size = (max_eccdata_size * ECC_PARITY_BITS + 7) >> 3;
+        max_eccdata_size = (max_eccdata_size * ecc->caps->parity_bits + 7) >> 3;
        max_eccdata_size = round_up(max_eccdata_size, 4);
        ecc->eccdata = devm_kzalloc(dev, max_eccdata_size, GFP_KERNEL);
        if (!ecc->eccdata)
diff --git a/drivers/mtd/nand/mtk_ecc.h b/drivers/mtd/nand/mtk_ecc.h
index d245c14f1b80..a455df080952 100644
--- a/drivers/mtd/nand/mtk_ecc.h
+++ b/drivers/mtd/nand/mtk_ecc.h
@@ -14,8 +14,6 @@
 #include <linux/types.h>
-#define ECC_PARITY_BITS         (14)
 enum mtk_ecc_mode {ECC_DMA_MODE = 0, ECC_NFI_MODE = 1};
 enum mtk_ecc_operation {ECC_ENCODE, ECC_DECODE};
@@ -43,6 +41,7 @@ int mtk_ecc_wait_done(struct mtk_ecc *, enum mtk_ecc_operation);
 int mtk_ecc_enable(struct mtk_ecc *, struct mtk_ecc_config *);
 void mtk_ecc_disable(struct mtk_ecc *);
 void mtk_ecc_adjust_strength(struct mtk_ecc *ecc, u32 *p);
+unsigned int mtk_ecc_get_parity_bits(struct mtk_ecc *ecc);
 struct mtk_ecc *of_mtk_ecc_get(struct device_node *);
 void mtk_ecc_release(struct mtk_ecc *);
diff --git a/drivers/mtd/nand/mtk_nand.c b/drivers/mtd/nand/mtk_nand.c
index d86a7d131cc0..6977da3a26aa 100644
--- a/drivers/mtd/nand/mtk_nand.c
+++ b/drivers/mtd/nand/mtk_nand.c
@@ -97,7 +97,6 @@
 #define MTK_TIMEOUT             (500000)
 #define MTK_RESET_TIMEOUT       (1000000)
-#define MTK_MAX_SECTOR          (16)
 #define MTK_NAND_MAX_NSELS      (2)
 #define MTK_NFC_MIN_SPARE       (16)
 #define ACCTIMING(tpoecs, tprecs, tc2r, tw2r, twh, twst, trlt) \
@@ -109,6 +108,8 @@ struct mtk_nfc_caps {
        u8 num_spare_size;
        u8 pageformat_spare_shift;
        u8 nfi_clk_div;
+        u8 max_sector;
+        u32 max_sector_size;
 };
 struct mtk_nfc_bad_mark_ctl {
@@ -173,6 +174,10 @@ static const u8 spare_size_mt2712[] = {
        74
 };
+static const u8 spare_size_mt7622[] = {
+        16, 26, 27, 28
+};
 static inline struct mtk_nfc_nand_chip *to_mtk_nand(struct nand_chip *nand)
 {
        return container_of(nand, struct mtk_nfc_nand_chip, nand);
@@ -450,7 +455,7 @@ static inline u8 mtk_nfc_read_byte(struct mtd_info *mtd)
                 * set to max sector to allow the HW to continue reading over
                 * unaligned accesses
                 */
-                reg = (MTK_MAX_SECTOR << CON_SEC_SHIFT) | CON_BRD;
+                reg = (nfc->caps->max_sector << CON_SEC_SHIFT) | CON_BRD;
                nfi_writel(nfc, reg, NFI_CON);
                /* trigger to fetch data */
@@ -481,7 +486,7 @@ static void mtk_nfc_write_byte(struct mtd_info *mtd, u8 byte)
                reg = nfi_readw(nfc, NFI_CNFG) | CNFG_BYTE_RW;
                nfi_writew(nfc, reg, NFI_CNFG);
-                reg = MTK_MAX_SECTOR << CON_SEC_SHIFT | CON_BWR;
+                reg = nfc->caps->max_sector << CON_SEC_SHIFT | CON_BWR;
                nfi_writel(nfc, reg, NFI_CON);
                nfi_writew(nfc, STAR_EN, NFI_STRDATA);
@@ -761,6 +766,8 @@ static int mtk_nfc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        u32 reg;
        int ret;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        if (!raw) {
                /* OOB => FDM: from register,  ECC: from HW */
                reg = nfi_readw(nfc, NFI_CNFG) | CNFG_AUTO_FMT_EN;
@@ -794,7 +801,10 @@ static int mtk_nfc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        if (!raw)
                mtk_ecc_disable(nfc->ecc);
-        return ret;
+        if (ret)
+                return ret;
+        return nand_prog_page_end_op(chip);
 }
 static int mtk_nfc_write_page_hwecc(struct mtd_info *mtd,
@@ -832,18 +842,7 @@ static int mtk_nfc_write_subpage_hwecc(struct mtd_info *mtd,
 static int mtk_nfc_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
                                 int page)
 {
-        int ret;
+        return mtk_nfc_write_page_raw(mtd, chip, NULL, 1, page);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
-        ret = mtk_nfc_write_page_raw(mtd, chip, NULL, 1, page);
-        if (ret < 0)
-                return -EIO;
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        ret = chip->waitfunc(mtd, chip);
-        return ret & NAND_STATUS_FAIL ? -EIO : 0;
 }
 static int mtk_nfc_update_ecc_stats(struct mtd_info *mtd, u8 *buf, u32 sectors)
@@ -892,8 +891,7 @@ static int mtk_nfc_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
        len = sectors * chip->ecc.size + (raw ? sectors * spare : 0);
        buf = bufpoi + start * chip->ecc.size;
-        if (column != 0)
+        nand_read_page_op(chip, page, column, NULL, 0);
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, column, -1);
        addr = dma_map_single(nfc->dev, buf, len, DMA_FROM_DEVICE);
        rc = dma_mapping_error(nfc->dev, addr);
@@ -1016,8 +1014,6 @@ static int mtk_nfc_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
 static int mtk_nfc_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
                                int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
        return mtk_nfc_read_page_raw(mtd, chip, NULL, 1, page);
 }
@@ -1126,9 +1122,11 @@ static void mtk_nfc_set_fdm(struct mtk_nfc_fdm *fdm, struct mtd_info *mtd)
 {
        struct nand_chip *nand = mtd_to_nand(mtd);
        struct mtk_nfc_nand_chip *chip = to_mtk_nand(nand);
+        struct mtk_nfc *nfc = nand_get_controller_data(nand);
        u32 ecc_bytes;
-        ecc_bytes = DIV_ROUND_UP(nand->ecc.strength * ECC_PARITY_BITS, 8);
+        ecc_bytes = DIV_ROUND_UP(nand->ecc.strength *
+                                 mtk_ecc_get_parity_bits(nfc->ecc), 8);
        fdm->reg_size = chip->spare_per_sector - ecc_bytes;
        if (fdm->reg_size > NFI_FDM_MAX_SIZE)
@@ -1208,7 +1206,8 @@ static int mtk_nfc_ecc_init(struct device *dev, struct mtd_info *mtd)
                 * this controller only supports 512 and 1024 sizes
                 */
                if (nand->ecc.size < 1024) {
-                        if (mtd->writesize > 512) {
+                        if (mtd->writesize > 512 &&
+                            nfc->caps->max_sector_size > 512) {
                                nand->ecc.size = 1024;
                                nand->ecc.strength <<= 1;
                        } else {
@@ -1223,7 +1222,8 @@ static int mtk_nfc_ecc_init(struct device *dev, struct mtd_info *mtd)
                        return ret;
                /* calculate oob bytes except ecc parity data */
-                free = ((nand->ecc.strength * ECC_PARITY_BITS) + 7) >> 3;
+                free = (nand->ecc.strength * mtk_ecc_get_parity_bits(nfc->ecc)
+                        + 7) >> 3;
                free = spare - free;
                /*
@@ -1233,10 +1233,12 @@ static int mtk_nfc_ecc_init(struct device *dev, struct mtd_info *mtd)
                 */
                if (free > NFI_FDM_MAX_SIZE) {
                        spare -= NFI_FDM_MAX_SIZE;
-                        nand->ecc.strength = (spare << 3) / ECC_PARITY_BITS;
+                        nand->ecc.strength = (spare << 3) /
+                                             mtk_ecc_get_parity_bits(nfc->ecc);
                } else if (free < 0) {
                        spare -= NFI_FDM_MIN_SIZE;
-                        nand->ecc.strength = (spare << 3) / ECC_PARITY_BITS;
+                        nand->ecc.strength = (spare << 3) /
+                                             mtk_ecc_get_parity_bits(nfc->ecc);
                }
        }
@@ -1389,6 +1391,8 @@ static const struct mtk_nfc_caps mtk_nfc_caps_mt2701 = {
        .num_spare_size = 16,
        .pageformat_spare_shift = 4,
        .nfi_clk_div = 1,
+        .max_sector = 16,
+        .max_sector_size = 1024,
 };
 static const struct mtk_nfc_caps mtk_nfc_caps_mt2712 = {
@@ -1396,6 +1400,17 @@ static const struct mtk_nfc_caps mtk_nfc_caps_mt2712 = {
        .num_spare_size = 19,
        .pageformat_spare_shift = 16,
        .nfi_clk_div = 2,
+        .max_sector = 16,
+        .max_sector_size = 1024,
+};
+static const struct mtk_nfc_caps mtk_nfc_caps_mt7622 = {
+        .spare_size = spare_size_mt7622,
+        .num_spare_size = 4,
+        .pageformat_spare_shift = 4,
+        .nfi_clk_div = 1,
+        .max_sector = 8,
+        .max_sector_size = 512,
 };
 static const struct of_device_id mtk_nfc_id_table[] = {
@@ -1405,6 +1420,9 @@ static const struct of_device_id mtk_nfc_id_table[] = {
        }, {
                .compatible = "mediatek,mt2712-nfc",
                .data = &mtk_nfc_caps_mt2712,
+        }, {
+                .compatible = "mediatek,mt7622-nfc",
+                .data = &mtk_nfc_caps_mt7622,
        },
        {}
 };
@@ -1540,7 +1558,6 @@ static int mtk_nfc_resume(struct device *dev)
        struct mtk_nfc *nfc = dev_get_drvdata(dev);
        struct mtk_nfc_nand_chip *chip;
        struct nand_chip *nand;
-        struct mtd_info *mtd;
        int ret;
        u32 i;
@@ -1553,11 +1570,8 @@ static int mtk_nfc_resume(struct device *dev)
        /* reset NAND chip if VCC was powered off */
        list_for_each_entry(chip, &nfc->chips, node) {
                nand = &chip->nand;
-                mtd = nand_to_mtd(nand);
+                for (i = 0; i < chip->nsels; i++)
-                for (i = 0; i < chip->nsels; i++) {
+                        nand_reset(nand, i);
-                        nand->select_chip(mtd, i);
-                        nand->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
-                }
        }
        return 0;
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index e7ec55b1d368..e70ca16a5118 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -561,14 +561,19 @@ static int nand_block_markbad_lowlevel(struct mtd_info *mtd, loff_t ofs)
 static int nand_check_wp(struct mtd_info *mtd)
 {
        struct nand_chip *chip = mtd_to_nand(mtd);
+        u8 status;
+        int ret;
        /* Broken xD cards report WP despite being writable */
        if (chip->options & NAND_BROKEN_XD)
                return 0;
        /* Check the WP bit */
-        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        ret = nand_status_op(chip, &status);
-        return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
+        if (ret)
+                return ret;
+        return status & NAND_STATUS_WP ? 0 : 1;
 }
 /**
@@ -667,16 +672,83 @@ EXPORT_SYMBOL_GPL(nand_wait_ready);
 static void nand_wait_status_ready(struct mtd_info *mtd, unsigned long timeo)
 {
        register struct nand_chip *chip = mtd_to_nand(mtd);
+        int ret;
        timeo = jiffies + msecs_to_jiffies(timeo);
        do {
-                if ((chip->read_byte(mtd) & NAND_STATUS_READY))
+                u8 status;
+                ret = nand_read_data_op(chip, &status, sizeof(status), true);
+                if (ret)
+                        return;
+                if (status & NAND_STATUS_READY)
                        break;
                touch_softlockup_watchdog();
        } while (time_before(jiffies, timeo));
 };
 /**
+ * nand_soft_waitrdy - Poll STATUS reg until RDY bit is set to 1
+ * @chip: NAND chip structure
+ * @timeout_ms: Timeout in ms
+ *
+ * Poll the STATUS register using ->exec_op() until the RDY bit becomes 1.
+ * If that does not happen whitin the specified timeout, -ETIMEDOUT is
+ * returned.
+ *
+ * This helper is intended to be used when the controller does not have access
+ * to the NAND R/B pin.
+ *
+ * Be aware that calling this helper from an ->exec_op() implementation means
+ * ->exec_op() must be re-entrant.
+ *
+ * Return 0 if the NAND chip is ready, a negative error otherwise.
+ */
+int nand_soft_waitrdy(struct nand_chip *chip, unsigned long timeout_ms)
+{
+        u8 status = 0;
+        int ret;
+        if (!chip->exec_op)
+                return -ENOTSUPP;
+        ret = nand_status_op(chip, NULL);
+        if (ret)
+                return ret;
+        timeout_ms = jiffies + msecs_to_jiffies(timeout_ms);
+        do {
+                ret = nand_read_data_op(chip, &status, sizeof(status), true);
+                if (ret)
+                        break;
+                if (status & NAND_STATUS_READY)
+                        break;
+                /*
+                 * Typical lowest execution time for a tR on most NANDs is 10us,
+                 * use this as polling delay before doing something smarter (ie.
+                 * deriving a delay from the timeout value, timeout_ms/ratio).
+                 */
+                udelay(10);
+        } while (time_before(jiffies, timeout_ms));
+        /*
+         * We have to exit READ_STATUS mode in order to read real data on the
+         * bus in case the WAITRDY instruction is preceding a DATA_IN
+         * instruction.
+         */
+        nand_exit_status_op(chip);
+        if (ret)
+                return ret;
+        return status & NAND_STATUS_READY ? 0 : -ETIMEDOUT;
+};
+EXPORT_SYMBOL_GPL(nand_soft_waitrdy);
+/**
 * nand_command - [DEFAULT] Send command to NAND device
 * @mtd: MTD device structure
 * @command: the command to be sent
@@ -710,7 +782,8 @@ static void nand_command(struct mtd_info *mtd, unsigned int command,
                chip->cmd_ctrl(mtd, readcmd, ctrl);
                ctrl &= ~NAND_CTRL_CHANGE;
        }
-        chip->cmd_ctrl(mtd, command, ctrl);
+        if (command != NAND_CMD_NONE)
+                chip->cmd_ctrl(mtd, command, ctrl);
        /* Address cycle, when necessary */
        ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
@@ -738,6 +811,7 @@ static void nand_command(struct mtd_info *mtd, unsigned int command,
         */
        switch (command) {
+        case NAND_CMD_NONE:
        case NAND_CMD_PAGEPROG:
        case NAND_CMD_ERASE1:
        case NAND_CMD_ERASE2:
@@ -802,8 +876,8 @@ static void nand_ccs_delay(struct nand_chip *chip)
         * Wait tCCS_min if it is correctly defined, otherwise wait 500ns
         * (which should be safe for all NANDs).
         */
-        if (chip->data_interface && chip->data_interface->timings.sdr.tCCS_min)
+        if (chip->setup_data_interface)
-                ndelay(chip->data_interface->timings.sdr.tCCS_min / 1000);
+                ndelay(chip->data_interface.timings.sdr.tCCS_min / 1000);
        else
                ndelay(500);
 }
@@ -831,7 +905,9 @@ static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
        }
        /* Command latch cycle */
-        chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
+        if (command != NAND_CMD_NONE)
+                chip->cmd_ctrl(mtd, command,
+                               NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
        if (column != -1 || page_addr != -1) {
                int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
@@ -866,6 +942,7 @@ static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
         */
        switch (command) {
+        case NAND_CMD_NONE:
        case NAND_CMD_CACHEDPROG:
        case NAND_CMD_PAGEPROG:
        case NAND_CMD_ERASE1:
@@ -1014,7 +1091,15 @@ static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip,
                        if (chip->dev_ready(mtd))
                                break;
                } else {
-                        if (chip->read_byte(mtd) & NAND_STATUS_READY)
+                        int ret;
+                        u8 status;
+                        ret = nand_read_data_op(chip, &status, sizeof(status),
+                                                true);
+                        if (ret)
+                                return;
+                        if (status & NAND_STATUS_READY)
                                break;
                }
                mdelay(1);
@@ -1031,8 +1116,9 @@ static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip,
 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
 {
-        int status;
        unsigned long timeo = 400;
+        u8 status;
+        int ret;
        /*
         * Apply this short delay always to ensure that we do wait tWB in any
@@ -1040,7 +1126,9 @@ static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
         */
        ndelay(100);
-        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        ret = nand_status_op(chip, NULL);
+        if (ret)
+                return ret;
        if (in_interrupt() || oops_in_progress)
                panic_nand_wait(mtd, chip, timeo);
@@ -1051,14 +1139,22 @@ static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
                                if (chip->dev_ready(mtd))
                                        break;
                        } else {
-                                if (chip->read_byte(mtd) & NAND_STATUS_READY)
+                                ret = nand_read_data_op(chip, &status,
+                                                        sizeof(status), true);
+                                if (ret)
+                                        return ret;
+                                if (status & NAND_STATUS_READY)
                                        break;
                        }
                        cond_resched();
                } while (time_before(jiffies, timeo));
        }
-        status = (int)chip->read_byte(mtd);
+        ret = nand_read_data_op(chip, &status, sizeof(status), true);
+        if (ret)
+                return ret;
        /* This can happen if in case of timeout or buggy dev_ready */
        WARN_ON(!(status & NAND_STATUS_READY));
        return status;
@@ -1076,7 +1172,6 @@ static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
 static int nand_reset_data_interface(struct nand_chip *chip, int chipnr)
 {
        struct mtd_info *mtd = nand_to_mtd(chip);
-        const struct nand_data_interface *conf;
        int ret;
        if (!chip->setup_data_interface)
@@ -1096,8 +1191,8 @@ static int nand_reset_data_interface(struct nand_chip *chip, int chipnr)
         * timings to timing mode 0.
         */
-        conf = nand_get_default_data_interface();
+        onfi_fill_data_interface(chip, NAND_SDR_IFACE, 0);
-        ret = chip->setup_data_interface(mtd, chipnr, conf);
+        ret = chip->setup_data_interface(mtd, chipnr, &chip->data_interface);
        if (ret)
                pr_err("Failed to configure data interface to SDR timing mode 0\n");
@@ -1122,7 +1217,7 @@ static int nand_setup_data_interface(struct nand_chip *chip, int chipnr)
        struct mtd_info *mtd = nand_to_mtd(chip);
        int ret;
-        if (!chip->setup_data_interface || !chip->data_interface)
+        if (!chip->setup_data_interface)
                return 0;
        /*
@@ -1143,7 +1238,7 @@ static int nand_setup_data_interface(struct nand_chip *chip, int chipnr)
                        goto err;
        }
-        ret = chip->setup_data_interface(mtd, chipnr, chip->data_interface);
+        ret = chip->setup_data_interface(mtd, chipnr, &chip->data_interface);
 err:
        return ret;
 }
@@ -1183,21 +1278,19 @@ static int nand_init_data_interface(struct nand_chip *chip)
                modes = GENMASK(chip->onfi_timing_mode_default, 0);
        }
-        chip->data_interface = kzalloc(sizeof(*chip->data_interface),
-                                       GFP_KERNEL);
-        if (!chip->data_interface)
-                return -ENOMEM;
        for (mode = fls(modes) - 1; mode >= 0; mode--) {
-                ret = onfi_init_data_interface(chip, chip->data_interface,
+                ret = onfi_fill_data_interface(chip, NAND_SDR_IFACE, mode);
-                                               NAND_SDR_IFACE, mode);
                if (ret)
                        continue;
-                /* Pass -1 to only */
+                /*
+                 * Pass NAND_DATA_IFACE_CHECK_ONLY to only check if the
+                 * controller supports the requested timings.
+                 */
                ret = chip->setup_data_interface(mtd,
                                                 NAND_DATA_IFACE_CHECK_ONLY,
-                                                 chip->data_interface);
+                                                 &chip->data_interface);
                if (!ret) {
                        chip->onfi_timing_mode_default = mode;
                        break;
@@ -1207,21 +1300,1429 @@ static int nand_init_data_interface(struct nand_chip *chip)
        return 0;
 }
-static void nand_release_data_interface(struct nand_chip *chip)
+/**
+ * nand_fill_column_cycles - fill the column cycles of an address
+ * @chip: The NAND chip
+ * @addrs: Array of address cycles to fill
+ * @offset_in_page: The offset in the page
+ *
+ * Fills the first or the first two bytes of the @addrs field depending
+ * on the NAND bus width and the page size.
+ *
+ * Returns the number of cycles needed to encode the column, or a negative
+ * error code in case one of the arguments is invalid.
+ */
+static int nand_fill_column_cycles(struct nand_chip *chip, u8 *addrs,
+                                   unsigned int offset_in_page)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        /* Make sure the offset is less than the actual page size. */
+        if (offset_in_page > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        /*
+         * On small page NANDs, there's a dedicated command to access the OOB
+         * area, and the column address is relative to the start of the OOB
+         * area, not the start of the page. Asjust the address accordingly.
+         */
+        if (mtd->writesize <= 512 && offset_in_page >= mtd->writesize)
+                offset_in_page -= mtd->writesize;
+        /*
+         * The offset in page is expressed in bytes, if the NAND bus is 16-bit
+         * wide, then it must be divided by 2.
+         */
+        if (chip->options & NAND_BUSWIDTH_16) {
+                if (WARN_ON(offset_in_page % 2))
+                        return -EINVAL;
+                offset_in_page /= 2;
+        }
+        addrs[0] = offset_in_page;
+        /*
+         * Small page NANDs use 1 cycle for the columns, while large page NANDs
+         * need 2
+         */
+        if (mtd->writesize <= 512)
+                return 1;
+        addrs[1] = offset_in_page >> 8;
+        return 2;
+}
+static int nand_sp_exec_read_page_op(struct nand_chip *chip, unsigned int page,
+                                     unsigned int offset_in_page, void *buf,
+                                     unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        const struct nand_sdr_timings *sdr =
+                nand_get_sdr_timings(&chip->data_interface);
+        u8 addrs[4];
+        struct nand_op_instr instrs[] = {
+                NAND_OP_CMD(NAND_CMD_READ0, 0),
+                NAND_OP_ADDR(3, addrs, PSEC_TO_NSEC(sdr->tWB_max)),
+                NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tR_max),
+                                 PSEC_TO_NSEC(sdr->tRR_min)),
+                NAND_OP_DATA_IN(len, buf, 0),
+        };
+        struct nand_operation op = NAND_OPERATION(instrs);
+        int ret;
+        /* Drop the DATA_IN instruction if len is set to 0. */
+        if (!len)
+                op.ninstrs--;
+        if (offset_in_page >= mtd->writesize)
+                instrs[0].ctx.cmd.opcode = NAND_CMD_READOOB;
+        else if (offset_in_page >= 256 &&
+                 !(chip->options & NAND_BUSWIDTH_16))
+                instrs[0].ctx.cmd.opcode = NAND_CMD_READ1;
+        ret = nand_fill_column_cycles(chip, addrs, offset_in_page);
+        if (ret < 0)
+                return ret;
+        addrs[1] = page;
+        addrs[2] = page >> 8;
+        if (chip->options & NAND_ROW_ADDR_3) {
+                addrs[3] = page >> 16;
+                instrs[1].ctx.addr.naddrs++;
+        }
+        return nand_exec_op(chip, &op);
+}
+static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,
+                                     unsigned int offset_in_page, void *buf,
+                                     unsigned int len)
+{
+        const struct nand_sdr_timings *sdr =
+                nand_get_sdr_timings(&chip->data_interface);
+        u8 addrs[5];
+        struct nand_op_instr instrs[] = {
+                NAND_OP_CMD(NAND_CMD_READ0, 0),
+                NAND_OP_ADDR(4, addrs, 0),
+                NAND_OP_CMD(NAND_CMD_READSTART, PSEC_TO_NSEC(sdr->tWB_max)),
+                NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tR_max),
+                                 PSEC_TO_NSEC(sdr->tRR_min)),
+                NAND_OP_DATA_IN(len, buf, 0),
+        };
+        struct nand_operation op = NAND_OPERATION(instrs);
+        int ret;
+        /* Drop the DATA_IN instruction if len is set to 0. */
+        if (!len)
+                op.ninstrs--;
+        ret = nand_fill_column_cycles(chip, addrs, offset_in_page);
+        if (ret < 0)
+                return ret;
+        addrs[2] = page;
+        addrs[3] = page >> 8;
+        if (chip->options & NAND_ROW_ADDR_3) {
+                addrs[4] = page >> 16;
+                instrs[1].ctx.addr.naddrs++;
+        }
+        return nand_exec_op(chip, &op);
+}
+/**
+ * nand_read_page_op - Do a READ PAGE operation
+ * @chip: The NAND chip
+ * @page: page to read
+ * @offset_in_page: offset within the page
+ * @buf: buffer used to store the data
+ * @len: length of the buffer
+ *
+ * This function issues a READ PAGE operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_read_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, void *buf, unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (len && !buf)
+                return -EINVAL;
+        if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        if (chip->exec_op) {
+                if (mtd->writesize > 512)
+                        return nand_lp_exec_read_page_op(chip, page,
+                                                         offset_in_page, buf,
+                                                         len);
+                return nand_sp_exec_read_page_op(chip, page, offset_in_page,
+                                                 buf, len);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_READ0, offset_in_page, page);
+        if (len)
+                chip->read_buf(mtd, buf, len);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_read_page_op);
+/**
+ * nand_read_param_page_op - Do a READ PARAMETER PAGE operation
+ * @chip: The NAND chip
+ * @page: parameter page to read
+ * @buf: buffer used to store the data
+ * @len: length of the buffer
+ *
+ * This function issues a READ PARAMETER PAGE operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+static int nand_read_param_page_op(struct nand_chip *chip, u8 page, void *buf,
+                                   unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        unsigned int i;
+        u8 *p = buf;
+        if (len && !buf)
+                return -EINVAL;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_PARAM, 0),
+                        NAND_OP_ADDR(1, &page, PSEC_TO_NSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tR_max),
+                                         PSEC_TO_NSEC(sdr->tRR_min)),
+                        NAND_OP_8BIT_DATA_IN(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                /* Drop the DATA_IN instruction if len is set to 0. */
+                if (!len)
+                        op.ninstrs--;
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_PARAM, page, -1);
+        for (i = 0; i < len; i++)
+                p[i] = chip->read_byte(mtd);
+        return 0;
+}
+/**
+ * nand_change_read_column_op - Do a CHANGE READ COLUMN operation
+ * @chip: The NAND chip
+ * @offset_in_page: offset within the page
+ * @buf: buffer used to store the data
+ * @len: length of the buffer
+ * @force_8bit: force 8-bit bus access
+ *
+ * This function issues a CHANGE READ COLUMN operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_change_read_column_op(struct nand_chip *chip,
+                               unsigned int offset_in_page, void *buf,
+                               unsigned int len, bool force_8bit)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (len && !buf)
+                return -EINVAL;
+        if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        /* Small page NANDs do not support column change. */
+        if (mtd->writesize <= 512)
+                return -ENOTSUPP;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                u8 addrs[2] = {};
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_RNDOUT, 0),
+                        NAND_OP_ADDR(2, addrs, 0),
+                        NAND_OP_CMD(NAND_CMD_RNDOUTSTART,
+                                    PSEC_TO_NSEC(sdr->tCCS_min)),
+                        NAND_OP_DATA_IN(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                int ret;
+                ret = nand_fill_column_cycles(chip, addrs, offset_in_page);
+                if (ret < 0)
+                        return ret;
+                /* Drop the DATA_IN instruction if len is set to 0. */
+                if (!len)
+                        op.ninstrs--;
+                instrs[3].ctx.data.force_8bit = force_8bit;
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, offset_in_page, -1);
+        if (len)
+                chip->read_buf(mtd, buf, len);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_change_read_column_op);
+/**
+ * nand_read_oob_op - Do a READ OOB operation
+ * @chip: The NAND chip
+ * @page: page to read
+ * @offset_in_oob: offset within the OOB area
+ * @buf: buffer used to store the data
+ * @len: length of the buffer
+ *
+ * This function issues a READ OOB operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_read_oob_op(struct nand_chip *chip, unsigned int page,
+                     unsigned int offset_in_oob, void *buf, unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (len && !buf)
+                return -EINVAL;
+        if (offset_in_oob + len > mtd->oobsize)
+                return -EINVAL;
+        if (chip->exec_op)
+                return nand_read_page_op(chip, page,
+                                         mtd->writesize + offset_in_oob,
+                                         buf, len);
+        chip->cmdfunc(mtd, NAND_CMD_READOOB, offset_in_oob, page);
+        if (len)
+                chip->read_buf(mtd, buf, len);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_read_oob_op);
+static int nand_exec_prog_page_op(struct nand_chip *chip, unsigned int page,
+                                  unsigned int offset_in_page, const void *buf,
+                                  unsigned int len, bool prog)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        const struct nand_sdr_timings *sdr =
+                nand_get_sdr_timings(&chip->data_interface);
+        u8 addrs[5] = {};
+        struct nand_op_instr instrs[] = {
+                /*
+                 * The first instruction will be dropped if we're dealing
+                 * with a large page NAND and adjusted if we're dealing
+                 * with a small page NAND and the page offset is > 255.
+                 */
+                NAND_OP_CMD(NAND_CMD_READ0, 0),
+                NAND_OP_CMD(NAND_CMD_SEQIN, 0),
+                NAND_OP_ADDR(0, addrs, PSEC_TO_NSEC(sdr->tADL_min)),
+                NAND_OP_DATA_OUT(len, buf, 0),
+                NAND_OP_CMD(NAND_CMD_PAGEPROG, PSEC_TO_NSEC(sdr->tWB_max)),
+                NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tPROG_max), 0),
+        };
+        struct nand_operation op = NAND_OPERATION(instrs);
+        int naddrs = nand_fill_column_cycles(chip, addrs, offset_in_page);
+        int ret;
+        u8 status;
+        if (naddrs < 0)
+                return naddrs;
+        addrs[naddrs++] = page;
+        addrs[naddrs++] = page >> 8;
+        if (chip->options & NAND_ROW_ADDR_3)
+                addrs[naddrs++] = page >> 16;
+        instrs[2].ctx.addr.naddrs = naddrs;
+        /* Drop the last two instructions if we're not programming the page. */
+        if (!prog) {
+                op.ninstrs -= 2;
+                /* Also drop the DATA_OUT instruction if empty. */
+                if (!len)
+                        op.ninstrs--;
+        }
+        if (mtd->writesize <= 512) {
+                /*
+                 * Small pages need some more tweaking: we have to adjust the
+                 * first instruction depending on the page offset we're trying
+                 * to access.
+                 */
+                if (offset_in_page >= mtd->writesize)
+                        instrs[0].ctx.cmd.opcode = NAND_CMD_READOOB;
+                else if (offset_in_page >= 256 &&
+                         !(chip->options & NAND_BUSWIDTH_16))
+                        instrs[0].ctx.cmd.opcode = NAND_CMD_READ1;
+        } else {
+                /*
+                 * Drop the first command if we're dealing with a large page
+                 * NAND.
+                 */
+                op.instrs++;
+                op.ninstrs--;
+        }
+        ret = nand_exec_op(chip, &op);
+        if (!prog || ret)
+                return ret;
+        ret = nand_status_op(chip, &status);
+        if (ret)
+                return ret;
+        return status;
+}
+/**
+ * nand_prog_page_begin_op - starts a PROG PAGE operation
+ * @chip: The NAND chip
+ * @page: page to write
+ * @offset_in_page: offset within the page
+ * @buf: buffer containing the data to write to the page
+ * @len: length of the buffer
+ *
+ * This function issues the first half of a PROG PAGE operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_prog_page_begin_op(struct nand_chip *chip, unsigned int page,
+                            unsigned int offset_in_page, const void *buf,
+                            unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (len && !buf)
+                return -EINVAL;
+        if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        if (chip->exec_op)
+                return nand_exec_prog_page_op(chip, page, offset_in_page, buf,
+                                              len, false);
+        chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page);
+        if (buf)
+                chip->write_buf(mtd, buf, len);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_prog_page_begin_op);
+/**
+ * nand_prog_page_end_op - ends a PROG PAGE operation
+ * @chip: The NAND chip
+ *
+ * This function issues the second half of a PROG PAGE operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_prog_page_end_op(struct nand_chip *chip)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        int ret;
+        u8 status;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_PAGEPROG,
+                                    PSEC_TO_NSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tPROG_max), 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                ret = nand_exec_op(chip, &op);
+                if (ret)
+                        return ret;
+                ret = nand_status_op(chip, &status);
+                if (ret)
+                        return ret;
+        } else {
+                chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+                ret = chip->waitfunc(mtd, chip);
+                if (ret < 0)
+                        return ret;
+                status = ret;
+        }
+        if (status & NAND_STATUS_FAIL)
+                return -EIO;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_prog_page_end_op);
+/**
+ * nand_prog_page_op - Do a full PROG PAGE operation
+ * @chip: The NAND chip
+ * @page: page to write
+ * @offset_in_page: offset within the page
+ * @buf: buffer containing the data to write to the page
+ * @len: length of the buffer
+ *
+ * This function issues a full PROG PAGE operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_prog_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, const void *buf,
+                      unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        int status;
+        if (!len || !buf)
+                return -EINVAL;
+        if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        if (chip->exec_op) {
+                status = nand_exec_prog_page_op(chip, page, offset_in_page, buf,
+                                                len, true);
+        } else {
+                chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page);
+                chip->write_buf(mtd, buf, len);
+                chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+                status = chip->waitfunc(mtd, chip);
+        }
+        if (status & NAND_STATUS_FAIL)
+                return -EIO;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_prog_page_op);
+/**
+ * nand_change_write_column_op - Do a CHANGE WRITE COLUMN operation
+ * @chip: The NAND chip
+ * @offset_in_page: offset within the page
+ * @buf: buffer containing the data to send to the NAND
+ * @len: length of the buffer
+ * @force_8bit: force 8-bit bus access
+ *
+ * This function issues a CHANGE WRITE COLUMN operation.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_change_write_column_op(struct nand_chip *chip,
+                                unsigned int offset_in_page,
+                                const void *buf, unsigned int len,
+                                bool force_8bit)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (len && !buf)
+                return -EINVAL;
+        if (offset_in_page + len > mtd->writesize + mtd->oobsize)
+                return -EINVAL;
+        /* Small page NANDs do not support column change. */
+        if (mtd->writesize <= 512)
+                return -ENOTSUPP;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                u8 addrs[2];
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_RNDIN, 0),
+                        NAND_OP_ADDR(2, addrs, PSEC_TO_NSEC(sdr->tCCS_min)),
+                        NAND_OP_DATA_OUT(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                int ret;
+                ret = nand_fill_column_cycles(chip, addrs, offset_in_page);
+                if (ret < 0)
+                        return ret;
+                instrs[2].ctx.data.force_8bit = force_8bit;
+                /* Drop the DATA_OUT instruction if len is set to 0. */
+                if (!len)
+                        op.ninstrs--;
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_RNDIN, offset_in_page, -1);
+        if (len)
+                chip->write_buf(mtd, buf, len);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_change_write_column_op);
+/**
+ * nand_readid_op - Do a READID operation
+ * @chip: The NAND chip
+ * @addr: address cycle to pass after the READID command
+ * @buf: buffer used to store the ID
+ * @len: length of the buffer
+ *
+ * This function sends a READID command and reads back the ID returned by the
+ * NAND.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_readid_op(struct nand_chip *chip, u8 addr, void *buf,
+                   unsigned int len)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        unsigned int i;
+        u8 *id = buf;
+        if (len && !buf)
+                return -EINVAL;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_READID, 0),
+                        NAND_OP_ADDR(1, &addr, PSEC_TO_NSEC(sdr->tADL_min)),
+                        NAND_OP_8BIT_DATA_IN(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                /* Drop the DATA_IN instruction if len is set to 0. */
+                if (!len)
+                        op.ninstrs--;
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_READID, addr, -1);
+        for (i = 0; i < len; i++)
+                id[i] = chip->read_byte(mtd);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_readid_op);
+/**
+ * nand_status_op - Do a STATUS operation
+ * @chip: The NAND chip
+ * @status: out variable to store the NAND status
+ *
+ * This function sends a STATUS command and reads back the status returned by
+ * the NAND.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_status_op(struct nand_chip *chip, u8 *status)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_STATUS,
+                                    PSEC_TO_NSEC(sdr->tADL_min)),
+                        NAND_OP_8BIT_DATA_IN(1, status, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                if (!status)
+                        op.ninstrs--;
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        if (status)
+                *status = chip->read_byte(mtd);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_status_op);
+/**
+ * nand_exit_status_op - Exit a STATUS operation
+ * @chip: The NAND chip
+ *
+ * This function sends a READ0 command to cancel the effect of the STATUS
+ * command to avoid reading only the status until a new read command is sent.
+ *
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_exit_status_op(struct nand_chip *chip)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (chip->exec_op) {
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_READ0, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_READ0, -1, -1);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_exit_status_op);
+/**
+ * nand_erase_op - Do an erase operation
+ * @chip: The NAND chip
+ * @eraseblock: block to erase
+ *
+ * This function sends an ERASE command and waits for the NAND to be ready
+ * before returning.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        unsigned int page = eraseblock <<
+                            (chip->phys_erase_shift - chip->page_shift);
+        int ret;
+        u8 status;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                u8 addrs[3] = { page, page >> 8, page >> 16 };
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_ERASE1, 0),
+                        NAND_OP_ADDR(2, addrs, 0),
+                        NAND_OP_CMD(NAND_CMD_ERASE2,
+                                    PSEC_TO_MSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tBERS_max), 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                if (chip->options & NAND_ROW_ADDR_3)
+                        instrs[1].ctx.addr.naddrs++;
+                ret = nand_exec_op(chip, &op);
+                if (ret)
+                        return ret;
+                ret = nand_status_op(chip, &status);
+                if (ret)
+                        return ret;
+        } else {
+                chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+                chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
+                ret = chip->waitfunc(mtd, chip);
+                if (ret < 0)
+                        return ret;
+                status = ret;
+        }
+        if (status & NAND_STATUS_FAIL)
+                return -EIO;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_erase_op);
+/**
+ * nand_set_features_op - Do a SET FEATURES operation
+ * @chip: The NAND chip
+ * @feature: feature id
+ * @data: 4 bytes of data
+ *
+ * This function sends a SET FEATURES command and waits for the NAND to be
+ * ready before returning.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+static int nand_set_features_op(struct nand_chip *chip, u8 feature,
+                                const void *data)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        const u8 *params = data;
+        int i, ret;
+        u8 status;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_SET_FEATURES, 0),
+                        NAND_OP_ADDR(1, &feature, PSEC_TO_NSEC(sdr->tADL_min)),
+                        NAND_OP_8BIT_DATA_OUT(ONFI_SUBFEATURE_PARAM_LEN, data,
+                                              PSEC_TO_NSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tFEAT_max), 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                ret = nand_exec_op(chip, &op);
+                if (ret)
+                        return ret;
+                ret = nand_status_op(chip, &status);
+                if (ret)
+                        return ret;
+        } else {
+                chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, feature, -1);
+                for (i = 0; i < ONFI_SUBFEATURE_PARAM_LEN; ++i)
+                        chip->write_byte(mtd, params[i]);
+                ret = chip->waitfunc(mtd, chip);
+                if (ret < 0)
+                        return ret;
+                status = ret;
+        }
+        if (status & NAND_STATUS_FAIL)
+                return -EIO;
+        return 0;
+}
+/**
+ * nand_get_features_op - Do a GET FEATURES operation
+ * @chip: The NAND chip
+ * @feature: feature id
+ * @data: 4 bytes of data
+ *
+ * This function sends a GET FEATURES command and waits for the NAND to be
+ * ready before returning.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+static int nand_get_features_op(struct nand_chip *chip, u8 feature,
+                                void *data)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        u8 *params = data;
+        int i;
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_GET_FEATURES, 0),
+                        NAND_OP_ADDR(1, &feature, PSEC_TO_NSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tFEAT_max),
+                                         PSEC_TO_NSEC(sdr->tRR_min)),
+                        NAND_OP_8BIT_DATA_IN(ONFI_SUBFEATURE_PARAM_LEN,
+                                             data, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, feature, -1);
+        for (i = 0; i < ONFI_SUBFEATURE_PARAM_LEN; ++i)
+                params[i] = chip->read_byte(mtd);
+        return 0;
+}
+/**
+ * nand_reset_op - Do a reset operation
+ * @chip: The NAND chip
+ *
+ * This function sends a RESET command and waits for the NAND to be ready
+ * before returning.
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_reset_op(struct nand_chip *chip)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (chip->exec_op) {
+                const struct nand_sdr_timings *sdr =
+                        nand_get_sdr_timings(&chip->data_interface);
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(NAND_CMD_RESET, PSEC_TO_NSEC(sdr->tWB_max)),
+                        NAND_OP_WAIT_RDY(PSEC_TO_MSEC(sdr->tRST_max), 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_reset_op);
+/**
+ * nand_read_data_op - Read data from the NAND
+ * @chip: The NAND chip
+ * @buf: buffer used to store the data
+ * @len: length of the buffer
+ * @force_8bit: force 8-bit bus access
+ *
+ * This function does a raw data read on the bus. Usually used after launching
+ * another NAND operation like nand_read_page_op().
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
+                      bool force_8bit)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (!len || !buf)
+                return -EINVAL;
+        if (chip->exec_op) {
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_DATA_IN(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                instrs[0].ctx.data.force_8bit = force_8bit;
+                return nand_exec_op(chip, &op);
+        }
+        if (force_8bit) {
+                u8 *p = buf;
+                unsigned int i;
+                for (i = 0; i < len; i++)
+                        p[i] = chip->read_byte(mtd);
+        } else {
+                chip->read_buf(mtd, buf, len);
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_read_data_op);
+/**
+ * nand_write_data_op - Write data from the NAND
+ * @chip: The NAND chip
+ * @buf: buffer containing the data to send on the bus
+ * @len: length of the buffer
+ * @force_8bit: force 8-bit bus access
+ *
+ * This function does a raw data write on the bus. Usually used after launching
+ * another NAND operation like nand_write_page_begin_op().
+ * This function does not select/unselect the CS line.
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int nand_write_data_op(struct nand_chip *chip, const void *buf,
+                       unsigned int len, bool force_8bit)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (!len || !buf)
+                return -EINVAL;
+        if (chip->exec_op) {
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_DATA_OUT(len, buf, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                instrs[0].ctx.data.force_8bit = force_8bit;
+                return nand_exec_op(chip, &op);
+        }
+        if (force_8bit) {
+                const u8 *p = buf;
+                unsigned int i;
+                for (i = 0; i < len; i++)
+                        chip->write_byte(mtd, p[i]);
+        } else {
+                chip->write_buf(mtd, buf, len);
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_write_data_op);
+/**
+ * struct nand_op_parser_ctx - Context used by the parser
+ * @instrs: array of all the instructions that must be addressed
+ * @ninstrs: length of the @instrs array
+ * @subop: Sub-operation to be passed to the NAND controller
+ *
+ * This structure is used by the core to split NAND operations into
+ * sub-operations that can be handled by the NAND controller.
+ */
+struct nand_op_parser_ctx {
+        const struct nand_op_instr *instrs;
+        unsigned int ninstrs;
+        struct nand_subop subop;
+};
+/**
+ * nand_op_parser_must_split_instr - Checks if an instruction must be split
+ * @pat: the parser pattern element that matches @instr
+ * @instr: pointer to the instruction to check
+ * @start_offset: this is an in/out parameter. If @instr has already been
+ *                split, then @start_offset is the offset from which to start
+ *                (either an address cycle or an offset in the data buffer).
+ *                Conversely, if the function returns true (ie. instr must be
+ *                split), this parameter is updated to point to the first
+ *                data/address cycle that has not been taken care of.
+ *
+ * Some NAND controllers are limited and cannot send X address cycles with a
+ * unique operation, or cannot read/write more than Y bytes at the same time.
+ * In this case, split the instruction that does not fit in a single
+ * controller-operation into two or more chunks.
+ *
+ * Returns true if the instruction must be split, false otherwise.
+ * The @start_offset parameter is also updated to the offset at which the next
+ * bundle of instruction must start (if an address or a data instruction).
+ */
+static bool
+nand_op_parser_must_split_instr(const struct nand_op_parser_pattern_elem *pat,
+                                const struct nand_op_instr *instr,
+                                unsigned int *start_offset)
+{
+        switch (pat->type) {
+        case NAND_OP_ADDR_INSTR:
+                if (!pat->ctx.addr.maxcycles)
+                        break;
+                if (instr->ctx.addr.naddrs - *start_offset >
+                    pat->ctx.addr.maxcycles) {
+                        *start_offset += pat->ctx.addr.maxcycles;
+                        return true;
+                }
+                break;
+        case NAND_OP_DATA_IN_INSTR:
+        case NAND_OP_DATA_OUT_INSTR:
+                if (!pat->ctx.data.maxlen)
+                        break;
+                if (instr->ctx.data.len - *start_offset >
+                    pat->ctx.data.maxlen) {
+                        *start_offset += pat->ctx.data.maxlen;
+                        return true;
+                }
+                break;
+        default:
+                break;
+        }
+        return false;
+}
+/**
+ * nand_op_parser_match_pat - Checks if a pattern matches the instructions
+ *                            remaining in the parser context
+ * @pat: the pattern to test
+ * @ctx: the parser context structure to match with the pattern @pat
+ *
+ * Check if @pat matches the set or a sub-set of instructions remaining in @ctx.
+ * Returns true if this is the case, false ortherwise. When true is returned,
+ * @ctx->subop is updated with the set of instructions to be passed to the
+ * controller driver.
+ */
+static bool
+nand_op_parser_match_pat(const struct nand_op_parser_pattern *pat,
+                         struct nand_op_parser_ctx *ctx)
+{
+        unsigned int instr_offset = ctx->subop.first_instr_start_off;
+        const struct nand_op_instr *end = ctx->instrs + ctx->ninstrs;
+        const struct nand_op_instr *instr = ctx->subop.instrs;
+        unsigned int i, ninstrs;
+        for (i = 0, ninstrs = 0; i < pat->nelems && instr < end; i++) {
+                /*
+                 * The pattern instruction does not match the operation
+                 * instruction. If the instruction is marked optional in the
+                 * pattern definition, we skip the pattern element and continue
+                 * to the next one. If the element is mandatory, there's no
+                 * match and we can return false directly.
+                 */
+                if (instr->type != pat->elems[i].type) {
+                        if (!pat->elems[i].optional)
+                                return false;
+                        continue;
+                }
+                /*
+                 * Now check the pattern element constraints. If the pattern is
+                 * not able to handle the whole instruction in a single step,
+                 * we have to split it.
+                 * The last_instr_end_off value comes back updated to point to
+                 * the position where we have to split the instruction (the
+                 * start of the next subop chunk).
+                 */
+                if (nand_op_parser_must_split_instr(&pat->elems[i], instr,
+                                                    &instr_offset)) {
+                        ninstrs++;
+                        i++;
+                        break;
+                }
+                instr++;
+                ninstrs++;
+                instr_offset = 0;
+        }
+        /*
+         * This can happen if all instructions of a pattern are optional.
+         * Still, if there's not at least one instruction handled by this
+         * pattern, this is not a match, and we should try the next one (if
+         * any).
+         */
+        if (!ninstrs)
+                return false;
+        /*
+         * We had a match on the pattern head, but the pattern may be longer
+         * than the instructions we're asked to execute. We need to make sure
+         * there's no mandatory elements in the pattern tail.
+         */
+        for (; i < pat->nelems; i++) {
+                if (!pat->elems[i].optional)
+                        return false;
+        }
+        /*
+         * We have a match: update the subop structure accordingly and return
+         * true.
+         */
+        ctx->subop.ninstrs = ninstrs;
+        ctx->subop.last_instr_end_off = instr_offset;
+        return true;
+}
+#if IS_ENABLED(CONFIG_DYNAMIC_DEBUG) || defined(DEBUG)
+static void nand_op_parser_trace(const struct nand_op_parser_ctx *ctx)
+{
+        const struct nand_op_instr *instr;
+        char *prefix = "      ";
+        unsigned int i;
+        pr_debug("executing subop:\n");
+        for (i = 0; i < ctx->ninstrs; i++) {
+                instr = &ctx->instrs[i];
+                if (instr == &ctx->subop.instrs[0])
+                        prefix = "    ->";
+                switch (instr->type) {
+                case NAND_OP_CMD_INSTR:
+                        pr_debug("%sCMD      [0x%02x]\n", prefix,
+                                 instr->ctx.cmd.opcode);
+                        break;
+                case NAND_OP_ADDR_INSTR:
+                        pr_debug("%sADDR     [%d cyc: %*ph]\n", prefix,
+                                 instr->ctx.addr.naddrs,
+                                 instr->ctx.addr.naddrs < 64 ?
+                                 instr->ctx.addr.naddrs : 64,
+                                 instr->ctx.addr.addrs);
+                        break;
+                case NAND_OP_DATA_IN_INSTR:
+                        pr_debug("%sDATA_IN  [%d B%s]\n", prefix,
+                                 instr->ctx.data.len,
+                                 instr->ctx.data.force_8bit ?
+                                 ", force 8-bit" : "");
+                        break;
+                case NAND_OP_DATA_OUT_INSTR:
+                        pr_debug("%sDATA_OUT [%d B%s]\n", prefix,
+                                 instr->ctx.data.len,
+                                 instr->ctx.data.force_8bit ?
+                                 ", force 8-bit" : "");
+                        break;
+                case NAND_OP_WAITRDY_INSTR:
+                        pr_debug("%sWAITRDY  [max %d ms]\n", prefix,
+                                 instr->ctx.waitrdy.timeout_ms);
+                        break;
+                }
+                if (instr == &ctx->subop.instrs[ctx->subop.ninstrs - 1])
+                        prefix = "      ";
+        }
+}
+#else
+static void nand_op_parser_trace(const struct nand_op_parser_ctx *ctx)
+{
+        /* NOP */
+}
+#endif
+/**
+ * nand_op_parser_exec_op - exec_op parser
+ * @chip: the NAND chip
+ * @parser: patterns description provided by the controller driver
+ * @op: the NAND operation to address
+ * @check_only: when true, the function only checks if @op can be handled but
+ *              does not execute the operation
+ *
+ * Helper function designed to ease integration of NAND controller drivers that
+ * only support a limited set of instruction sequences. The supported sequences
+ * are described in @parser, and the framework takes care of splitting @op into
+ * multiple sub-operations (if required) and pass them back to the ->exec()
+ * callback of the matching pattern if @check_only is set to false.
+ *
+ * NAND controller drivers should call this function from their own ->exec_op()
+ * implementation.
+ *
+ * Returns 0 on success, a negative error code otherwise. A failure can be
+ * caused by an unsupported operation (none of the supported patterns is able
+ * to handle the requested operation), or an error returned by one of the
+ * matching pattern->exec() hook.
+ */
+int nand_op_parser_exec_op(struct nand_chip *chip,
+                           const struct nand_op_parser *parser,
+                           const struct nand_operation *op, bool check_only)
+{
+        struct nand_op_parser_ctx ctx = {
+                .subop.instrs = op->instrs,
+                .instrs = op->instrs,
+                .ninstrs = op->ninstrs,
+        };
+        unsigned int i;
+        while (ctx.subop.instrs < op->instrs + op->ninstrs) {
+                int ret;
+                for (i = 0; i < parser->npatterns; i++) {
+                        const struct nand_op_parser_pattern *pattern;
+                        pattern = &parser->patterns[i];
+                        if (!nand_op_parser_match_pat(pattern, &ctx))
+                                continue;
+                        nand_op_parser_trace(&ctx);
+                        if (check_only)
+                                break;
+                        ret = pattern->exec(chip, &ctx.subop);
+                        if (ret)
+                                return ret;
+                        break;
+                }
+                if (i == parser->npatterns) {
+                        pr_debug("->exec_op() parser: pattern not found!\n");
+                        return -ENOTSUPP;
+                }
+                /*
+                 * Update the context structure by pointing to the start of the
+                 * next subop.
+                 */
+                ctx.subop.instrs = ctx.subop.instrs + ctx.subop.ninstrs;
+                if (ctx.subop.last_instr_end_off)
+                        ctx.subop.instrs -= 1;
+                ctx.subop.first_instr_start_off = ctx.subop.last_instr_end_off;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(nand_op_parser_exec_op);
+static bool nand_instr_is_data(const struct nand_op_instr *instr)
+{
+        return instr && (instr->type == NAND_OP_DATA_IN_INSTR ||
+                         instr->type == NAND_OP_DATA_OUT_INSTR);
+}
+static bool nand_subop_instr_is_valid(const struct nand_subop *subop,
+                                      unsigned int instr_idx)
 {
-        kfree(chip->data_interface);
+        return subop && instr_idx < subop->ninstrs;
 }
+static int nand_subop_get_start_off(const struct nand_subop *subop,
+                                    unsigned int instr_idx)
+{
+        if (instr_idx)
+                return 0;
+        return subop->first_instr_start_off;
+}
+/**
+ * nand_subop_get_addr_start_off - Get the start offset in an address array
+ * @subop: The entire sub-operation
+ * @instr_idx: Index of the instruction inside the sub-operation
+ *
+ * During driver development, one could be tempted to directly use the
+ * ->addr.addrs field of address instructions. This is wrong as address
+ * instructions might be split.
+ *
+ * Given an address instruction, returns the offset of the first cycle to issue.
+ */
+int nand_subop_get_addr_start_off(const struct nand_subop *subop,
+                                  unsigned int instr_idx)
+{
+        if (!nand_subop_instr_is_valid(subop, instr_idx) ||
+            subop->instrs[instr_idx].type != NAND_OP_ADDR_INSTR)
+                return -EINVAL;
+        return nand_subop_get_start_off(subop, instr_idx);
+}
+EXPORT_SYMBOL_GPL(nand_subop_get_addr_start_off);
+/**
+ * nand_subop_get_num_addr_cyc - Get the remaining address cycles to assert
+ * @subop: The entire sub-operation
+ * @instr_idx: Index of the instruction inside the sub-operation
+ *
+ * During driver development, one could be tempted to directly use the
+ * ->addr->naddrs field of a data instruction. This is wrong as instructions
+ * might be split.
+ *
+ * Given an address instruction, returns the number of address cycle to issue.
+ */
+int nand_subop_get_num_addr_cyc(const struct nand_subop *subop,
+                                unsigned int instr_idx)
+{
+        int start_off, end_off;
+        if (!nand_subop_instr_is_valid(subop, instr_idx) ||
+            subop->instrs[instr_idx].type != NAND_OP_ADDR_INSTR)
+                return -EINVAL;
+        start_off = nand_subop_get_addr_start_off(subop, instr_idx);
+        if (instr_idx == subop->ninstrs - 1 &&
+            subop->last_instr_end_off)
+                end_off = subop->last_instr_end_off;
+        else
+                end_off = subop->instrs[instr_idx].ctx.addr.naddrs;
+        return end_off - start_off;
+}
+EXPORT_SYMBOL_GPL(nand_subop_get_num_addr_cyc);
+/**
+ * nand_subop_get_data_start_off - Get the start offset in a data array
+ * @subop: The entire sub-operation
+ * @instr_idx: Index of the instruction inside the sub-operation
+ *
+ * During driver development, one could be tempted to directly use the
+ * ->data->buf.{in,out} field of data instructions. This is wrong as data
+ * instructions might be split.
+ *
+ * Given a data instruction, returns the offset to start from.
+ */
+int nand_subop_get_data_start_off(const struct nand_subop *subop,
+                                  unsigned int instr_idx)
+{
+        if (!nand_subop_instr_is_valid(subop, instr_idx) ||
+            !nand_instr_is_data(&subop->instrs[instr_idx]))
+                return -EINVAL;
+        return nand_subop_get_start_off(subop, instr_idx);
+}
+EXPORT_SYMBOL_GPL(nand_subop_get_data_start_off);
+/**
+ * nand_subop_get_data_len - Get the number of bytes to retrieve
+ * @subop: The entire sub-operation
+ * @instr_idx: Index of the instruction inside the sub-operation
+ *
+ * During driver development, one could be tempted to directly use the
+ * ->data->len field of a data instruction. This is wrong as data instructions
+ * might be split.
+ *
+ * Returns the length of the chunk of data to send/receive.
+ */
+int nand_subop_get_data_len(const struct nand_subop *subop,
+                            unsigned int instr_idx)
+{
+        int start_off = 0, end_off;
+        if (!nand_subop_instr_is_valid(subop, instr_idx) ||
+            !nand_instr_is_data(&subop->instrs[instr_idx]))
+                return -EINVAL;
+        start_off = nand_subop_get_data_start_off(subop, instr_idx);
+        if (instr_idx == subop->ninstrs - 1 &&
+            subop->last_instr_end_off)
+                end_off = subop->last_instr_end_off;
+        else
+                end_off = subop->instrs[instr_idx].ctx.data.len;
+        return end_off - start_off;
+}
+EXPORT_SYMBOL_GPL(nand_subop_get_data_len);
 /**
 * nand_reset - Reset and initialize a NAND device
 * @chip: The NAND chip
 * @chipnr: Internal die id
 *
- * Returns 0 for success or negative error code otherwise
+ * Save the timings data structure, then apply SDR timings mode 0 (see
+ * nand_reset_data_interface for details), do the reset operation, and
+ * apply back the previous timings.
+ *
+ * Returns 0 on success, a negative error code otherwise.
 */
 int nand_reset(struct nand_chip *chip, int chipnr)
 {
        struct mtd_info *mtd = nand_to_mtd(chip);
+        struct nand_data_interface saved_data_intf = chip->data_interface;
        int ret;
        ret = nand_reset_data_interface(chip, chipnr);
@@ -1233,10 +2734,13 @@ int nand_reset(struct nand_chip *chip, int chipnr)
         * interface settings, hence this weird ->select_chip() dance.
         */
        chip->select_chip(mtd, chipnr);
-        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        ret = nand_reset_op(chip);
        chip->select_chip(mtd, -1);
+        if (ret)
+                return ret;
        chip->select_chip(mtd, chipnr);
+        chip->data_interface = saved_data_intf;
        ret = nand_setup_data_interface(chip, chipnr);
        chip->select_chip(mtd, -1);
        if (ret)
@@ -1390,9 +2894,19 @@ EXPORT_SYMBOL(nand_check_erased_ecc_chunk);
 int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                       uint8_t *buf, int oob_required, int page)
 {
-        chip->read_buf(mtd, buf, mtd->writesize);
+        int ret;
-        if (oob_required)
-                chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        ret = nand_read_page_op(chip, page, 0, buf, mtd->writesize);
+        if (ret)
+                return ret;
+        if (oob_required) {
+                ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize,
+                                        false);
+                if (ret)
+                        return ret;
+        }
        return 0;
 }
 EXPORT_SYMBOL(nand_read_page_raw);
@@ -1414,29 +2928,50 @@ static int nand_read_page_raw_syndrome(struct mtd_info *mtd,
        int eccsize = chip->ecc.size;
        int eccbytes = chip->ecc.bytes;
        uint8_t *oob = chip->oob_poi;
-        int steps, size;
+        int steps, size, ret;
+        ret = nand_read_page_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (steps = chip->ecc.steps; steps > 0; steps--) {
-                chip->read_buf(mtd, buf, eccsize);
+                ret = nand_read_data_op(chip, buf, eccsize, false);
+                if (ret)
+                        return ret;
                buf += eccsize;
                if (chip->ecc.prepad) {
-                        chip->read_buf(mtd, oob, chip->ecc.prepad);
+                        ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
+                                                false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.prepad;
                }
-                chip->read_buf(mtd, oob, eccbytes);
+                ret = nand_read_data_op(chip, oob, eccbytes, false);
+                if (ret)
+                        return ret;
                oob += eccbytes;
                if (chip->ecc.postpad) {
-                        chip->read_buf(mtd, oob, chip->ecc.postpad);
+                        ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
+                                                false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.postpad;
                }
        }
        size = mtd->oobsize - (oob - chip->oob_poi);
-        if (size)
+        if (size) {
-                chip->read_buf(mtd, oob, size);
+                ret = nand_read_data_op(chip, oob, size, false);
+                if (ret)
+                        return ret;
+        }
        return 0;
 }
@@ -1456,8 +2991,8 @@ static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
        uint8_t *p = buf;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        uint8_t *ecc_code = chip->ecc.code_buf;
        unsigned int max_bitflips = 0;
        chip->ecc.read_page_raw(mtd, chip, buf, 1, page);
@@ -1521,15 +3056,14 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
        data_col_addr = start_step * chip->ecc.size;
        /* If we read not a page aligned data */
-        if (data_col_addr != 0)
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1);
        p = bufpoi + data_col_addr;
-        chip->read_buf(mtd, p, datafrag_len);
+        ret = nand_read_page_op(chip, page, data_col_addr, p, datafrag_len);
+        if (ret)
+                return ret;
        /* Calculate ECC */
        for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
-                chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]);
+                chip->ecc.calculate(mtd, p, &chip->ecc.calc_buf[i]);
        /*
         * The performance is faster if we position offsets according to
@@ -1543,8 +3077,11 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
                gaps = 1;
        if (gaps) {
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1);
+                ret = nand_change_read_column_op(chip, mtd->writesize,
-                chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+                                                 chip->oob_poi, mtd->oobsize,
+                                                 false);
+                if (ret)
+                        return ret;
        } else {
                /*
                 * Send the command to read the particular ECC bytes take care
@@ -1558,12 +3095,15 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
                    (busw - 1))
                        aligned_len++;
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
+                ret = nand_change_read_column_op(chip,
-                              mtd->writesize + aligned_pos, -1);
+                                                 mtd->writesize + aligned_pos,
-                chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len);
+                                                 &chip->oob_poi[aligned_pos],
+                                                 aligned_len, false);
+                if (ret)
+                        return ret;
        }
-        ret = mtd_ooblayout_get_eccbytes(mtd, chip->buffers->ecccode,
+        ret = mtd_ooblayout_get_eccbytes(mtd, chip->ecc.code_buf,
                                         chip->oob_poi, index, eccfrag_len);
        if (ret)
                return ret;
@@ -1572,13 +3112,13 @@ static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
        for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
                int stat;
-                stat = chip->ecc.correct(mtd, p,
+                stat = chip->ecc.correct(mtd, p, &chip->ecc.code_buf[i],
-                        &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);
+                                         &chip->ecc.calc_buf[i]);
                if (stat == -EBADMSG &&
                    (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
                        /* check for empty pages with bitflips */
                        stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
-                                                &chip->buffers->ecccode[i],
+                                                &chip->ecc.code_buf[i],
                                                chip->ecc.bytes,
                                                NULL, 0,
                                                chip->ecc.strength);
@@ -1611,16 +3151,27 @@ static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
        uint8_t *p = buf;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        uint8_t *ecc_code = chip->ecc.code_buf;
        unsigned int max_bitflips = 0;
+        ret = nand_read_page_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
                chip->ecc.hwctl(mtd, NAND_ECC_READ);
-                chip->read_buf(mtd, p, eccsize);
+                ret = nand_read_data_op(chip, p, eccsize, false);
+                if (ret)
+                        return ret;
                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
        }
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize, false);
+        if (ret)
+                return ret;
        ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
                                         chip->ecc.total);
@@ -1674,14 +3225,18 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
        uint8_t *p = buf;
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        uint8_t *ecc_code = chip->ecc.code_buf;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
        unsigned int max_bitflips = 0;
        /* Read the OOB area first */
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        ret = nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        if (ret)
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+                return ret;
+        ret = nand_read_page_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
                                         chip->ecc.total);
@@ -1692,7 +3247,11 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
                int stat;
                chip->ecc.hwctl(mtd, NAND_ECC_READ);
-                chip->read_buf(mtd, p, eccsize);
+                ret = nand_read_data_op(chip, p, eccsize, false);
+                if (ret)
+                        return ret;
                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
                stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);
@@ -1729,7 +3288,7 @@ static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
                                   uint8_t *buf, int oob_required, int page)
 {
-        int i, eccsize = chip->ecc.size;
+        int ret, i, eccsize = chip->ecc.size;
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
        int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;
@@ -1737,25 +3296,44 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
        uint8_t *oob = chip->oob_poi;
        unsigned int max_bitflips = 0;
+        ret = nand_read_page_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
                int stat;
                chip->ecc.hwctl(mtd, NAND_ECC_READ);
-                chip->read_buf(mtd, p, eccsize);
+                ret = nand_read_data_op(chip, p, eccsize, false);
+                if (ret)
+                        return ret;
                if (chip->ecc.prepad) {
-                        chip->read_buf(mtd, oob, chip->ecc.prepad);
+                        ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
+                                                false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.prepad;
                }
                chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
-                chip->read_buf(mtd, oob, eccbytes);
+                ret = nand_read_data_op(chip, oob, eccbytes, false);
+                if (ret)
+                        return ret;
                stat = chip->ecc.correct(mtd, p, oob, NULL);
                oob += eccbytes;
                if (chip->ecc.postpad) {
-                        chip->read_buf(mtd, oob, chip->ecc.postpad);
+                        ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
+                                                false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.postpad;
                }
@@ -1779,8 +3357,11 @@ static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
        /* Calculate remaining oob bytes */
        i = mtd->oobsize - (oob - chip->oob_poi);
-        if (i)
+        if (i) {
-                chip->read_buf(mtd, oob, i);
+                ret = nand_read_data_op(chip, oob, i, false);
+                if (ret)
+                        return ret;
+        }
        return max_bitflips;
 }
@@ -1894,16 +3475,13 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
                /* Is the current page in the buffer? */
                if (realpage != chip->pagebuf || oob) {
-                        bufpoi = use_bufpoi ? chip->buffers->databuf : buf;
+                        bufpoi = use_bufpoi ? chip->data_buf : buf;
                        if (use_bufpoi && aligned)
                                pr_debug("%s: using read bounce buffer for buf@%p\n",
                                                 __func__, buf);
 read_retry:
-                        if (nand_standard_page_accessors(&chip->ecc))
-                                chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
                        /*
                         * Now read the page into the buffer.  Absent an error,
                         * the read methods return max bitflips per ecc step.
@@ -1938,7 +3516,7 @@ read_retry:
                                        /* Invalidate page cache */
                                        chip->pagebuf = -1;
                                }
-                                memcpy(buf, chip->buffers->databuf + col, bytes);
+                                memcpy(buf, chip->data_buf + col, bytes);
                        }
                        if (unlikely(oob)) {
@@ -1979,7 +3557,7 @@ read_retry:
                        buf += bytes;
                        max_bitflips = max_t(unsigned int, max_bitflips, ret);
                } else {
-                        memcpy(buf, chip->buffers->databuf + col, bytes);
+                        memcpy(buf, chip->data_buf + col, bytes);
                        buf += bytes;
                        max_bitflips = max_t(unsigned int, max_bitflips,
                                             chip->pagebuf_bitflips);
@@ -2034,9 +3612,7 @@ read_retry:
 */
 int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
 }
 EXPORT_SYMBOL(nand_read_oob_std);
@@ -2054,25 +3630,43 @@ int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
        int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
        int eccsize = chip->ecc.size;
        uint8_t *bufpoi = chip->oob_poi;
-        int i, toread, sndrnd = 0, pos;
+        int i, toread, sndrnd = 0, pos, ret;
+        ret = nand_read_page_op(chip, page, chip->ecc.size, NULL, 0);
+        if (ret)
+                return ret;
-        chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
        for (i = 0; i < chip->ecc.steps; i++) {
                if (sndrnd) {
+                        int ret;
                        pos = eccsize + i * (eccsize + chunk);
                        if (mtd->writesize > 512)
-                                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1);
+                                ret = nand_change_read_column_op(chip, pos,
+                                                                 NULL, 0,
+                                                                 false);
                        else
-                                chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page);
+                                ret = nand_read_page_op(chip, page, pos, NULL,
+                                                        0);
+                        if (ret)
+                                return ret;
                } else
                        sndrnd = 1;
                toread = min_t(int, length, chunk);
-                chip->read_buf(mtd, bufpoi, toread);
+                ret = nand_read_data_op(chip, bufpoi, toread, false);
+                if (ret)
+                        return ret;
                bufpoi += toread;
                length -= toread;
        }
-        if (length > 0)
+        if (length > 0) {
-                chip->read_buf(mtd, bufpoi, length);
+                ret = nand_read_data_op(chip, bufpoi, length, false);
+                if (ret)
+                        return ret;
+        }
        return 0;
 }
@@ -2086,18 +3680,8 @@ EXPORT_SYMBOL(nand_read_oob_syndrome);
 */
 int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page)
 {
-        int status = 0;
+        return nand_prog_page_op(chip, page, mtd->writesize, chip->oob_poi,
-        const uint8_t *buf = chip->oob_poi;
+                                 mtd->oobsize);
-        int length = mtd->oobsize;
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
-        chip->write_buf(mtd, buf, length);
-        /* Send command to program the OOB data */
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 EXPORT_SYMBOL(nand_write_oob_std);
@@ -2113,7 +3697,7 @@ int nand_write_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
 {
        int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
        int eccsize = chip->ecc.size, length = mtd->oobsize;
-        int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps;
+        int ret, i, len, pos, sndcmd = 0, steps = chip->ecc.steps;
        const uint8_t *bufpoi = chip->oob_poi;
        /*
@@ -2127,7 +3711,10 @@ int nand_write_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
        } else
                pos = eccsize;
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
+        ret = nand_prog_page_begin_op(chip, page, pos, NULL, 0);
+        if (ret)
+                return ret;
        for (i = 0; i < steps; i++) {
                if (sndcmd) {
                        if (mtd->writesize <= 512) {
@@ -2136,28 +3723,40 @@ int nand_write_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
                                len = eccsize;
                                while (len > 0) {
                                        int num = min_t(int, len, 4);
-                                        chip->write_buf(mtd, (uint8_t *)&fill,
-                                                        num);
+                                        ret = nand_write_data_op(chip, &fill,
+                                                                 num, false);
+                                        if (ret)
+                                                return ret;
                                        len -= num;
                                }
                        } else {
                                pos = eccsize + i * (eccsize + chunk);
-                                chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1);
+                                ret = nand_change_write_column_op(chip, pos,
+                                                                  NULL, 0,
+                                                                  false);
+                                if (ret)
+                                        return ret;
                        }
                } else
                        sndcmd = 1;
                len = min_t(int, length, chunk);
-                chip->write_buf(mtd, bufpoi, len);
+                ret = nand_write_data_op(chip, bufpoi, len, false);
+                if (ret)
+                        return ret;
                bufpoi += len;
                length -= len;
        }
-        if (length > 0)
+        if (length > 0) {
-                chip->write_buf(mtd, bufpoi, length);
+                ret = nand_write_data_op(chip, bufpoi, length, false);
+                if (ret)
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+                        return ret;
-        status = chip->waitfunc(mtd, chip);
+        }
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
+        return nand_prog_page_end_op(chip);
 }
 EXPORT_SYMBOL(nand_write_oob_syndrome);
@@ -2172,6 +3771,7 @@ EXPORT_SYMBOL(nand_write_oob_syndrome);
 static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
                            struct mtd_oob_ops *ops)
 {
+        unsigned int max_bitflips = 0;
        int page, realpage, chipnr;
        struct nand_chip *chip = mtd_to_nand(mtd);
        struct mtd_ecc_stats stats;
@@ -2214,6 +3814,8 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
                                nand_wait_ready(mtd);
                }
+                max_bitflips = max_t(unsigned int, max_bitflips, ret);
                readlen -= len;
                if (!readlen)
                        break;
@@ -2239,7 +3841,7 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
        if (mtd->ecc_stats.failed - stats.failed)
                return -EBADMSG;
-        return  mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
+        return max_bitflips;
 }
 /**
@@ -2287,11 +3889,20 @@ static int nand_read_oob(struct mtd_info *mtd, loff_t from,
 int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        const uint8_t *buf, int oob_required, int page)
 {
-        chip->write_buf(mtd, buf, mtd->writesize);
+        int ret;
-        if (oob_required)
-                chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        ret = nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
+        if (ret)
+                return ret;
+        if (oob_required) {
+                ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize,
+                                         false);
+                if (ret)
+                        return ret;
+        }
+        return nand_prog_page_end_op(chip);
 }
 EXPORT_SYMBOL(nand_write_page_raw);
@@ -2313,31 +3924,52 @@ static int nand_write_page_raw_syndrome(struct mtd_info *mtd,
        int eccsize = chip->ecc.size;
        int eccbytes = chip->ecc.bytes;
        uint8_t *oob = chip->oob_poi;
-        int steps, size;
+        int steps, size, ret;
+        ret = nand_prog_page_begin_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (steps = chip->ecc.steps; steps > 0; steps--) {
-                chip->write_buf(mtd, buf, eccsize);
+                ret = nand_write_data_op(chip, buf, eccsize, false);
+                if (ret)
+                        return ret;
                buf += eccsize;
                if (chip->ecc.prepad) {
-                        chip->write_buf(mtd, oob, chip->ecc.prepad);
+                        ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
+                                                 false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.prepad;
                }
-                chip->write_buf(mtd, oob, eccbytes);
+                ret = nand_write_data_op(chip, oob, eccbytes, false);
+                if (ret)
+                        return ret;
                oob += eccbytes;
                if (chip->ecc.postpad) {
-                        chip->write_buf(mtd, oob, chip->ecc.postpad);
+                        ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
+                                                 false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.postpad;
                }
        }
        size = mtd->oobsize - (oob - chip->oob_poi);
-        if (size)
+        if (size) {
-                chip->write_buf(mtd, oob, size);
+                ret = nand_write_data_op(chip, oob, size, false);
+                if (ret)
+                        return ret;
+        }
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /**
 * nand_write_page_swecc - [REPLACEABLE] software ECC based page write function
@@ -2354,7 +3986,7 @@ static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
        int i, eccsize = chip->ecc.size, ret;
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
        const uint8_t *p = buf;
        /* Software ECC calculation */
@@ -2384,12 +4016,20 @@ static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        int i, eccsize = chip->ecc.size, ret;
        int eccbytes = chip->ecc.bytes;
        int eccsteps = chip->ecc.steps;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
        const uint8_t *p = buf;
+        ret = nand_prog_page_begin_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
-                chip->write_buf(mtd, p, eccsize);
+                ret = nand_write_data_op(chip, p, eccsize, false);
+                if (ret)
+                        return ret;
                chip->ecc.calculate(mtd, p, &ecc_calc[i]);
        }
@@ -2398,9 +4038,11 @@ static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        if (ret)
                return ret;
-        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false);
+        if (ret)
+                return ret;
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
@@ -2420,7 +4062,7 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
                                int oob_required, int page)
 {
        uint8_t *oob_buf  = chip->oob_poi;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
        int ecc_size      = chip->ecc.size;
        int ecc_bytes     = chip->ecc.bytes;
        int ecc_steps     = chip->ecc.steps;
@@ -2429,12 +4071,18 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
        int oob_bytes       = mtd->oobsize / ecc_steps;
        int step, ret;
+        ret = nand_prog_page_begin_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
        for (step = 0; step < ecc_steps; step++) {
                /* configure controller for WRITE access */
                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
                /* write data (untouched subpages already masked by 0xFF) */
-                chip->write_buf(mtd, buf, ecc_size);
+                ret = nand_write_data_op(chip, buf, ecc_size, false);
+                if (ret)
+                        return ret;
                /* mask ECC of un-touched subpages by padding 0xFF */
                if ((step < start_step) || (step > end_step))
@@ -2454,16 +4102,18 @@ static int nand_write_subpage_hwecc(struct mtd_info *mtd,
        /* copy calculated ECC for whole page to chip->buffer->oob */
        /* this include masked-value(0xFF) for unwritten subpages */
-        ecc_calc = chip->buffers->ecccalc;
+        ecc_calc = chip->ecc.calc_buf;
        ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
                                         chip->ecc.total);
        if (ret)
                return ret;
        /* write OOB buffer to NAND device */
-        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false);
+        if (ret)
+                return ret;
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
@@ -2488,33 +4138,55 @@ static int nand_write_page_syndrome(struct mtd_info *mtd,
        int eccsteps = chip->ecc.steps;
        const uint8_t *p = buf;
        uint8_t *oob = chip->oob_poi;
+        int ret;
-        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+        ret = nand_prog_page_begin_op(chip, page, 0, NULL, 0);
+        if (ret)
+                return ret;
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
                chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
-                chip->write_buf(mtd, p, eccsize);
+                ret = nand_write_data_op(chip, p, eccsize, false);
+                if (ret)
+                        return ret;
                if (chip->ecc.prepad) {
-                        chip->write_buf(mtd, oob, chip->ecc.prepad);
+                        ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
+                                                 false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.prepad;
                }
                chip->ecc.calculate(mtd, p, oob);
-                chip->write_buf(mtd, oob, eccbytes);
+                ret = nand_write_data_op(chip, oob, eccbytes, false);
+                if (ret)
+                        return ret;
                oob += eccbytes;
                if (chip->ecc.postpad) {
-                        chip->write_buf(mtd, oob, chip->ecc.postpad);
+                        ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
+                                                 false);
+                        if (ret)
+                                return ret;
                        oob += chip->ecc.postpad;
                }
        }
        /* Calculate remaining oob bytes */
        i = mtd->oobsize - (oob - chip->oob_poi);
-        if (i)
+        if (i) {
-                chip->write_buf(mtd, oob, i);
+                ret = nand_write_data_op(chip, oob, i, false);
+                if (ret)
+                        return ret;
+        }
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /**
@@ -2540,9 +4212,6 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        else
                subpage = 0;
-        if (nand_standard_page_accessors(&chip->ecc))
-                chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
        if (unlikely(raw))
                status = chip->ecc.write_page_raw(mtd, chip, buf,
                                                  oob_required, page);
@@ -2556,14 +4225,6 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        if (status < 0)
                return status;
-        if (nand_standard_page_accessors(&chip->ecc)) {
-                chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-                status = chip->waitfunc(mtd, chip);
-                if (status & NAND_STATUS_FAIL)
-                        return -EIO;
-        }
        return 0;
 }
@@ -2688,9 +4349,9 @@ static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
                        if (part_pagewr)
                                bytes = min_t(int, bytes - column, writelen);
                        chip->pagebuf = -1;
-                        memset(chip->buffers->databuf, 0xff, mtd->writesize);
+                        memset(chip->data_buf, 0xff, mtd->writesize);
-                        memcpy(&chip->buffers->databuf[column], buf, bytes);
+                        memcpy(&chip->data_buf[column], buf, bytes);
-                        wbuf = chip->buffers->databuf;
+                        wbuf = chip->data_buf;
                }
                if (unlikely(oob)) {
@@ -2885,11 +4546,12 @@ out:
 static int single_erase(struct mtd_info *mtd, int page)
 {
        struct nand_chip *chip = mtd_to_nand(mtd);
+        unsigned int eraseblock;
        /* Send commands to erase a block */
-        chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
+        eraseblock = page >> (chip->phys_erase_shift - chip->page_shift);
-        chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
-        return chip->waitfunc(mtd, chip);
+        return nand_erase_op(chip, eraseblock);
 }
 /**
@@ -2973,7 +4635,7 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
                status = chip->erase(mtd, page & chip->pagemask);
                /* See if block erase succeeded */
-                if (status & NAND_STATUS_FAIL) {
+                if (status) {
                        pr_debug("%s: failed erase, page 0x%08x\n",
                                        __func__, page);
                        instr->state = MTD_ERASE_FAILED;
@@ -3116,22 +4778,12 @@ static int nand_max_bad_blocks(struct mtd_info *mtd, loff_t ofs, size_t len)
 static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip,
                        int addr, uint8_t *subfeature_param)
 {
-        int status;
-        int i;
        if (!chip->onfi_version ||
            !(le16_to_cpu(chip->onfi_params.opt_cmd)
              & ONFI_OPT_CMD_SET_GET_FEATURES))
                return -EINVAL;
-        chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, addr, -1);
+        return nand_set_features_op(chip, addr, subfeature_param);
-        for (i = 0; i < ONFI_SUBFEATURE_PARAM_LEN; ++i)
-                chip->write_byte(mtd, subfeature_param[i]);
-        status = chip->waitfunc(mtd, chip);
-        if (status & NAND_STATUS_FAIL)
-                return -EIO;
-        return 0;
 }
 /**
@@ -3144,17 +4796,12 @@ static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip,
 static int nand_onfi_get_features(struct mtd_info *mtd, struct nand_chip *chip,
                        int addr, uint8_t *subfeature_param)
 {
-        int i;
        if (!chip->onfi_version ||
            !(le16_to_cpu(chip->onfi_params.opt_cmd)
              & ONFI_OPT_CMD_SET_GET_FEATURES))
                return -EINVAL;
-        chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, addr, -1);
+        return nand_get_features_op(chip, addr, subfeature_param);
-        for (i = 0; i < ONFI_SUBFEATURE_PARAM_LEN; ++i)
-                *subfeature_param++ = chip->read_byte(mtd);
-        return 0;
 }
 /**
@@ -3220,7 +4867,7 @@ static void nand_set_defaults(struct nand_chip *chip)
                chip->chip_delay = 20;
        /* check, if a user supplied command function given */
-        if (chip->cmdfunc == NULL)
+        if (!chip->cmdfunc && !chip->exec_op)
                chip->cmdfunc = nand_command;
        /* check, if a user supplied wait function given */
@@ -3297,12 +4944,11 @@ static u16 onfi_crc16(u16 crc, u8 const *p, size_t len)
 static int nand_flash_detect_ext_param_page(struct nand_chip *chip,
                                            struct nand_onfi_params *p)
 {
-        struct mtd_info *mtd = nand_to_mtd(chip);
        struct onfi_ext_param_page *ep;
        struct onfi_ext_section *s;
        struct onfi_ext_ecc_info *ecc;
        uint8_t *cursor;
-        int ret = -EINVAL;
+        int ret;
        int len;
        int i;
@@ -3312,14 +4958,18 @@ static int nand_flash_detect_ext_param_page(struct nand_chip *chip,
                return -ENOMEM;
        /* Send our own NAND_CMD_PARAM. */
-        chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1);
+        ret = nand_read_param_page_op(chip, 0, NULL, 0);
+        if (ret)
+                goto ext_out;
        /* Use the Change Read Column command to skip the ONFI param pages. */
-        chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
+        ret = nand_change_read_column_op(chip,
-                        sizeof(*p) * p->num_of_param_pages , -1);
+                                         sizeof(*p) * p->num_of_param_pages,
+                                         ep, len, true);
+        if (ret)
+                goto ext_out;
-        /* Read out the Extended Parameter Page. */
+        ret = -EINVAL;
-        chip->read_buf(mtd, (uint8_t *)ep, len);
        if ((onfi_crc16(ONFI_CRC_BASE, ((uint8_t *)ep) + 2, len - 2)
                != le16_to_cpu(ep->crc))) {
                pr_debug("fail in the CRC.\n");
@@ -3372,19 +5022,23 @@ static int nand_flash_detect_onfi(struct nand_chip *chip)
 {
        struct mtd_info *mtd = nand_to_mtd(chip);
        struct nand_onfi_params *p = &chip->onfi_params;
-        int i, j;
+        char id[4];
-        int val;
+        int i, ret, val;
        /* Try ONFI for unknown chip or LP */
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x20, -1);
+        ret = nand_readid_op(chip, 0x20, id, sizeof(id));
-        if (chip->read_byte(mtd) != 'O' || chip->read_byte(mtd) != 'N' ||
+        if (ret || strncmp(id, "ONFI", 4))
-                chip->read_byte(mtd) != 'F' || chip->read_byte(mtd) != 'I')
+                return 0;
+        ret = nand_read_param_page_op(chip, 0, NULL, 0);
+        if (ret)
                return 0;
-        chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1);
        for (i = 0; i < 3; i++) {
-                for (j = 0; j < sizeof(*p); j++)
+                ret = nand_read_data_op(chip, p, sizeof(*p), true);
-                        ((uint8_t *)p)[j] = chip->read_byte(mtd);
+                if (ret)
+                        return 0;
                if (onfi_crc16(ONFI_CRC_BASE, (uint8_t *)p, 254) ==
                                le16_to_cpu(p->crc)) {
                        break;
@@ -3475,20 +5129,22 @@ static int nand_flash_detect_jedec(struct nand_chip *chip)
        struct mtd_info *mtd = nand_to_mtd(chip);
        struct nand_jedec_params *p = &chip->jedec_params;
        struct jedec_ecc_info *ecc;
-        int val;
+        char id[5];
-        int i, j;
+        int i, val, ret;
        /* Try JEDEC for unknown chip or LP */
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x40, -1);
+        ret = nand_readid_op(chip, 0x40, id, sizeof(id));
-        if (chip->read_byte(mtd) != 'J' || chip->read_byte(mtd) != 'E' ||
+        if (ret || strncmp(id, "JEDEC", sizeof(id)))
-                chip->read_byte(mtd) != 'D' || chip->read_byte(mtd) != 'E' ||
+                return 0;
-                chip->read_byte(mtd) != 'C')
+        ret = nand_read_param_page_op(chip, 0x40, NULL, 0);
+        if (ret)
                return 0;
-        chip->cmdfunc(mtd, NAND_CMD_PARAM, 0x40, -1);
        for (i = 0; i < 3; i++) {
-                for (j = 0; j < sizeof(*p); j++)
+                ret = nand_read_data_op(chip, p, sizeof(*p), true);
-                        ((uint8_t *)p)[j] = chip->read_byte(mtd);
+                if (ret)
+                        return 0;
                if (onfi_crc16(ONFI_CRC_BASE, (uint8_t *)p, 510) ==
                                le16_to_cpu(p->crc))
@@ -3767,8 +5423,7 @@ static int nand_detect(struct nand_chip *chip, struct nand_flash_dev *type)
 {
        const struct nand_manufacturer *manufacturer;
        struct mtd_info *mtd = nand_to_mtd(chip);
-        int busw;
+        int busw, ret;
-        int i;
        u8 *id_data = chip->id.data;
        u8 maf_id, dev_id;
@@ -3776,17 +5431,21 @@ static int nand_detect(struct nand_chip *chip, struct nand_flash_dev *type)
         * Reset the chip, required by some chips (e.g. Micron MT29FxGxxxxx)
         * after power-up.
         */
-        nand_reset(chip, 0);
+        ret = nand_reset(chip, 0);
+        if (ret)
+                return ret;
        /* Select the device */
        chip->select_chip(mtd, 0);
        /* Send the command for reading device ID */
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
+        ret = nand_readid_op(chip, 0, id_data, 2);
+        if (ret)
+                return ret;
        /* Read manufacturer and device IDs */
-        maf_id = chip->read_byte(mtd);
+        maf_id = id_data[0];
-        dev_id = chip->read_byte(mtd);
+        dev_id = id_data[1];
        /*
         * Try again to make sure, as some systems the bus-hold or other
@@ -3795,11 +5454,10 @@ static int nand_detect(struct nand_chip *chip, struct nand_flash_dev *type)
         * not match, ignore the device completely.
         */
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
        /* Read entire ID string */
-        for (i = 0; i < ARRAY_SIZE(chip->id.data); i++)
+        ret = nand_readid_op(chip, 0, id_data, sizeof(chip->id.data));
-                id_data[i] = chip->read_byte(mtd);
+        if (ret)
+                return ret;
        if (id_data[0] != maf_id || id_data[1] != dev_id) {
                pr_info("second ID read did not match %02x,%02x against %02x,%02x\n",
@@ -4091,6 +5749,9 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips,
        struct nand_chip *chip = mtd_to_nand(mtd);
        int ret;
+        /* Enforce the right timings for reset/detection */
+        onfi_fill_data_interface(chip, NAND_SDR_IFACE, 0);
        ret = nand_dt_init(chip);
        if (ret)
                return ret;
@@ -4098,15 +5759,21 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips,
        if (!mtd->name && mtd->dev.parent)
                mtd->name = dev_name(mtd->dev.parent);
-        if ((!chip->cmdfunc || !chip->select_chip) && !chip->cmd_ctrl) {
+        /*
+         * ->cmdfunc() is legacy and will only be used if ->exec_op() is not
+         * populated.
+         */
+        if (!chip->exec_op) {
                /*
-                 * Default functions assigned for chip_select() and
+                 * Default functions assigned for ->cmdfunc() and
-                 * cmdfunc() both expect cmd_ctrl() to be populated,
+                 * ->select_chip() both expect ->cmd_ctrl() to be populated.
-                 * so we need to check that that's the case
                 */
-                pr_err("chip.cmd_ctrl() callback is not provided");
+                if ((!chip->cmdfunc || !chip->select_chip) && !chip->cmd_ctrl) {
-                return -EINVAL;
+                        pr_err("->cmd_ctrl() should be provided\n");
+                        return -EINVAL;
+                }
        }
        /* Set the default functions */
        nand_set_defaults(chip);
@@ -4126,15 +5793,16 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips,
        /* Check for a chip array */
        for (i = 1; i < maxchips; i++) {
+                u8 id[2];
                /* See comment in nand_get_flash_type for reset */
                nand_reset(chip, i);
                chip->select_chip(mtd, i);
                /* Send the command for reading device ID */
-                chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
+                nand_readid_op(chip, 0, id, sizeof(id));
                /* Read manufacturer and device IDs */
-                if (nand_maf_id != chip->read_byte(mtd) ||
+                if (nand_maf_id != id[0] || nand_dev_id != id[1]) {
-                    nand_dev_id != chip->read_byte(mtd)) {
                        chip->select_chip(mtd, -1);
                        break;
                }
@@ -4501,26 +6169,6 @@ static bool nand_ecc_strength_good(struct mtd_info *mtd)
        return corr >= ds_corr && ecc->strength >= chip->ecc_strength_ds;
 }
-static bool invalid_ecc_page_accessors(struct nand_chip *chip)
-{
-        struct nand_ecc_ctrl *ecc = &chip->ecc;
-        if (nand_standard_page_accessors(ecc))
-                return false;
-        /*
-         * NAND_ECC_CUSTOM_PAGE_ACCESS flag is set, make sure the NAND
-         * controller driver implements all the page accessors because
-         * default helpers are not suitable when the core does not
-         * send the READ0/PAGEPROG commands.
-         */
-        return (!ecc->read_page || !ecc->write_page ||
-                !ecc->read_page_raw || !ecc->write_page_raw ||
-                (NAND_HAS_SUBPAGE_READ(chip) && !ecc->read_subpage) ||
-                (NAND_HAS_SUBPAGE_WRITE(chip) && !ecc->write_subpage &&
-                 ecc->hwctl && ecc->calculate));
-}
 /**
 * nand_scan_tail - [NAND Interface] Scan for the NAND device
 * @mtd: MTD device structure
@@ -4533,7 +6181,6 @@ int nand_scan_tail(struct mtd_info *mtd)
 {
        struct nand_chip *chip = mtd_to_nand(mtd);
        struct nand_ecc_ctrl *ecc = &chip->ecc;
-        struct nand_buffers *nbuf = NULL;
        int ret, i;
        /* New bad blocks should be marked in OOB, flash-based BBT, or both */
@@ -4542,39 +6189,9 @@ int nand_scan_tail(struct mtd_info *mtd)
                return -EINVAL;
        }
-        if (invalid_ecc_page_accessors(chip)) {
+        chip->data_buf = kmalloc(mtd->writesize + mtd->oobsize, GFP_KERNEL);
-                pr_err("Invalid ECC page accessors setup\n");
+        if (!chip->data_buf)
-                return -EINVAL;
-        }
-        if (!(chip->options & NAND_OWN_BUFFERS)) {
-                nbuf = kzalloc(sizeof(*nbuf), GFP_KERNEL);
-                if (!nbuf)
-                        return -ENOMEM;
-                nbuf->ecccalc = kmalloc(mtd->oobsize, GFP_KERNEL);
-                if (!nbuf->ecccalc) {
-                        ret = -ENOMEM;
-                        goto err_free_nbuf;
-                }
-                nbuf->ecccode = kmalloc(mtd->oobsize, GFP_KERNEL);
-                if (!nbuf->ecccode) {
-                        ret = -ENOMEM;
-                        goto err_free_nbuf;
-                }
-                nbuf->databuf = kmalloc(mtd->writesize + mtd->oobsize,
-                                        GFP_KERNEL);
-                if (!nbuf->databuf) {
-                        ret = -ENOMEM;
-                        goto err_free_nbuf;
-                }
-                chip->buffers = nbuf;
-        } else if (!chip->buffers) {
                return -ENOMEM;
-        }
        /*
         * FIXME: some NAND manufacturer drivers expect the first die to be
@@ -4586,10 +6203,10 @@ int nand_scan_tail(struct mtd_info *mtd)
        ret = nand_manufacturer_init(chip);
        chip->select_chip(mtd, -1);
        if (ret)
-                goto err_free_nbuf;
+                goto err_free_buf;
        /* Set the internal oob buffer location, just after the page data */
-        chip->oob_poi = chip->buffers->databuf + mtd->writesize;
+        chip->oob_poi = chip->data_buf + mtd->writesize;
        /*
         * If no default placement scheme is given, select an appropriate one.
@@ -4737,6 +6354,15 @@ int nand_scan_tail(struct mtd_info *mtd)
                goto err_nand_manuf_cleanup;
        }
+        if (ecc->correct || ecc->calculate) {
+                ecc->calc_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
+                ecc->code_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
+                if (!ecc->calc_buf || !ecc->code_buf) {
+                        ret = -ENOMEM;
+                        goto err_nand_manuf_cleanup;
+                }
+        }
        /* For many systems, the standard OOB write also works for raw */
        if (!ecc->read_oob_raw)
                ecc->read_oob_raw = ecc->read_oob;
@@ -4853,7 +6479,7 @@ int nand_scan_tail(struct mtd_info *mtd)
                chip->select_chip(mtd, -1);
                if (ret)
-                        goto err_nand_data_iface_cleanup;
+                        goto err_nand_manuf_cleanup;
        }
        /* Check, if we should skip the bad block table scan */
@@ -4863,23 +6489,18 @@ int nand_scan_tail(struct mtd_info *mtd)
        /* Build bad block table */
        ret = chip->scan_bbt(mtd);
        if (ret)
-                goto err_nand_data_iface_cleanup;
+                goto err_nand_manuf_cleanup;
        return 0;
-err_nand_data_iface_cleanup:
-        nand_release_data_interface(chip);
 err_nand_manuf_cleanup:
        nand_manufacturer_cleanup(chip);
-err_free_nbuf:
+err_free_buf:
-        if (nbuf) {
+        kfree(chip->data_buf);
-                kfree(nbuf->databuf);
+        kfree(ecc->code_buf);
-                kfree(nbuf->ecccode);
+        kfree(ecc->calc_buf);
-                kfree(nbuf->ecccalc);
-                kfree(nbuf);
-        }
        return ret;
 }
@@ -4927,16 +6548,11 @@ void nand_cleanup(struct nand_chip *chip)
            chip->ecc.algo == NAND_ECC_BCH)
                nand_bch_free((struct nand_bch_control *)chip->ecc.priv);
-        nand_release_data_interface(chip);
        /* Free bad block table memory */
        kfree(chip->bbt);
-        if (!(chip->options & NAND_OWN_BUFFERS) && chip->buffers) {
+        kfree(chip->data_buf);
-                kfree(chip->buffers->databuf);
+        kfree(chip->ecc.code_buf);
-                kfree(chip->buffers->ecccode);
+        kfree(chip->ecc.calc_buf);
-                kfree(chip->buffers->ecccalc);
-                kfree(chip->buffers);
-        }
        /* Free bad block descriptor memory */
        if (chip->badblock_pattern && chip->badblock_pattern->options
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index 2915b6739bf8..36092850be2c 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -898,7 +898,7 @@ static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *b
 {
        struct nand_chip *this = mtd_to_nand(mtd);
-        return create_bbt(mtd, this->buffers->databuf, bd, -1);
+        return create_bbt(mtd, this->data_buf, bd, -1);
 }
 /**
diff --git a/drivers/mtd/nand/nand_hynix.c b/drivers/mtd/nand/nand_hynix.c
index 985751eda317..d542908a0ebb 100644
--- a/drivers/mtd/nand/nand_hynix.c
+++ b/drivers/mtd/nand/nand_hynix.c
@@ -67,15 +67,43 @@ struct hynix_read_retry_otp {
 static bool hynix_nand_has_valid_jedecid(struct nand_chip *chip)
 {
+        u8 jedecid[5] = { };
+        int ret;
+        ret = nand_readid_op(chip, 0x40, jedecid, sizeof(jedecid));
+        if (ret)
+                return false;
+        return !strncmp("JEDEC", jedecid, sizeof(jedecid));
+}
+static int hynix_nand_cmd_op(struct nand_chip *chip, u8 cmd)
+{
+        struct mtd_info *mtd = nand_to_mtd(chip);
+        if (chip->exec_op) {
+                struct nand_op_instr instrs[] = {
+                        NAND_OP_CMD(cmd, 0),
+                };
+                struct nand_operation op = NAND_OPERATION(instrs);
+                return nand_exec_op(chip, &op);
+        }
+        chip->cmdfunc(mtd, cmd, -1, -1);
+        return 0;
+}
+static int hynix_nand_reg_write_op(struct nand_chip *chip, u8 addr, u8 val)
+{
        struct mtd_info *mtd = nand_to_mtd(chip);
-        u8 jedecid[6] = { };
+        u16 column = ((u16)addr << 8) | addr;
-        int i = 0;
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x40, -1);
+        chip->cmdfunc(mtd, NAND_CMD_NONE, column, -1);
-        for (i = 0; i < 5; i++)
+        chip->write_byte(mtd, val);
-                jedecid[i] = chip->read_byte(mtd);
-        return !strcmp("JEDEC", jedecid);
+        return 0;
 }
 static int hynix_nand_setup_read_retry(struct mtd_info *mtd, int retry_mode)
@@ -83,14 +111,15 @@ static int hynix_nand_setup_read_retry(struct mtd_info *mtd, int retry_mode)
        struct nand_chip *chip = mtd_to_nand(mtd);
        struct hynix_nand *hynix = nand_get_manufacturer_data(chip);
        const u8 *values;
-        int status;
+        int i, ret;
-        int i;
        values = hynix->read_retry->values +
                 (retry_mode * hynix->read_retry->nregs);
        /* Enter 'Set Hynix Parameters' mode */
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_SET_PARAMS, -1, -1);
+        ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
+        if (ret)
+                return ret;
        /*
         * Configure the NAND in the requested read-retry mode.
@@ -102,21 +131,14 @@ static int hynix_nand_setup_read_retry(struct mtd_info *mtd, int retry_mode)
         * probably tweaked at production in this case).
         */
        for (i = 0; i < hynix->read_retry->nregs; i++) {
-                int column = hynix->read_retry->regs[i];
+                ret = hynix_nand_reg_write_op(chip, hynix->read_retry->regs[i],
+                                              values[i]);
-                column |= column << 8;
+                if (ret)
-                chip->cmdfunc(mtd, NAND_CMD_NONE, column, -1);
+                        return ret;
-                chip->write_byte(mtd, values[i]);
        }
        /* Apply the new settings. */
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_APPLY_PARAMS, -1, -1);
+        return hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
-        status = chip->waitfunc(mtd, chip);
-        if (status & NAND_STATUS_FAIL)
-                return -EIO;
-        return 0;
 }
 /**
@@ -172,40 +194,63 @@ static int hynix_read_rr_otp(struct nand_chip *chip,
                             const struct hynix_read_retry_otp *info,
                             void *buf)
 {
-        struct mtd_info *mtd = nand_to_mtd(chip);
+        int i, ret;
-        int i;
-        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        ret = nand_reset_op(chip);
+        if (ret)
+                return ret;
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_SET_PARAMS, -1, -1);
+        ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
+        if (ret)
+                return ret;
        for (i = 0; i < info->nregs; i++) {
-                int column = info->regs[i];
+                ret = hynix_nand_reg_write_op(chip, info->regs[i],
+                                              info->values[i]);
-                column |= column << 8;
+                if (ret)
-                chip->cmdfunc(mtd, NAND_CMD_NONE, column, -1);
+                        return ret;
-                chip->write_byte(mtd, info->values[i]);
        }
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_APPLY_PARAMS, -1, -1);
+        ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
+        if (ret)
+                return ret;
        /* Sequence to enter OTP mode? */
-        chip->cmdfunc(mtd, 0x17, -1, -1);
+        ret = hynix_nand_cmd_op(chip, 0x17);
-        chip->cmdfunc(mtd, 0x04, -1, -1);
+        if (ret)
-        chip->cmdfunc(mtd, 0x19, -1, -1);
+                return ret;
+        ret = hynix_nand_cmd_op(chip, 0x4);
+        if (ret)
+                return ret;
+        ret = hynix_nand_cmd_op(chip, 0x19);
+        if (ret)
+                return ret;
        /* Now read the page */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x0, info->page);
+        ret = nand_read_page_op(chip, info->page, 0, buf, info->size);
-        chip->read_buf(mtd, buf, info->size);
+        if (ret)
+                return ret;
        /* Put everything back to normal */
-        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+        ret = nand_reset_op(chip);
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_SET_PARAMS, 0x38, -1);
+        if (ret)
-        chip->write_byte(mtd, 0x0);
+                return ret;
-        chip->cmdfunc(mtd, NAND_HYNIX_CMD_APPLY_PARAMS, -1, -1);
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x0, -1);
-        return 0;
+        ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_SET_PARAMS);
+        if (ret)
+                return ret;
+        ret = hynix_nand_reg_write_op(chip, 0x38, 0);
+        if (ret)
+                return ret;
+        ret = hynix_nand_cmd_op(chip, NAND_HYNIX_CMD_APPLY_PARAMS);
+        if (ret)
+                return ret;
+        return nand_read_page_op(chip, 0, 0, NULL, 0);
 }
 #define NAND_HYNIX_1XNM_RR_COUNT_OFFS                           0
diff --git a/drivers/mtd/nand/nand_micron.c b/drivers/mtd/nand/nand_micron.c
index abf6a3c376e8..02e109ae73f1 100644
--- a/drivers/mtd/nand/nand_micron.c
+++ b/drivers/mtd/nand/nand_micron.c
@@ -117,16 +117,28 @@ micron_nand_read_page_on_die_ecc(struct mtd_info *mtd, struct nand_chip *chip,
                                 uint8_t *buf, int oob_required,
                                 int page)
 {
-        int status;
+        u8 status;
-        int max_bitflips = 0;
+        int ret, max_bitflips = 0;
-        micron_nand_on_die_ecc_setup(chip, true);
+        ret = micron_nand_on_die_ecc_setup(chip, true);
+        if (ret)
+                return ret;
+        ret = nand_read_page_op(chip, page, 0, NULL, 0);
+        if (ret)
+                goto out;
+        ret = nand_status_op(chip, &status);
+        if (ret)
+                goto out;
+        ret = nand_exit_status_op(chip);
+        if (ret)
+                goto out;
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
-        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
-        status = chip->read_byte(mtd);
        if (status & NAND_STATUS_FAIL)
                mtd->ecc_stats.failed++;
        /*
         * The internal ECC doesn't tell us the number of bitflips
         * that have been corrected, but tells us if it recommends to
@@ -137,13 +149,15 @@ micron_nand_read_page_on_die_ecc(struct mtd_info *mtd, struct nand_chip *chip,
        else if (status & NAND_STATUS_WRITE_RECOMMENDED)
                max_bitflips = chip->ecc.strength;
-        chip->cmdfunc(mtd, NAND_CMD_READ0, -1, -1);
+        ret = nand_read_data_op(chip, buf, mtd->writesize, false);
+        if (!ret && oob_required)
-        nand_read_page_raw(mtd, chip, buf, oob_required, page);
+                ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize,
+                                        false);
+out:
        micron_nand_on_die_ecc_setup(chip, false);
-        return max_bitflips;
+        return ret ? ret : max_bitflips;
 }
 static int
@@ -151,46 +165,16 @@ micron_nand_write_page_on_die_ecc(struct mtd_info *mtd, struct nand_chip *chip,
                                  const uint8_t *buf, int oob_required,
                                  int page)
 {
-        int status;
+        int ret;
-        micron_nand_on_die_ecc_setup(chip, true);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
+        ret = micron_nand_on_die_ecc_setup(chip, true);
-        nand_write_page_raw(mtd, chip, buf, oob_required, page);
+        if (ret)
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+                return ret;
-        status = chip->waitfunc(mtd, chip);
+        ret = nand_write_page_raw(mtd, chip, buf, oob_required, page);
        micron_nand_on_die_ecc_setup(chip, false);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
+        return ret;
-}
-static int
-micron_nand_read_page_raw_on_die_ecc(struct mtd_info *mtd,
-                                     struct nand_chip *chip,
-                                     uint8_t *buf, int oob_required,
-                                     int page)
-{
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
-        nand_read_page_raw(mtd, chip, buf, oob_required, page);
-        return 0;
-}
-static int
-micron_nand_write_page_raw_on_die_ecc(struct mtd_info *mtd,
-                                      struct nand_chip *chip,
-                                      const uint8_t *buf, int oob_required,
-                                      int page)
-{
-        int status;
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
-        nand_write_page_raw(mtd, chip, buf, oob_required, page);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 enum {
@@ -285,17 +269,14 @@ static int micron_nand_init(struct nand_chip *chip)
                        return -EINVAL;
                }
-                chip->ecc.options = NAND_ECC_CUSTOM_PAGE_ACCESS;
                chip->ecc.bytes = 8;
                chip->ecc.size = 512;
                chip->ecc.strength = 4;
                chip->ecc.algo = NAND_ECC_BCH;
                chip->ecc.read_page = micron_nand_read_page_on_die_ecc;
                chip->ecc.write_page = micron_nand_write_page_on_die_ecc;
-                chip->ecc.read_page_raw =
+                chip->ecc.read_page_raw = nand_read_page_raw;
-                        micron_nand_read_page_raw_on_die_ecc;
+                chip->ecc.write_page_raw = nand_write_page_raw;
-                chip->ecc.write_page_raw =
-                        micron_nand_write_page_raw_on_die_ecc;
                mtd_set_ooblayout(mtd, &micron_nand_on_die_ooblayout_ops);
        }
diff --git a/drivers/mtd/nand/nand_samsung.c b/drivers/mtd/nand/nand_samsung.c
index d348f0129ae7..ef022f62f74c 100644
--- a/drivers/mtd/nand/nand_samsung.c
+++ b/drivers/mtd/nand/nand_samsung.c
@@ -91,6 +91,25 @@ static void samsung_nand_decode_id(struct nand_chip *chip)
                }
        } else {
                nand_decode_ext_id(chip);
+                if (nand_is_slc(chip)) {
+                        switch (chip->id.data[1]) {
+                        /* K9F4G08U0D-S[I|C]B0(T00) */
+                        case 0xDC:
+                                chip->ecc_step_ds = 512;
+                                chip->ecc_strength_ds = 1;
+                                break;
+                        /* K9F1G08U0E 21nm chips do not support subpage write */
+                        case 0xF1:
+                                if (chip->id.len > 4 &&
+                                    (chip->id.data[4] & GENMASK(1, 0)) == 0x1)
+                                        chip->options |= NAND_NO_SUBPAGE_WRITE;
+                                break;
+                        default:
+                                break;
+                        }
+                }
        }
 }
diff --git a/drivers/mtd/nand/nand_timings.c b/drivers/mtd/nand/nand_timings.c
index 5d1533bcc5bd..9400d039ddbd 100644
--- a/drivers/mtd/nand/nand_timings.c
+++ b/drivers/mtd/nand/nand_timings.c
@@ -283,16 +283,16 @@ const struct nand_sdr_timings *onfi_async_timing_mode_to_sdr_timings(int mode)
 EXPORT_SYMBOL(onfi_async_timing_mode_to_sdr_timings);
 /**
- * onfi_init_data_interface - [NAND Interface] Initialize a data interface from
+ * onfi_fill_data_interface - [NAND Interface] Initialize a data interface from
 * given ONFI mode
- * @iface: The data interface to be initialized
 * @mode: The ONFI timing mode
 */
-int onfi_init_data_interface(struct nand_chip *chip,
+int onfi_fill_data_interface(struct nand_chip *chip,
-                             struct nand_data_interface *iface,
                             enum nand_data_interface_type type,
                             int timing_mode)
 {
+        struct nand_data_interface *iface = &chip->data_interface;
        if (type != NAND_SDR_IFACE)
                return -EINVAL;
@@ -321,15 +321,4 @@ int onfi_init_data_interface(struct nand_chip *chip,
        return 0;
 }
-EXPORT_SYMBOL(onfi_init_data_interface);
+EXPORT_SYMBOL(onfi_fill_data_interface);
-/**
- * nand_get_default_data_interface - [NAND Interface] Retrieve NAND
- * data interface for mode 0. This is used as default timing after
- * reset.
- */
-const struct nand_data_interface *nand_get_default_data_interface(void)
-{
-        return &onfi_sdr_timings[0];
-}
-EXPORT_SYMBOL(nand_get_default_data_interface);
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index dad438c4906a..8cdf7d3d8fa7 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -1530,7 +1530,9 @@ static int omap_write_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
                               const uint8_t *buf, int oob_required, int page)
 {
        int ret;
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        /* Enable GPMC ecc engine */
        chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
@@ -1548,7 +1550,8 @@ static int omap_write_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
        /* Write ecc vector to OOB area */
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /**
@@ -1568,7 +1571,7 @@ static int omap_write_subpage_bch(struct mtd_info *mtd,
                                  u32 data_len, const u8 *buf,
                                  int oob_required, int page)
 {
-        u8 *ecc_calc = chip->buffers->ecccalc;
+        u8 *ecc_calc = chip->ecc.calc_buf;
        int ecc_size      = chip->ecc.size;
        int ecc_bytes     = chip->ecc.bytes;
        int ecc_steps     = chip->ecc.steps;
@@ -1582,6 +1585,7 @@ static int omap_write_subpage_bch(struct mtd_info *mtd,
         * ECC is calculated for all subpages but we choose
         * only what we want.
         */
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        /* Enable GPMC ECC engine */
        chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
@@ -1605,7 +1609,7 @@ static int omap_write_subpage_bch(struct mtd_info *mtd,
        /* copy calculated ECC for whole page to chip->buffer->oob */
        /* this include masked-value(0xFF) for unwritten subpages */
-        ecc_calc = chip->buffers->ecccalc;
+        ecc_calc = chip->ecc.calc_buf;
        ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
                                         chip->ecc.total);
        if (ret)
@@ -1614,7 +1618,7 @@ static int omap_write_subpage_bch(struct mtd_info *mtd,
        /* write OOB buffer to NAND device */
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 /**
@@ -1635,11 +1639,13 @@ static int omap_write_subpage_bch(struct mtd_info *mtd,
 static int omap_read_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
                                uint8_t *buf, int oob_required, int page)
 {
-        uint8_t *ecc_calc = chip->buffers->ecccalc;
+        uint8_t *ecc_calc = chip->ecc.calc_buf;
-        uint8_t *ecc_code = chip->buffers->ecccode;
+        uint8_t *ecc_code = chip->ecc.code_buf;
        int stat, ret;
        unsigned int max_bitflips = 0;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        /* Enable GPMC ecc engine */
        chip->ecc.hwctl(mtd, NAND_ECC_READ);
@@ -1647,10 +1653,10 @@ static int omap_read_page_bch(struct mtd_info *mtd, struct nand_chip *chip,
        chip->read_buf(mtd, buf, mtd->writesize);
        /* Read oob bytes */
-        chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
+        nand_change_read_column_op(chip,
-                      mtd->writesize + BADBLOCK_MARKER_LENGTH, -1);
+                                   mtd->writesize + BADBLOCK_MARKER_LENGTH,
-        chip->read_buf(mtd, chip->oob_poi + BADBLOCK_MARKER_LENGTH,
+                                   chip->oob_poi + BADBLOCK_MARKER_LENGTH,
-                       chip->ecc.total);
+                                   chip->ecc.total, false);
        /* Calculate ecc bytes */
        omap_calculate_ecc_bch_multi(mtd, buf, ecc_calc);
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index 90b9a9ccbe60..021374fe59dc 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -520,15 +520,13 @@ static int pxa3xx_nand_init_timings_compat(struct pxa3xx_nand_host *host,
        struct nand_chip *chip = &host->chip;
        struct pxa3xx_nand_info *info = host->info_data;
        const struct pxa3xx_nand_flash *f = NULL;
-        struct mtd_info *mtd = nand_to_mtd(&host->chip);
        int i, id, ntypes;
+        u8 idbuf[2];
        ntypes = ARRAY_SIZE(builtin_flash_types);
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
+        nand_readid_op(chip, 0, idbuf, sizeof(idbuf));
+        id = idbuf[0] | (idbuf[1] << 8);
-        id = chip->read_byte(mtd);
-        id |= chip->read_byte(mtd) << 0x8;
        for (i = 0; i < ntypes; i++) {
                f = &builtin_flash_types[i];
@@ -1350,10 +1348,10 @@ static int pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
                struct nand_chip *chip, const uint8_t *buf, int oob_required,
                int page)
 {
-        chip->write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
@@ -1363,7 +1361,7 @@ static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
        struct pxa3xx_nand_host *host = nand_get_controller_data(chip);
        struct pxa3xx_nand_info *info = host->info_data;
-        chip->read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        if (info->retcode == ERR_CORERR && info->use_ecc) {
diff --git a/drivers/mtd/nand/qcom_nandc.c b/drivers/mtd/nand/qcom_nandc.c
index 2656c1ac5646..6be555806eca 100644
--- a/drivers/mtd/nand/qcom_nandc.c
+++ b/drivers/mtd/nand/qcom_nandc.c
@@ -1725,6 +1725,7 @@ static int qcom_nandc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        u8 *data_buf, *oob_buf = NULL;
        int ret;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        data_buf = buf;
        oob_buf = oob_required ? chip->oob_poi : NULL;
@@ -1750,6 +1751,7 @@ static int qcom_nandc_read_page_raw(struct mtd_info *mtd,
        int i, ret;
        int read_loc;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        data_buf = buf;
        oob_buf = chip->oob_poi;
@@ -1850,6 +1852,8 @@ static int qcom_nandc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        u8 *data_buf, *oob_buf;
        int i, ret;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        clear_read_regs(nandc);
        clear_bam_transaction(nandc);
@@ -1902,6 +1906,9 @@ static int qcom_nandc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        free_descs(nandc);
+        if (!ret)
+                ret = nand_prog_page_end_op(chip);
        return ret;
 }
@@ -1916,6 +1923,7 @@ static int qcom_nandc_write_page_raw(struct mtd_info *mtd,
        u8 *data_buf, *oob_buf;
        int i, ret;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        clear_read_regs(nandc);
        clear_bam_transaction(nandc);
@@ -1970,6 +1978,9 @@ static int qcom_nandc_write_page_raw(struct mtd_info *mtd,
        free_descs(nandc);
+        if (!ret)
+                ret = nand_prog_page_end_op(chip);
        return ret;
 }
@@ -1990,7 +2001,7 @@ static int qcom_nandc_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
        struct nand_ecc_ctrl *ecc = &chip->ecc;
        u8 *oob = chip->oob_poi;
        int data_size, oob_size;
-        int ret, status = 0;
+        int ret;
        host->use_ecc = true;
@@ -2027,11 +2038,7 @@ static int qcom_nandc_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
                return -EIO;
        }
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 static int qcom_nandc_block_bad(struct mtd_info *mtd, loff_t ofs)
@@ -2081,7 +2088,7 @@ static int qcom_nandc_block_markbad(struct mtd_info *mtd, loff_t ofs)
        struct qcom_nand_host *host = to_qcom_nand_host(chip);
        struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip);
        struct nand_ecc_ctrl *ecc = &chip->ecc;
-        int page, ret, status = 0;
+        int page, ret;
        clear_read_regs(nandc);
        clear_bam_transaction(nandc);
@@ -2114,11 +2121,7 @@ static int qcom_nandc_block_markbad(struct mtd_info *mtd, loff_t ofs)
                return -EIO;
        }
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 /*
@@ -2636,6 +2639,9 @@ static int qcom_nand_host_init(struct qcom_nand_controller *nandc,
        nand_set_flash_node(chip, dn);
        mtd->name = devm_kasprintf(dev, GFP_KERNEL, "qcom_nand.%d", host->cs);
+        if (!mtd->name)
+                return -ENOMEM;
        mtd->owner = THIS_MODULE;
        mtd->dev.parent = dev;
diff --git a/drivers/mtd/nand/r852.c b/drivers/mtd/nand/r852.c
index fc9287af4614..595635b9e9de 100644
--- a/drivers/mtd/nand/r852.c
+++ b/drivers/mtd/nand/r852.c
@@ -364,7 +364,7 @@ static int r852_wait(struct mtd_info *mtd, struct nand_chip *chip)
        struct r852_device *dev = nand_get_controller_data(chip);
        unsigned long timeout;
-        int status;
+        u8 status;
        timeout = jiffies + (chip->state == FL_ERASING ?
                msecs_to_jiffies(400) : msecs_to_jiffies(20));
@@ -373,8 +373,7 @@ static int r852_wait(struct mtd_info *mtd, struct nand_chip *chip)
                if (chip->dev_ready(mtd))
                        break;
-        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        nand_status_op(chip, &status);
-        status = (int)chip->read_byte(mtd);
        /* Unfortunelly, no way to send detailed error status... */
        if (dev->dma_error) {
@@ -522,9 +521,7 @@ exit:
 static int r852_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
                             int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+        return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize);
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
 }
 /*
@@ -1046,7 +1043,7 @@ static int r852_resume(struct device *device)
        if (dev->card_registred) {
                r852_engine_enable(dev);
                dev->chip->select_chip(mtd, 0);
-                dev->chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+                nand_reset_op(dev->chip);
                dev->chip->select_chip(mtd, -1);
        }
diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
index 3c5008a4f5f3..c4e7755448e6 100644
--- a/drivers/mtd/nand/sh_flctl.c
+++ b/drivers/mtd/nand/sh_flctl.c
@@ -614,7 +614,7 @@ static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_va
 static int flctl_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                                uint8_t *buf, int oob_required, int page)
 {
-        chip->read_buf(mtd, buf, mtd->writesize);
+        nand_read_page_op(chip, page, 0, buf, mtd->writesize);
        if (oob_required)
                chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
        return 0;
@@ -624,9 +624,9 @@ static int flctl_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                                  const uint8_t *buf, int oob_required,
                                  int page)
 {
-        chip->write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static void execmd_read_page_sector(struct mtd_info *mtd, int page_addr)
diff --git a/drivers/mtd/nand/sm_common.h b/drivers/mtd/nand/sm_common.h
index d3e028e58b0f..1581671b05ae 100644
--- a/drivers/mtd/nand/sm_common.h
+++ b/drivers/mtd/nand/sm_common.h
@@ -36,7 +36,7 @@ struct sm_oob {
 #define SM_SMALL_OOB_SIZE       8
-extern int sm_register_device(struct mtd_info *mtd, int smartmedia);
+int sm_register_device(struct mtd_info *mtd, int smartmedia);
 static inline int sm_sector_valid(struct sm_oob *oob)
diff --git a/drivers/mtd/nand/sunxi_nand.c b/drivers/mtd/nand/sunxi_nand.c
index 82244be3e766..f5a55c63935c 100644
--- a/drivers/mtd/nand/sunxi_nand.c
+++ b/drivers/mtd/nand/sunxi_nand.c
@@ -958,12 +958,12 @@ static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd,
        int ret;
        if (*cur_off != data_off)
-                nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1);
+                nand_change_read_column_op(nand, data_off, NULL, 0, false);
        sunxi_nfc_randomizer_read_buf(mtd, NULL, ecc->size, false, page);
        if (data_off + ecc->size != oob_off)
-                nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
+                nand_change_read_column_op(nand, oob_off, NULL, 0, false);
        ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
        if (ret)
@@ -991,16 +991,15 @@ static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd,
                 * Re-read the data with the randomizer disabled to identify
                 * bitflips in erased pages.
                 */
-                if (nand->options & NAND_NEED_SCRAMBLING) {
+                if (nand->options & NAND_NEED_SCRAMBLING)
-                        nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1);
+                        nand_change_read_column_op(nand, data_off, data,
-                        nand->read_buf(mtd, data, ecc->size);
+                                                   ecc->size, false);
-                } else {
+                else
                        memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE,
                                      ecc->size);
-                }
-                nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
+                nand_change_read_column_op(nand, oob_off, oob, ecc->bytes + 4,
-                nand->read_buf(mtd, oob, ecc->bytes + 4);
+                                           false);
                ret = nand_check_erased_ecc_chunk(data, ecc->size,
                                                  oob, ecc->bytes + 4,
@@ -1011,7 +1010,8 @@ static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd,
                memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE, ecc->size);
                if (oob_required) {
-                        nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
+                        nand_change_read_column_op(nand, oob_off, NULL, 0,
+                                                   false);
                        sunxi_nfc_randomizer_read_buf(mtd, oob, ecc->bytes + 4,
                                                      true, page);
@@ -1038,8 +1038,8 @@ static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info *mtd,
                return;
        if (!cur_off || *cur_off != offset)
-                nand->cmdfunc(mtd, NAND_CMD_RNDOUT,
+                nand_change_read_column_op(nand, mtd->writesize, NULL, 0,
-                              offset + mtd->writesize, -1);
+                                           false);
        if (!randomize)
                sunxi_nfc_read_buf(mtd, oob + offset, len);
@@ -1116,9 +1116,9 @@ static int sunxi_nfc_hw_ecc_read_chunks_dma(struct mtd_info *mtd, uint8_t *buf,
                if (oob_required && !erased) {
                        /* TODO: use DMA to retrieve OOB */
-                        nand->cmdfunc(mtd, NAND_CMD_RNDOUT,
+                        nand_change_read_column_op(nand,
-                                      mtd->writesize + oob_off, -1);
+                                                   mtd->writesize + oob_off,
-                        nand->read_buf(mtd, oob, ecc->bytes + 4);
+                                                   oob, ecc->bytes + 4, false);
                        sunxi_nfc_hw_ecc_get_prot_oob_bytes(mtd, oob, i,
                                                            !i, page);
@@ -1143,18 +1143,17 @@ static int sunxi_nfc_hw_ecc_read_chunks_dma(struct mtd_info *mtd, uint8_t *buf,
                        /*
                         * Re-read the data with the randomizer disabled to
                         * identify bitflips in erased pages.
+                         * TODO: use DMA to read page in raw mode
                         */
-                        if (randomized) {
+                        if (randomized)
-                                /* TODO: use DMA to read page in raw mode */
+                                nand_change_read_column_op(nand, data_off,
-                                nand->cmdfunc(mtd, NAND_CMD_RNDOUT,
+                                                           data, ecc->size,
-                                              data_off, -1);
+                                                           false);
-                                nand->read_buf(mtd, data, ecc->size);
-                        }
                        /* TODO: use DMA to retrieve OOB */
-                        nand->cmdfunc(mtd, NAND_CMD_RNDOUT,
+                        nand_change_read_column_op(nand,
-                                      mtd->writesize + oob_off, -1);
+                                                   mtd->writesize + oob_off,
-                        nand->read_buf(mtd, oob, ecc->bytes + 4);
+                                                   oob, ecc->bytes + 4, false);
                        ret = nand_check_erased_ecc_chunk(data, ecc->size,
                                                          oob, ecc->bytes + 4,
@@ -1187,12 +1186,12 @@ static int sunxi_nfc_hw_ecc_write_chunk(struct mtd_info *mtd,
        int ret;
        if (data_off != *cur_off)
-                nand->cmdfunc(mtd, NAND_CMD_RNDIN, data_off, -1);
+                nand_change_write_column_op(nand, data_off, NULL, 0, false);
        sunxi_nfc_randomizer_write_buf(mtd, data, ecc->size, false, page);
        if (data_off + ecc->size != oob_off)
-                nand->cmdfunc(mtd, NAND_CMD_RNDIN, oob_off, -1);
+                nand_change_write_column_op(nand, oob_off, NULL, 0, false);
        ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
        if (ret)
@@ -1228,8 +1227,8 @@ static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info *mtd,
                return;
        if (!cur_off || *cur_off != offset)
-                nand->cmdfunc(mtd, NAND_CMD_RNDIN,
+                nand_change_write_column_op(nand, offset + mtd->writesize,
-                              offset + mtd->writesize, -1);
+                                            NULL, 0, false);
        sunxi_nfc_randomizer_write_buf(mtd, oob + offset, len, false, page);
@@ -1246,6 +1245,8 @@ static int sunxi_nfc_hw_ecc_read_page(struct mtd_info *mtd,
        int ret, i, cur_off = 0;
        bool raw_mode = false;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = 0; i < ecc->steps; i++) {
@@ -1279,14 +1280,14 @@ static int sunxi_nfc_hw_ecc_read_page_dma(struct mtd_info *mtd,
 {
        int ret;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        ret = sunxi_nfc_hw_ecc_read_chunks_dma(mtd, buf, oob_required, page,
                                               chip->ecc.steps);
        if (ret >= 0)
                return ret;
        /* Fallback to PIO mode */
-        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, 0, -1);
        return sunxi_nfc_hw_ecc_read_page(mtd, chip, buf, oob_required, page);
 }
@@ -1299,6 +1300,8 @@ static int sunxi_nfc_hw_ecc_read_subpage(struct mtd_info *mtd,
        int ret, i, cur_off = 0;
        unsigned int max_bitflips = 0;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = data_offs / ecc->size;
@@ -1330,13 +1333,13 @@ static int sunxi_nfc_hw_ecc_read_subpage_dma(struct mtd_info *mtd,
        int nchunks = DIV_ROUND_UP(data_offs + readlen, chip->ecc.size);
        int ret;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        ret = sunxi_nfc_hw_ecc_read_chunks_dma(mtd, buf, false, page, nchunks);
        if (ret >= 0)
                return ret;
        /* Fallback to PIO mode */
-        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, 0, -1);
        return sunxi_nfc_hw_ecc_read_subpage(mtd, chip, data_offs, readlen,
                                             buf, page);
 }
@@ -1349,6 +1352,8 @@ static int sunxi_nfc_hw_ecc_write_page(struct mtd_info *mtd,
        struct nand_ecc_ctrl *ecc = &chip->ecc;
        int ret, i, cur_off = 0;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = 0; i < ecc->steps; i++) {
@@ -1370,7 +1375,7 @@ static int sunxi_nfc_hw_ecc_write_page(struct mtd_info *mtd,
        sunxi_nfc_hw_ecc_disable(mtd);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd,
@@ -1382,6 +1387,8 @@ static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd,
        struct nand_ecc_ctrl *ecc = &chip->ecc;
        int ret, i, cur_off = 0;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = data_offs / ecc->size;
@@ -1400,7 +1407,7 @@ static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd,
        sunxi_nfc_hw_ecc_disable(mtd);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int sunxi_nfc_hw_ecc_write_page_dma(struct mtd_info *mtd,
@@ -1430,6 +1437,8 @@ static int sunxi_nfc_hw_ecc_write_page_dma(struct mtd_info *mtd,
                sunxi_nfc_hw_ecc_set_prot_oob_bytes(mtd, oob, i, !i, page);
        }
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        sunxi_nfc_randomizer_config(mtd, page, false);
        sunxi_nfc_randomizer_enable(mtd);
@@ -1460,7 +1469,7 @@ static int sunxi_nfc_hw_ecc_write_page_dma(struct mtd_info *mtd,
                sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi,
                                                 NULL, page);
-        return 0;
+        return nand_prog_page_end_op(chip);
 pio_fallback:
        return sunxi_nfc_hw_ecc_write_page(mtd, chip, buf, oob_required, page);
@@ -1476,6 +1485,8 @@ static int sunxi_nfc_hw_syndrome_ecc_read_page(struct mtd_info *mtd,
        int ret, i, cur_off = 0;
        bool raw_mode = false;
+        nand_read_page_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = 0; i < ecc->steps; i++) {
@@ -1512,6 +1523,8 @@ static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info *mtd,
        struct nand_ecc_ctrl *ecc = &chip->ecc;
        int ret, i, cur_off = 0;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        sunxi_nfc_hw_ecc_enable(mtd);
        for (i = 0; i < ecc->steps; i++) {
@@ -1533,41 +1546,33 @@ static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info *mtd,
        sunxi_nfc_hw_ecc_disable(mtd);
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static int sunxi_nfc_hw_common_ecc_read_oob(struct mtd_info *mtd,
                                            struct nand_chip *chip,
                                            int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
        chip->pagebuf = -1;
-        return chip->ecc.read_page(mtd, chip, chip->buffers->databuf, 1, page);
+        return chip->ecc.read_page(mtd, chip, chip->data_buf, 1, page);
 }
 static int sunxi_nfc_hw_common_ecc_write_oob(struct mtd_info *mtd,
                                             struct nand_chip *chip,
                                             int page)
 {
-        int ret, status;
+        int ret;
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
        chip->pagebuf = -1;
-        memset(chip->buffers->databuf, 0xff, mtd->writesize);
+        memset(chip->data_buf, 0xff, mtd->writesize);
-        ret = chip->ecc.write_page(mtd, chip, chip->buffers->databuf, 1, page);
+        ret = chip->ecc.write_page(mtd, chip, chip->data_buf, 1, page);
        if (ret)
                return ret;
        /* Send command to program the OOB data */
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        status = chip->waitfunc(mtd, chip);
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
 }
 static const s32 tWB_lut[] = {6, 12, 16, 20};
@@ -1853,8 +1858,14 @@ static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd,
        /* Add ECC info retrieval from DT */
        for (i = 0; i < ARRAY_SIZE(strengths); i++) {
-                if (ecc->strength <= strengths[i])
+                if (ecc->strength <= strengths[i]) {
+                        /*
+                         * Update ecc->strength value with the actual strength
+                         * that will be used by the ECC engine.
+                         */
+                        ecc->strength = strengths[i];
                        break;
+                }
        }
        if (i >= ARRAY_SIZE(strengths)) {
diff --git a/drivers/mtd/nand/tango_nand.c b/drivers/mtd/nand/tango_nand.c
index 766906f03943..c5bee00b7f5e 100644
--- a/drivers/mtd/nand/tango_nand.c
+++ b/drivers/mtd/nand/tango_nand.c
@@ -329,7 +329,7 @@ static void aux_read(struct nand_chip *chip, u8 **buf, int len, int *pos)
        if (!*buf) {
                /* skip over "len" bytes */
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT, *pos, -1);
+                nand_change_read_column_op(chip, *pos, NULL, 0, false);
        } else {
                tango_read_buf(mtd, *buf, len);
                *buf += len;
@@ -344,7 +344,7 @@ static void aux_write(struct nand_chip *chip, const u8 **buf, int len, int *pos)
        if (!*buf) {
                /* skip over "len" bytes */
-                chip->cmdfunc(mtd, NAND_CMD_RNDIN, *pos, -1);
+                nand_change_write_column_op(chip, *pos, NULL, 0, false);
        } else {
                tango_write_buf(mtd, *buf, len);
                *buf += len;
@@ -427,7 +427,7 @@ static void raw_write(struct nand_chip *chip, const u8 *buf, const u8 *oob)
 static int tango_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                               u8 *buf, int oob_required, int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+        nand_read_page_op(chip, page, 0, NULL, 0);
        raw_read(chip, buf, chip->oob_poi);
        return 0;
 }
@@ -435,23 +435,15 @@ static int tango_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
 static int tango_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                const u8 *buf, int oob_required, int page)
 {
-        int status;
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
        raw_write(chip, buf, chip->oob_poi);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        status = chip->waitfunc(mtd, chip);
-        if (status & NAND_STATUS_FAIL)
-                return -EIO;
-        return 0;
 }
 static int tango_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
                          int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+        nand_read_page_op(chip, page, 0, NULL, 0);
        raw_read(chip, NULL, chip->oob_poi);
        return 0;
 }
@@ -459,11 +451,9 @@ static int tango_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
 static int tango_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
                           int page)
 {
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
+        nand_prog_page_begin_op(chip, page, 0, NULL, 0);
        raw_write(chip, NULL, chip->oob_poi);
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        return nand_prog_page_end_op(chip);
-        chip->waitfunc(mtd, chip);
-        return 0;
 }
 static int oob_ecc(struct mtd_info *mtd, int idx, struct mtd_oob_region *res)
@@ -590,7 +580,6 @@ static int chip_init(struct device *dev, struct device_node *np)
        ecc->write_page = tango_write_page;
        ecc->read_oob = tango_read_oob;
        ecc->write_oob = tango_write_oob;
-        ecc->options = NAND_ECC_CUSTOM_PAGE_ACCESS;
        err = nand_scan_tail(mtd);
        if (err)
diff --git a/drivers/mtd/nand/tmio_nand.c b/drivers/mtd/nand/tmio_nand.c
index 84dbf32332e1..dcaa924502de 100644
--- a/drivers/mtd/nand/tmio_nand.c
+++ b/drivers/mtd/nand/tmio_nand.c
@@ -192,6 +192,7 @@ tmio_nand_wait(struct mtd_info *mtd, struct nand_chip *nand_chip)
 {
        struct tmio_nand *tmio = mtd_to_tmio(mtd);
        long timeout;
+        u8 status;
        /* enable RDYREQ interrupt */
        tmio_iowrite8(0x0f, tmio->fcr + FCR_ISR);
@@ -212,8 +213,8 @@ tmio_nand_wait(struct mtd_info *mtd, struct nand_chip *nand_chip)
                dev_warn(&tmio->dev->dev, "timeout waiting for interrupt\n");
        }
-        nand_chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        nand_status_op(nand_chip, &status);
-        return nand_chip->read_byte(mtd);
+        return status;
 }
 /*
diff --git a/drivers/mtd/nand/vf610_nfc.c b/drivers/mtd/nand/vf610_nfc.c
index 8037d4b48a05..80d31a58e558 100644
--- a/drivers/mtd/nand/vf610_nfc.c
+++ b/drivers/mtd/nand/vf610_nfc.c
@@ -560,7 +560,7 @@ static int vf610_nfc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
        int eccsize = chip->ecc.size;
        int stat;
-        vf610_nfc_read_buf(mtd, buf, eccsize);
+        nand_read_page_op(chip, page, 0, buf, eccsize);
        if (oob_required)
                vf610_nfc_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -580,7 +580,7 @@ static int vf610_nfc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
 {
        struct vf610_nfc *nfc = mtd_to_nfc(mtd);
-        vf610_nfc_write_buf(mtd, buf, mtd->writesize);
+        nand_prog_page_begin_op(chip, page, 0, buf, mtd->writesize);
        if (oob_required)
                vf610_nfc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -588,7 +588,7 @@ static int vf610_nfc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
        nfc->use_hw_ecc = true;
        nfc->write_sz = mtd->writesize + mtd->oobsize;
-        return 0;
+        return nand_prog_page_end_op(chip);
 }
 static const struct of_device_id vf610_nfc_dt_ids[] = {
diff --git a/drivers/mtd/onenand/Kconfig b/drivers/mtd/onenand/Kconfig
index dcae2f6a2b11..9dc15748947b 100644
--- a/drivers/mtd/onenand/Kconfig
+++ b/drivers/mtd/onenand/Kconfig
@@ -4,8 +4,7 @@ menuconfig MTD_ONENAND
        depends on HAS_IOMEM
        help
          This enables support for accessing all type of OneNAND flash
-          devices. For further information see
+          devices.
-          <http://www.samsung.com/Products/Semiconductor/OneNAND/index.htm>
 if MTD_ONENAND
@@ -26,9 +25,11 @@ config MTD_ONENAND_GENERIC
 config MTD_ONENAND_OMAP2
        tristate "OneNAND on OMAP2/OMAP3 support"
        depends on ARCH_OMAP2 || ARCH_OMAP3
+        depends on OF || COMPILE_TEST
        help
-          Support for a OneNAND flash device connected to an OMAP2/OMAP3 CPU
+          Support for a OneNAND flash device connected to an OMAP2/OMAP3 SoC
          via the GPMC memory controller.
+          Enable dmaengine and gpiolib for better performance.
 config MTD_ONENAND_SAMSUNG
        tristate "OneNAND on Samsung SOC controller support"
diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c
index 24a1388d3031..87c34f607a75 100644
--- a/drivers/mtd/onenand/omap2.c
+++ b/drivers/mtd/onenand/omap2.c
@@ -28,19 +28,18 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/onenand.h>
 #include <linux/mtd/partitions.h>
+#include <linux/of_device.h>
+#include <linux/omap-gpmc.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <linux/regulator/consumer.h>
+#include <linux/gpio/consumer.h>
-#include <linux/gpio.h>
 #include <asm/mach/flash.h>
-#include <linux/platform_data/mtd-onenand-omap2.h>
-#include <linux/omap-dma.h>
 #define DRIVER_NAME "omap2-onenand"
@@ -50,24 +49,17 @@ struct omap2_onenand {
        struct platform_device *pdev;
        int gpmc_cs;
        unsigned long phys_base;
-        unsigned int mem_size;
+        struct gpio_desc *int_gpiod;
-        int gpio_irq;
        struct mtd_info mtd;
        struct onenand_chip onenand;
        struct completion irq_done;
        struct completion dma_done;
-        int dma_channel;
+        struct dma_chan *dma_chan;
-        int freq;
-        int (*setup)(void __iomem *base, int *freq_ptr);
-        struct regulator *regulator;
-        u8 flags;
 };
-static void omap2_onenand_dma_cb(int lch, u16 ch_status, void *data)
+static void omap2_onenand_dma_complete_func(void *completion)
 {
-        struct omap2_onenand *c = data;
+        complete(completion);
-        complete(&c->dma_done);
 }
 static irqreturn_t omap2_onenand_interrupt(int irq, void *dev_id)
@@ -90,6 +82,65 @@ static inline void write_reg(struct omap2_onenand *c, unsigned short value,
        writew(value, c->onenand.base + reg);
 }
+static int omap2_onenand_set_cfg(struct omap2_onenand *c,
+                                 bool sr, bool sw,
+                                 int latency, int burst_len)
+{
+        unsigned short reg = ONENAND_SYS_CFG1_RDY | ONENAND_SYS_CFG1_INT;
+        reg |= latency << ONENAND_SYS_CFG1_BRL_SHIFT;
+        switch (burst_len) {
+        case 0:         /* continuous */
+                break;
+        case 4:
+                reg |= ONENAND_SYS_CFG1_BL_4;
+                break;
+        case 8:
+                reg |= ONENAND_SYS_CFG1_BL_8;
+                break;
+        case 16:
+                reg |= ONENAND_SYS_CFG1_BL_16;
+                break;
+        case 32:
+                reg |= ONENAND_SYS_CFG1_BL_32;
+                break;
+        default:
+                return -EINVAL;
+        }
+        if (latency > 5)
+                reg |= ONENAND_SYS_CFG1_HF;
+        if (latency > 7)
+                reg |= ONENAND_SYS_CFG1_VHF;
+        if (sr)
+                reg |= ONENAND_SYS_CFG1_SYNC_READ;
+        if (sw)
+                reg |= ONENAND_SYS_CFG1_SYNC_WRITE;
+        write_reg(c, reg, ONENAND_REG_SYS_CFG1);
+        return 0;
+}
+static int omap2_onenand_get_freq(int ver)
+{
+        switch ((ver >> 4) & 0xf) {
+        case 0:
+                return 40;
+        case 1:
+                return 54;
+        case 2:
+                return 66;
+        case 3:
+                return 83;
+        case 4:
+                return 104;
+        }
+        return -EINVAL;
+}
 static void wait_err(char *msg, int state, unsigned int ctrl, unsigned int intr)
 {
        printk(KERN_ERR "onenand_wait: %s! state %d ctrl 0x%04x intr 0x%04x\n",
@@ -153,28 +204,22 @@ static int omap2_onenand_wait(struct mtd_info *mtd, int state)
                if (!(syscfg & ONENAND_SYS_CFG1_IOBE)) {
                        syscfg |= ONENAND_SYS_CFG1_IOBE;
                        write_reg(c, syscfg, ONENAND_REG_SYS_CFG1);
-                        if (c->flags & ONENAND_IN_OMAP34XX)
+                        /* Add a delay to let GPIO settle */
-                                /* Add a delay to let GPIO settle */
+                        syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
-                                syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
                }
                reinit_completion(&c->irq_done);
-                if (c->gpio_irq) {
+                result = gpiod_get_value(c->int_gpiod);
-                        result = gpio_get_value(c->gpio_irq);
+                if (result < 0) {
-                        if (result == -1) {
+                        ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
-                                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+                        intr = read_reg(c, ONENAND_REG_INTERRUPT);
-                                intr = read_reg(c, ONENAND_REG_INTERRUPT);
+                        wait_err("gpio error", state, ctrl, intr);
-                                wait_err("gpio error", state, ctrl, intr);
+                        return result;
-                                return -EIO;
+                } else if (result == 0) {
-                        }
-                } else
-                        result = 0;
-                if (result == 0) {
                        int retry_cnt = 0;
 retry:
-                        result = wait_for_completion_timeout(&c->irq_done,
+                        if (!wait_for_completion_io_timeout(&c->irq_done,
-                                                    msecs_to_jiffies(20));
+                                                msecs_to_jiffies(20))) {
-                        if (result == 0) {
                                /* Timeout after 20ms */
                                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
                                if (ctrl & ONENAND_CTRL_ONGO &&
@@ -291,9 +336,42 @@ static inline int omap2_onenand_bufferram_offset(struct mtd_info *mtd, int area)
        return 0;
 }
-#if defined(CONFIG_ARCH_OMAP3) || defined(MULTI_OMAP2)
+static inline int omap2_onenand_dma_transfer(struct omap2_onenand *c,
+                                             dma_addr_t src, dma_addr_t dst,
+                                             size_t count)
+{
+        struct dma_async_tx_descriptor *tx;
+        dma_cookie_t cookie;
+        tx = dmaengine_prep_dma_memcpy(c->dma_chan, dst, src, count, 0);
+        if (!tx) {
+                dev_err(&c->pdev->dev, "Failed to prepare DMA memcpy\n");
+                return -EIO;
+        }
+        reinit_completion(&c->dma_done);
+        tx->callback = omap2_onenand_dma_complete_func;
+        tx->callback_param = &c->dma_done;
+        cookie = tx->tx_submit(tx);
+        if (dma_submit_error(cookie)) {
+                dev_err(&c->pdev->dev, "Failed to do DMA tx_submit\n");
+                return -EIO;
+        }
+        dma_async_issue_pending(c->dma_chan);
+        if (!wait_for_completion_io_timeout(&c->dma_done,
+                                            msecs_to_jiffies(20))) {
+                dmaengine_terminate_sync(c->dma_chan);
+                return -ETIMEDOUT;
+        }
+        return 0;
+}
-static int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
+static int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
                                        unsigned char *buffer, int offset,
                                        size_t count)
 {
@@ -301,10 +379,9 @@ static int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
        struct onenand_chip *this = mtd->priv;
        dma_addr_t dma_src, dma_dst;
        int bram_offset;
-        unsigned long timeout;
        void *buf = (void *)buffer;
        size_t xtra;
-        volatile unsigned *done;
+        int ret;
        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
        if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
@@ -341,25 +418,10 @@ static int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
                goto out_copy;
        }
-        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
+        ret = omap2_onenand_dma_transfer(c, dma_src, dma_dst, count);
-                                     count >> 2, 1, 0, 0, 0);
-        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                dma_src, 0, 0);
-        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                 dma_dst, 0, 0);
-        reinit_completion(&c->dma_done);
-        omap_start_dma(c->dma_channel);
-        timeout = jiffies + msecs_to_jiffies(20);
-        done = &c->dma_done.done;
-        while (time_before(jiffies, timeout))
-                if (*done)
-                        break;
        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_FROM_DEVICE);
-        if (!*done) {
+        if (ret) {
                dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
                goto out_copy;
        }
@@ -371,7 +433,7 @@ out_copy:
        return 0;
 }
-static int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
+static int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
                                         const unsigned char *buffer,
                                         int offset, size_t count)
 {
@@ -379,9 +441,8 @@ static int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
        struct onenand_chip *this = mtd->priv;
        dma_addr_t dma_src, dma_dst;
        int bram_offset;
-        unsigned long timeout;
        void *buf = (void *)buffer;
-        volatile unsigned *done;
+        int ret;
        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
        if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
@@ -412,25 +473,10 @@ static int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
                return -1;
        }
-        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
+        ret = omap2_onenand_dma_transfer(c, dma_src, dma_dst, count);
-                                     count >> 2, 1, 0, 0, 0);
-        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                dma_src, 0, 0);
-        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                 dma_dst, 0, 0);
-        reinit_completion(&c->dma_done);
-        omap_start_dma(c->dma_channel);
-        timeout = jiffies + msecs_to_jiffies(20);
-        done = &c->dma_done.done;
-        while (time_before(jiffies, timeout))
-                if (*done)
-                        break;
        dma_unmap_single(&c->pdev->dev, dma_src, count, DMA_TO_DEVICE);
-        if (!*done) {
+        if (ret) {
                dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
                goto out_copy;
        }
@@ -442,136 +488,6 @@ out_copy:
        return 0;
 }
-#else
-static int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
-                                        unsigned char *buffer, int offset,
-                                        size_t count)
-{
-        return -ENOSYS;
-}
-static int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
-                                         const unsigned char *buffer,
-                                         int offset, size_t count)
-{
-        return -ENOSYS;
-}
-#endif
-#if defined(CONFIG_ARCH_OMAP2) || defined(MULTI_OMAP2)
-static int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
-                                        unsigned char *buffer, int offset,
-                                        size_t count)
-{
-        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
-        struct onenand_chip *this = mtd->priv;
-        dma_addr_t dma_src, dma_dst;
-        int bram_offset;
-        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
-        /* DMA is not used.  Revisit PM requirements before enabling it. */
-        if (1 || (c->dma_channel < 0) ||
-            ((void *) buffer >= (void *) high_memory) || (bram_offset & 3) ||
-            (((unsigned int) buffer) & 3) || (count < 1024) || (count & 3)) {
-                memcpy(buffer, (__force void *)(this->base + bram_offset),
-                       count);
-                return 0;
-        }
-        dma_src = c->phys_base + bram_offset;
-        dma_dst = dma_map_single(&c->pdev->dev, buffer, count,
-                                 DMA_FROM_DEVICE);
-        if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
-                dev_err(&c->pdev->dev,
-                        "Couldn't DMA map a %d byte buffer\n",
-                        count);
-                return -1;
-        }
-        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
-                                     count / 4, 1, 0, 0, 0);
-        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                dma_src, 0, 0);
-        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                 dma_dst, 0, 0);
-        reinit_completion(&c->dma_done);
-        omap_start_dma(c->dma_channel);
-        wait_for_completion(&c->dma_done);
-        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_FROM_DEVICE);
-        return 0;
-}
-static int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
-                                         const unsigned char *buffer,
-                                         int offset, size_t count)
-{
-        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
-        struct onenand_chip *this = mtd->priv;
-        dma_addr_t dma_src, dma_dst;
-        int bram_offset;
-        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
-        /* DMA is not used.  Revisit PM requirements before enabling it. */
-        if (1 || (c->dma_channel < 0) ||
-            ((void *) buffer >= (void *) high_memory) || (bram_offset & 3) ||
-            (((unsigned int) buffer) & 3) || (count < 1024) || (count & 3)) {
-                memcpy((__force void *)(this->base + bram_offset), buffer,
-                       count);
-                return 0;
-        }
-        dma_src = dma_map_single(&c->pdev->dev, (void *) buffer, count,
-                                 DMA_TO_DEVICE);
-        dma_dst = c->phys_base + bram_offset;
-        if (dma_mapping_error(&c->pdev->dev, dma_src)) {
-                dev_err(&c->pdev->dev,
-                        "Couldn't DMA map a %d byte buffer\n",
-                        count);
-                return -1;
-        }
-        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S16,
-                                     count / 2, 1, 0, 0, 0);
-        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                dma_src, 0, 0);
-        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
-                                 dma_dst, 0, 0);
-        reinit_completion(&c->dma_done);
-        omap_start_dma(c->dma_channel);
-        wait_for_completion(&c->dma_done);
-        dma_unmap_single(&c->pdev->dev, dma_src, count, DMA_TO_DEVICE);
-        return 0;
-}
-#else
-static int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
-                                        unsigned char *buffer, int offset,
-                                        size_t count)
-{
-        return -ENOSYS;
-}
-static int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
-                                         const unsigned char *buffer,
-                                         int offset, size_t count)
-{
-        return -ENOSYS;
-}
-#endif
-static struct platform_driver omap2_onenand_driver;
 static void omap2_onenand_shutdown(struct platform_device *pdev)
 {
        struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
@@ -583,168 +499,117 @@ static void omap2_onenand_shutdown(struct platform_device *pdev)
        memset((__force void *)c->onenand.base, 0, ONENAND_BUFRAM_SIZE);
 }
-static int omap2_onenand_enable(struct mtd_info *mtd)
-{
-        int ret;
-        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
-        ret = regulator_enable(c->regulator);
-        if (ret != 0)
-                dev_err(&c->pdev->dev, "can't enable regulator\n");
-        return ret;
-}
-static int omap2_onenand_disable(struct mtd_info *mtd)
-{
-        int ret;
-        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
-        ret = regulator_disable(c->regulator);
-        if (ret != 0)
-                dev_err(&c->pdev->dev, "can't disable regulator\n");
-        return ret;
-}
 static int omap2_onenand_probe(struct platform_device *pdev)
 {
-        struct omap_onenand_platform_data *pdata;
+        u32 val;
-        struct omap2_onenand *c;
+        dma_cap_mask_t mask;
-        struct onenand_chip *this;
+        int freq, latency, r;
-        int r;
        struct resource *res;
+        struct omap2_onenand *c;
+        struct gpmc_onenand_info info;
+        struct device *dev = &pdev->dev;
+        struct device_node *np = dev->of_node;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "error getting memory resource\n");
+                return -EINVAL;
+        }
-        pdata = dev_get_platdata(&pdev->dev);
+        r = of_property_read_u32(np, "reg", &val);
-        if (pdata == NULL) {
+        if (r) {
-                dev_err(&pdev->dev, "platform data missing\n");
+                dev_err(dev, "reg not found in DT\n");
-                return -ENODEV;
+                return r;
        }
-        c = kzalloc(sizeof(struct omap2_onenand), GFP_KERNEL);
+        c = devm_kzalloc(dev, sizeof(struct omap2_onenand), GFP_KERNEL);
        if (!c)
                return -ENOMEM;
        init_completion(&c->irq_done);
        init_completion(&c->dma_done);
-        c->flags = pdata->flags;
+        c->gpmc_cs = val;
-        c->gpmc_cs = pdata->cs;
-        c->gpio_irq = pdata->gpio_irq;
-        c->dma_channel = pdata->dma_channel;
-        if (c->dma_channel < 0) {
-                /* if -1, don't use DMA */
-                c->gpio_irq = 0;
-        }
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
-                r = -EINVAL;
-                dev_err(&pdev->dev, "error getting memory resource\n");
-                goto err_kfree;
-        }
        c->phys_base = res->start;
-        c->mem_size = resource_size(res);
-        if (request_mem_region(c->phys_base, c->mem_size,
-                               pdev->dev.driver->name) == NULL) {
-                dev_err(&pdev->dev, "Cannot reserve memory region at 0x%08lx, size: 0x%x\n",
-                                                c->phys_base, c->mem_size);
-                r = -EBUSY;
-                goto err_kfree;
-        }
-        c->onenand.base = ioremap(c->phys_base, c->mem_size);
-        if (c->onenand.base == NULL) {
-                r = -ENOMEM;
-                goto err_release_mem_region;
-        }
-        if (pdata->onenand_setup != NULL) {
+        c->onenand.base = devm_ioremap_resource(dev, res);
-                r = pdata->onenand_setup(c->onenand.base, &c->freq);
+        if (IS_ERR(c->onenand.base))
-                if (r < 0) {
+                return PTR_ERR(c->onenand.base);
-                        dev_err(&pdev->dev, "Onenand platform setup failed: "
-                                "%d\n", r);
+        c->int_gpiod = devm_gpiod_get_optional(dev, "int", GPIOD_IN);
-                        goto err_iounmap;
+        if (IS_ERR(c->int_gpiod)) {
-                }
+                r = PTR_ERR(c->int_gpiod);
-                c->setup = pdata->onenand_setup;
+                /* Just try again if this happens */
+                if (r != -EPROBE_DEFER)
+                        dev_err(dev, "error getting gpio: %d\n", r);
+                return r;
        }
-        if (c->gpio_irq) {
+        if (c->int_gpiod) {
-                if ((r = gpio_request(c->gpio_irq, "OneNAND irq")) < 0) {
+                r = devm_request_irq(dev, gpiod_to_irq(c->int_gpiod),
-                        dev_err(&pdev->dev,  "Failed to request GPIO%d for "
+                                     omap2_onenand_interrupt,
-                                "OneNAND\n", c->gpio_irq);
+                                     IRQF_TRIGGER_RISING, "onenand", c);
-                        goto err_iounmap;
+                if (r)
-        }
+                        return r;
-        gpio_direction_input(c->gpio_irq);
-        if ((r = request_irq(gpio_to_irq(c->gpio_irq),
+                c->onenand.wait = omap2_onenand_wait;
-                             omap2_onenand_interrupt, IRQF_TRIGGER_RISING,
-                             pdev->dev.driver->name, c)) < 0)
-                goto err_release_gpio;
        }
-        if (c->dma_channel >= 0) {
+        dma_cap_zero(mask);
-                r = omap_request_dma(0, pdev->dev.driver->name,
+        dma_cap_set(DMA_MEMCPY, mask);
-                                     omap2_onenand_dma_cb, (void *) c,
-                                     &c->dma_channel);
-                if (r == 0) {
-                        omap_set_dma_write_mode(c->dma_channel,
-                                                OMAP_DMA_WRITE_NON_POSTED);
-                        omap_set_dma_src_data_pack(c->dma_channel, 1);
-                        omap_set_dma_src_burst_mode(c->dma_channel,
-                                                    OMAP_DMA_DATA_BURST_8);
-                        omap_set_dma_dest_data_pack(c->dma_channel, 1);
-                        omap_set_dma_dest_burst_mode(c->dma_channel,
-                                                     OMAP_DMA_DATA_BURST_8);
-                } else {
-                        dev_info(&pdev->dev,
-                                 "failed to allocate DMA for OneNAND, "
-                                 "using PIO instead\n");
-                        c->dma_channel = -1;
-                }
-        }
-        dev_info(&pdev->dev, "initializing on CS%d, phys base 0x%08lx, virtual "
+        c->dma_chan = dma_request_channel(mask, NULL, NULL);
-                 "base %p, freq %d MHz\n", c->gpmc_cs, c->phys_base,
+        if (c->dma_chan) {
-                 c->onenand.base, c->freq);
+                c->onenand.read_bufferram = omap2_onenand_read_bufferram;
+                c->onenand.write_bufferram = omap2_onenand_write_bufferram;
+        }
        c->pdev = pdev;
        c->mtd.priv = &c->onenand;
+        c->mtd.dev.parent = dev;
+        mtd_set_of_node(&c->mtd, dev->of_node);
-        c->mtd.dev.parent = &pdev->dev;
+        dev_info(dev, "initializing on CS%d (0x%08lx), va %p, %s mode\n",
-        mtd_set_of_node(&c->mtd, pdata->of_node);
+                 c->gpmc_cs, c->phys_base, c->onenand.base,
+                 c->dma_chan ? "DMA" : "PIO");
-        this = &c->onenand;
-        if (c->dma_channel >= 0) {
-                this->wait = omap2_onenand_wait;
-                if (c->flags & ONENAND_IN_OMAP34XX) {
-                        this->read_bufferram = omap3_onenand_read_bufferram;
-                        this->write_bufferram = omap3_onenand_write_bufferram;
-                } else {
-                        this->read_bufferram = omap2_onenand_read_bufferram;
-                        this->write_bufferram = omap2_onenand_write_bufferram;
-                }
-        }
-        if (pdata->regulator_can_sleep) {
+        if ((r = onenand_scan(&c->mtd, 1)) < 0)
-                c->regulator = regulator_get(&pdev->dev, "vonenand");
+                goto err_release_dma;
-                if (IS_ERR(c->regulator)) {
-                        dev_err(&pdev->dev,  "Failed to get regulator\n");
+        freq = omap2_onenand_get_freq(c->onenand.version_id);
-                        r = PTR_ERR(c->regulator);
+        if (freq > 0) {
-                        goto err_release_dma;
+                switch (freq) {
+                case 104:
+                        latency = 7;
+                        break;
+                case 83:
+                        latency = 6;
+                        break;
+                case 66:
+                        latency = 5;
+                        break;
+                case 56:
+                        latency = 4;
+                        break;
+                default:        /* 40 MHz or lower */
+                        latency = 3;
+                        break;
                }
-                c->onenand.enable = omap2_onenand_enable;
-                c->onenand.disable = omap2_onenand_disable;
-        }
-        if (pdata->skip_initial_unlocking)
+                r = gpmc_omap_onenand_set_timings(dev, c->gpmc_cs,
-                this->options |= ONENAND_SKIP_INITIAL_UNLOCKING;
+                                                  freq, latency, &info);
+                if (r)
+                        goto err_release_onenand;
-        if ((r = onenand_scan(&c->mtd, 1)) < 0)
+                r = omap2_onenand_set_cfg(c, info.sync_read, info.sync_write,
-                goto err_release_regulator;
+                                          latency, info.burst_len);
+                if (r)
+                        goto err_release_onenand;
-        r = mtd_device_register(&c->mtd, pdata ? pdata->parts : NULL,
+                if (info.sync_read || info.sync_write)
-                                pdata ? pdata->nr_parts : 0);
+                        dev_info(dev, "optimized timings for %d MHz\n", freq);
+        }
+        r = mtd_device_register(&c->mtd, NULL, 0);
        if (r)
                goto err_release_onenand;
@@ -754,22 +619,9 @@ static int omap2_onenand_probe(struct platform_device *pdev)
 err_release_onenand:
        onenand_release(&c->mtd);
-err_release_regulator:
-        regulator_put(c->regulator);
 err_release_dma:
-        if (c->dma_channel != -1)
+        if (c->dma_chan)
-                omap_free_dma(c->dma_channel);
+                dma_release_channel(c->dma_chan);
-        if (c->gpio_irq)
-                free_irq(gpio_to_irq(c->gpio_irq), c);
-err_release_gpio:
-        if (c->gpio_irq)
-                gpio_free(c->gpio_irq);
-err_iounmap:
-        iounmap(c->onenand.base);
-err_release_mem_region:
-        release_mem_region(c->phys_base, c->mem_size);
-err_kfree:
-        kfree(c);
        return r;
 }
@@ -779,27 +631,26 @@ static int omap2_onenand_remove(struct platform_device *pdev)
        struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
        onenand_release(&c->mtd);
-        regulator_put(c->regulator);
+        if (c->dma_chan)
-        if (c->dma_channel != -1)
+                dma_release_channel(c->dma_chan);
-                omap_free_dma(c->dma_channel);
        omap2_onenand_shutdown(pdev);
-        if (c->gpio_irq) {
-                free_irq(gpio_to_irq(c->gpio_irq), c);
-                gpio_free(c->gpio_irq);
-        }
-        iounmap(c->onenand.base);
-        release_mem_region(c->phys_base, c->mem_size);
-        kfree(c);
        return 0;
 }
+static const struct of_device_id omap2_onenand_id_table[] = {
+        { .compatible = "ti,omap2-onenand", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, omap2_onenand_id_table);
 static struct platform_driver omap2_onenand_driver = {
        .probe          = omap2_onenand_probe,
        .remove         = omap2_onenand_remove,
        .shutdown       = omap2_onenand_shutdown,
        .driver         = {
                .name   = DRIVER_NAME,
+                .of_match_table = omap2_onenand_id_table,
        },
 };
diff --git a/drivers/mtd/onenand/samsung.c b/drivers/mtd/onenand/samsung.c
index af0ac1a7bf8f..2e9d076e445a 100644
--- a/drivers/mtd/onenand/samsung.c
+++ b/drivers/mtd/onenand/samsung.c
@@ -25,8 +25,6 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include <asm/mach/flash.h>
 #include "samsung.h"
 enum soc_type {
@@ -129,16 +127,13 @@ struct s3c_onenand {
        struct platform_device  *pdev;
        enum soc_type   type;
        void __iomem    *base;
-        struct resource *base_res;
        void __iomem    *ahb_addr;
-        struct resource *ahb_res;
        int             bootram_command;
-        void __iomem    *page_buf;
+        void            *page_buf;
-        void __iomem    *oob_buf;
+        void            *oob_buf;
        unsigned int    (*mem_addr)(int fba, int fpa, int fsa);
        unsigned int    (*cmd_map)(unsigned int type, unsigned int val);
        void __iomem    *dma_addr;
-        struct resource *dma_res;
        unsigned long   phys_base;
        struct completion       complete;
 };
@@ -413,8 +408,8 @@ static int s3c_onenand_command(struct mtd_info *mtd, int cmd, loff_t addr,
        /*
         * Emulate Two BufferRAMs and access with 4 bytes pointer
         */
-        m = (unsigned int *) onenand->page_buf;
+        m = onenand->page_buf;
-        s = (unsigned int *) onenand->oob_buf;
+        s = onenand->oob_buf;
        if (index) {
                m += (this->writesize >> 2);
@@ -486,11 +481,11 @@ static unsigned char *s3c_get_bufferram(struct mtd_info *mtd, int area)
        unsigned char *p;
        if (area == ONENAND_DATARAM) {
-                p = (unsigned char *) onenand->page_buf;
+                p = onenand->page_buf;
                if (index == 1)
                        p += this->writesize;
        } else {
-                p = (unsigned char *) onenand->oob_buf;
+                p = onenand->oob_buf;
                if (index == 1)
                        p += mtd->oobsize;
        }
@@ -851,15 +846,14 @@ static int s3c_onenand_probe(struct platform_device *pdev)
        /* No need to check pdata. the platform data is optional */
        size = sizeof(struct mtd_info) + sizeof(struct onenand_chip);
-        mtd = kzalloc(size, GFP_KERNEL);
+        mtd = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
        if (!mtd)
                return -ENOMEM;
-        onenand = kzalloc(sizeof(struct s3c_onenand), GFP_KERNEL);
+        onenand = devm_kzalloc(&pdev->dev, sizeof(struct s3c_onenand),
-        if (!onenand) {
+                               GFP_KERNEL);
-                err = -ENOMEM;
+        if (!onenand)
-                goto onenand_fail;
+                return -ENOMEM;
-        }
        this = (struct onenand_chip *) &mtd[1];
        mtd->priv = this;
@@ -870,26 +864,12 @@ static int s3c_onenand_probe(struct platform_device *pdev)
        s3c_onenand_setup(mtd);
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r) {
+        onenand->base = devm_ioremap_resource(&pdev->dev, r);
-                dev_err(&pdev->dev, "no memory resource defined\n");
+        if (IS_ERR(onenand->base))
-                return -ENOENT;
+                return PTR_ERR(onenand->base);
-                goto ahb_resource_failed;
-        }
-        onenand->base_res = request_mem_region(r->start, resource_size(r),
+        onenand->phys_base = r->start;
-                                               pdev->name);
-        if (!onenand->base_res) {
-                dev_err(&pdev->dev, "failed to request memory resource\n");
-                err = -EBUSY;
-                goto resource_failed;
-        }
-        onenand->base = ioremap(r->start, resource_size(r));
-        if (!onenand->base) {
-                dev_err(&pdev->dev, "failed to map memory resource\n");
-                err = -EFAULT;
-                goto ioremap_failed;
-        }
        /* Set onenand_chip also */
        this->base = onenand->base;
@@ -898,40 +878,20 @@ static int s3c_onenand_probe(struct platform_device *pdev)
        if (onenand->type != TYPE_S5PC110) {
                r = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-                if (!r) {
+                onenand->ahb_addr = devm_ioremap_resource(&pdev->dev, r);
-                        dev_err(&pdev->dev, "no buffer memory resource defined\n");
+                if (IS_ERR(onenand->ahb_addr))
-                        err = -ENOENT;
+                        return PTR_ERR(onenand->ahb_addr);
-                        goto ahb_resource_failed;
-                }
-                onenand->ahb_res = request_mem_region(r->start, resource_size(r),
-                                                      pdev->name);
-                if (!onenand->ahb_res) {
-                        dev_err(&pdev->dev, "failed to request buffer memory resource\n");
-                        err = -EBUSY;
-                        goto ahb_resource_failed;
-                }
-                onenand->ahb_addr = ioremap(r->start, resource_size(r));
-                if (!onenand->ahb_addr) {
-                        dev_err(&pdev->dev, "failed to map buffer memory resource\n");
-                        err = -EINVAL;
-                        goto ahb_ioremap_failed;
-                }
                /* Allocate 4KiB BufferRAM */
-                onenand->page_buf = kzalloc(SZ_4K, GFP_KERNEL);
+                onenand->page_buf = devm_kzalloc(&pdev->dev, SZ_4K,
-                if (!onenand->page_buf) {
+                                                 GFP_KERNEL);
-                        err = -ENOMEM;
+                if (!onenand->page_buf)
-                        goto page_buf_fail;
+                        return -ENOMEM;
-                }
                /* Allocate 128 SpareRAM */
-                onenand->oob_buf = kzalloc(128, GFP_KERNEL);
+                onenand->oob_buf = devm_kzalloc(&pdev->dev, 128, GFP_KERNEL);
-                if (!onenand->oob_buf) {
+                if (!onenand->oob_buf)
-                        err = -ENOMEM;
+                        return -ENOMEM;
-                        goto oob_buf_fail;
-                }
                /* S3C doesn't handle subpage write */
                mtd->subpage_sft = 0;
@@ -939,28 +899,9 @@ static int s3c_onenand_probe(struct platform_device *pdev)
        } else { /* S5PC110 */
                r = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-                if (!r) {
+                onenand->dma_addr = devm_ioremap_resource(&pdev->dev, r);
-                        dev_err(&pdev->dev, "no dma memory resource defined\n");
+                if (IS_ERR(onenand->dma_addr))
-                        err = -ENOENT;
+                        return PTR_ERR(onenand->dma_addr);
-                        goto dma_resource_failed;
-                }
-                onenand->dma_res = request_mem_region(r->start, resource_size(r),
-                                                      pdev->name);
-                if (!onenand->dma_res) {
-                        dev_err(&pdev->dev, "failed to request dma memory resource\n");
-                        err = -EBUSY;
-                        goto dma_resource_failed;
-                }
-                onenand->dma_addr = ioremap(r->start, resource_size(r));
-                if (!onenand->dma_addr) {
-                        dev_err(&pdev->dev, "failed to map dma memory resource\n");
-                        err = -EINVAL;
-                        goto dma_ioremap_failed;
-                }
-                onenand->phys_base = onenand->base_res->start;
                s5pc110_dma_ops = s5pc110_dma_poll;
                /* Interrupt support */
@@ -968,19 +909,20 @@ static int s3c_onenand_probe(struct platform_device *pdev)
                if (r) {
                        init_completion(&onenand->complete);
                        s5pc110_dma_ops = s5pc110_dma_irq;
-                        err = request_irq(r->start, s5pc110_onenand_irq,
+                        err = devm_request_irq(&pdev->dev, r->start,
-                                        IRQF_SHARED, "onenand", &onenand);
+                                               s5pc110_onenand_irq,
+                                               IRQF_SHARED, "onenand",
+                                               &onenand);
                        if (err) {
                                dev_err(&pdev->dev, "failed to get irq\n");
-                                goto scan_failed;
+                                return err;
                        }
                }
        }
-        if (onenand_scan(mtd, 1)) {
+        err = onenand_scan(mtd, 1);
-                err = -EFAULT;
+        if (err)
-                goto scan_failed;
+                return err;
-        }
        if (onenand->type != TYPE_S5PC110) {
                /* S3C doesn't handle subpage write */
@@ -994,40 +936,15 @@ static int s3c_onenand_probe(struct platform_device *pdev)
        err = mtd_device_parse_register(mtd, NULL, NULL,
                                        pdata ? pdata->parts : NULL,
                                        pdata ? pdata->nr_parts : 0);
+        if (err) {
+                dev_err(&pdev->dev, "failed to parse partitions and register the MTD device\n");
+                onenand_release(mtd);
+                return err;
+        }
        platform_set_drvdata(pdev, mtd);
        return 0;
-scan_failed:
-        if (onenand->dma_addr)
-                iounmap(onenand->dma_addr);
-dma_ioremap_failed:
-        if (onenand->dma_res)
-                release_mem_region(onenand->dma_res->start,
-                                   resource_size(onenand->dma_res));
-        kfree(onenand->oob_buf);
-oob_buf_fail:
-        kfree(onenand->page_buf);
-page_buf_fail:
-        if (onenand->ahb_addr)
-                iounmap(onenand->ahb_addr);
-ahb_ioremap_failed:
-        if (onenand->ahb_res)
-                release_mem_region(onenand->ahb_res->start,
-                                   resource_size(onenand->ahb_res));
-dma_resource_failed:
-ahb_resource_failed:
-        iounmap(onenand->base);
-ioremap_failed:
-        if (onenand->base_res)
-                release_mem_region(onenand->base_res->start,
-                                   resource_size(onenand->base_res));
-resource_failed:
-        kfree(onenand);
-onenand_fail:
-        kfree(mtd);
-        return err;
 }
 static int s3c_onenand_remove(struct platform_device *pdev)
@@ -1035,25 +952,7 @@ static int s3c_onenand_remove(struct platform_device *pdev)
        struct mtd_info *mtd = platform_get_drvdata(pdev);
        onenand_release(mtd);
-        if (onenand->ahb_addr)
-                iounmap(onenand->ahb_addr);
-        if (onenand->ahb_res)
-                release_mem_region(onenand->ahb_res->start,
-                                   resource_size(onenand->ahb_res));
-        if (onenand->dma_addr)
-                iounmap(onenand->dma_addr);
-        if (onenand->dma_res)
-                release_mem_region(onenand->dma_res->start,
-                                   resource_size(onenand->dma_res));
-        iounmap(onenand->base);
-        release_mem_region(onenand->base_res->start,
-                           resource_size(onenand->base_res));
-        kfree(onenand->oob_buf);
-        kfree(onenand->page_buf);
-        kfree(onenand);
-        kfree(mtd);
        return 0;
 }
diff --git a/drivers/mtd/tests/nandbiterrs.c b/drivers/mtd/tests/nandbiterrs.c
index 5f03b8c885a9..cde19c99e77b 100644
--- a/drivers/mtd/tests/nandbiterrs.c
+++ b/drivers/mtd/tests/nandbiterrs.c
@@ -151,7 +151,7 @@ static int read_page(int log)
        memcpy(&oldstats, &mtd->ecc_stats, sizeof(oldstats));
        err = mtd_read(mtd, offset, mtd->writesize, &read, rbuffer);
-        if (err == -EUCLEAN)
+        if (!err || err == -EUCLEAN)
                err = mtd->ecc_stats.corrected - oldstats.corrected;
        if (err < 0 || read != mtd->writesize) {
diff --git a/drivers/mtd/tests/oobtest.c b/drivers/mtd/tests/oobtest.c
index 1cb3f7758fb6..766b2c385682 100644
--- a/drivers/mtd/tests/oobtest.c
+++ b/drivers/mtd/tests/oobtest.c
@@ -193,6 +193,9 @@ static int verify_eraseblock(int ebnum)
                ops.datbuf    = NULL;
                ops.oobbuf    = readbuf;
                err = mtd_read_oob(mtd, addr, &ops);
+                if (mtd_is_bitflip(err))
+                        err = 0;
                if (err || ops.oobretlen != use_len) {
                        pr_err("error: readoob failed at %#llx\n",
                               (long long)addr);
@@ -227,6 +230,9 @@ static int verify_eraseblock(int ebnum)
                        ops.datbuf    = NULL;
                        ops.oobbuf    = readbuf;
                        err = mtd_read_oob(mtd, addr, &ops);
+                        if (mtd_is_bitflip(err))
+                                err = 0;
                        if (err || ops.oobretlen != mtd->oobavail) {
                                pr_err("error: readoob failed at %#llx\n",
                                                (long long)addr);
@@ -286,6 +292,9 @@ static int verify_eraseblock_in_one_go(int ebnum)
        /* read entire block's OOB at one go */
        err = mtd_read_oob(mtd, addr, &ops);
+        if (mtd_is_bitflip(err))
+                err = 0;
        if (err || ops.oobretlen != len) {
                pr_err("error: readoob failed at %#llx\n",
                       (long long)addr);
@@ -527,6 +536,9 @@ static int __init mtd_oobtest_init(void)
        pr_info("attempting to start read past end of OOB\n");
        pr_info("an error is expected...\n");
        err = mtd_read_oob(mtd, addr0, &ops);
+        if (mtd_is_bitflip(err))
+                err = 0;
        if (err) {
                pr_info("error occurred as expected\n");
                err = 0;
@@ -571,6 +583,9 @@ static int __init mtd_oobtest_init(void)
                pr_info("attempting to read past end of device\n");
                pr_info("an error is expected...\n");
                err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
+                if (mtd_is_bitflip(err))
+                        err = 0;
                if (err) {
                        pr_info("error occurred as expected\n");
                        err = 0;
@@ -615,6 +630,9 @@ static int __init mtd_oobtest_init(void)
                pr_info("attempting to read past end of device\n");
                pr_info("an error is expected...\n");
                err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
+                if (mtd_is_bitflip(err))
+                        err = 0;
                if (err) {
                        pr_info("error occurred as expected\n");
                        err = 0;
@@ -684,6 +702,9 @@ static int __init mtd_oobtest_init(void)
                ops.datbuf    = NULL;
                ops.oobbuf    = readbuf;
                err = mtd_read_oob(mtd, addr, &ops);
+                if (mtd_is_bitflip(err))
+                        err = 0;
                if (err)
                        goto out;
                if (memcmpshow(addr, readbuf, writebuf,
diff --git a/drivers/staging/mt29f_spinand/mt29f_spinand.c b/drivers/staging/mt29f_spinand/mt29f_spinand.c
index 87595c594b12..264ad362d858 100644
--- a/drivers/staging/mt29f_spinand/mt29f_spinand.c
+++ b/drivers/staging/mt29f_spinand/mt29f_spinand.c
@@ -637,8 +637,7 @@ static int spinand_write_page_hwecc(struct mtd_info *mtd,
        int eccsteps = chip->ecc.steps;
        enable_hw_ecc = 1;
-        chip->write_buf(mtd, p, eccsize * eccsteps);
+        return nand_prog_page_op(chip, page, 0, p, eccsize * eccsteps);
-        return 0;
 }
 static int spinand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
@@ -653,7 +652,7 @@ static int spinand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
        enable_read_hw_ecc = 1;
-        chip->read_buf(mtd, p, eccsize * eccsteps);
+        nand_read_page_op(chip, page, 0, p, eccsize * eccsteps);
        if (oob_required)
                chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
diff --git a/include/linux/mtd/rawnand.h b/include/linux/mtd/rawnand.h
index 749bb08c4772..56c5570aadbe 100644
--- a/include/linux/mtd/rawnand.h
+++ b/include/linux/mtd/rawnand.h
@@ -133,12 +133,6 @@ enum nand_ecc_algo {
 */
 #define NAND_ECC_GENERIC_ERASED_CHECK   BIT(0)
 #define NAND_ECC_MAXIMIZE               BIT(1)
-/*
- * If your controller already sends the required NAND commands when
- * reading or writing a page, then the framework is not supposed to
- * send READ0 and SEQIN/PAGEPROG respectively.
- */
-#define NAND_ECC_CUSTOM_PAGE_ACCESS     BIT(2)
 /* Bit mask for flags passed to do_nand_read_ecc */
 #define NAND_GET_DEVICE         0x80
@@ -191,11 +185,6 @@ enum nand_ecc_algo {
 /* Non chip related options */
 /* This option skips the bbt scan during initialization. */
 #define NAND_SKIP_BBTSCAN       0x00010000
-/*
- * This option is defined if the board driver allocates its own buffers
- * (e.g. because it needs them DMA-coherent).
- */
-#define NAND_OWN_BUFFERS        0x00020000
 /* Chip may not exist, so silence any errors in scan */
 #define NAND_SCAN_SILENT_NODEV  0x00040000
 /*
@@ -525,6 +514,8 @@ static const struct nand_ecc_caps __name = {			\
 * @postpad:    padding information for syndrome based ECC generators
 * @options:    ECC specific options (see NAND_ECC_XXX flags defined above)
 * @priv:       pointer to private ECC control data
+ * @calc_buf:   buffer for calculated ECC, size is oobsize.
+ * @code_buf:   buffer for ECC read from flash, size is oobsize.
 * @hwctl:      function to control hardware ECC generator. Must only
 *              be provided if an hardware ECC is available
 * @calculate:  function for ECC calculation or readback from ECC hardware
@@ -575,6 +566,8 @@ struct nand_ecc_ctrl {
        int postpad;
        unsigned int options;
        void *priv;
+        u8 *calc_buf;
+        u8 *code_buf;
        void (*hwctl)(struct mtd_info *mtd, int mode);
        int (*calculate)(struct mtd_info *mtd, const uint8_t *dat,
                        uint8_t *ecc_code);
@@ -602,26 +595,6 @@ struct nand_ecc_ctrl {
                        int page);
 };
-static inline int nand_standard_page_accessors(struct nand_ecc_ctrl *ecc)
-{
-        return !(ecc->options & NAND_ECC_CUSTOM_PAGE_ACCESS);
-}
-/**
- * struct nand_buffers - buffer structure for read/write
- * @ecccalc:    buffer pointer for calculated ECC, size is oobsize.
- * @ecccode:    buffer pointer for ECC read from flash, size is oobsize.
- * @databuf:    buffer pointer for data, size is (page size + oobsize).
- *
- * Do not change the order of buffers. databuf and oobrbuf must be in
- * consecutive order.
- */
-struct nand_buffers {
-        uint8_t *ecccalc;
-        uint8_t *ecccode;
-        uint8_t *databuf;
-};
 /**
 * struct nand_sdr_timings - SDR NAND chip timings
 *
@@ -762,6 +735,350 @@ struct nand_manufacturer_ops {
 };
 /**
+ * struct nand_op_cmd_instr - Definition of a command instruction
+ * @opcode: the command to issue in one cycle
+ */
+struct nand_op_cmd_instr {
+        u8 opcode;
+};
+/**
+ * struct nand_op_addr_instr - Definition of an address instruction
+ * @naddrs: length of the @addrs array
+ * @addrs: array containing the address cycles to issue
+ */
+struct nand_op_addr_instr {
+        unsigned int naddrs;
+        const u8 *addrs;
+};
+/**
+ * struct nand_op_data_instr - Definition of a data instruction
+ * @len: number of data bytes to move
+ * @in: buffer to fill when reading from the NAND chip
+ * @out: buffer to read from when writing to the NAND chip
+ * @force_8bit: force 8-bit access
+ *
+ * Please note that "in" and "out" are inverted from the ONFI specification
+ * and are from the controller perspective, so a "in" is a read from the NAND
+ * chip while a "out" is a write to the NAND chip.
+ */
+struct nand_op_data_instr {
+        unsigned int len;
+        union {
+                void *in;
+                const void *out;
+        } buf;
+        bool force_8bit;
+};
+/**
+ * struct nand_op_waitrdy_instr - Definition of a wait ready instruction
+ * @timeout_ms: maximum delay while waiting for the ready/busy pin in ms
+ */
+struct nand_op_waitrdy_instr {
+        unsigned int timeout_ms;
+};
+/**
+ * enum nand_op_instr_type - Definition of all instruction types
+ * @NAND_OP_CMD_INSTR: command instruction
+ * @NAND_OP_ADDR_INSTR: address instruction
+ * @NAND_OP_DATA_IN_INSTR: data in instruction
+ * @NAND_OP_DATA_OUT_INSTR: data out instruction
+ * @NAND_OP_WAITRDY_INSTR: wait ready instruction
+ */
+enum nand_op_instr_type {
+        NAND_OP_CMD_INSTR,
+        NAND_OP_ADDR_INSTR,
+        NAND_OP_DATA_IN_INSTR,
+        NAND_OP_DATA_OUT_INSTR,
+        NAND_OP_WAITRDY_INSTR,
+};
+/**
+ * struct nand_op_instr - Instruction object
+ * @type: the instruction type
+ * @cmd/@addr/@data/@waitrdy: extra data associated to the instruction.
+ *                            You'll have to use the appropriate element
+ *                            depending on @type
+ * @delay_ns: delay the controller should apply after the instruction has been
+ *            issued on the bus. Most modern controllers have internal timings
+ *            control logic, and in this case, the controller driver can ignore
+ *            this field.
+ */
+struct nand_op_instr {
+        enum nand_op_instr_type type;
+        union {
+                struct nand_op_cmd_instr cmd;
+                struct nand_op_addr_instr addr;
+                struct nand_op_data_instr data;
+                struct nand_op_waitrdy_instr waitrdy;
+        } ctx;
+        unsigned int delay_ns;
+};
+/*
+ * Special handling must be done for the WAITRDY timeout parameter as it usually
+ * is either tPROG (after a prog), tR (before a read), tRST (during a reset) or
+ * tBERS (during an erase) which all of them are u64 values that cannot be
+ * divided by usual kernel macros and must be handled with the special
+ * DIV_ROUND_UP_ULL() macro.
+ */
+#define __DIVIDE(dividend, divisor) ({                                  \
+        sizeof(dividend) == sizeof(u32) ?                               \
+                DIV_ROUND_UP(dividend, divisor) :                       \
+                DIV_ROUND_UP_ULL(dividend, divisor);                    \
+                })
+#define PSEC_TO_NSEC(x) __DIVIDE(x, 1000)
+#define PSEC_TO_MSEC(x) __DIVIDE(x, 1000000000)
+#define NAND_OP_CMD(id, ns)                                             \
+        {                                                               \
+                .type = NAND_OP_CMD_INSTR,                              \
+                .ctx.cmd.opcode = id,                                   \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_ADDR(ncycles, cycles, ns)                               \
+        {                                                               \
+                .type = NAND_OP_ADDR_INSTR,                             \
+                .ctx.addr = {                                           \
+                        .naddrs = ncycles,                              \
+                        .addrs = cycles,                                \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_DATA_IN(l, b, ns)                                       \
+        {                                                               \
+                .type = NAND_OP_DATA_IN_INSTR,                          \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.in = b,                                    \
+                        .force_8bit = false,                            \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_DATA_OUT(l, b, ns)                                      \
+        {                                                               \
+                .type = NAND_OP_DATA_OUT_INSTR,                         \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.out = b,                                   \
+                        .force_8bit = false,                            \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_8BIT_DATA_IN(l, b, ns)                                  \
+        {                                                               \
+                .type = NAND_OP_DATA_IN_INSTR,                          \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.in = b,                                    \
+                        .force_8bit = true,                             \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_8BIT_DATA_OUT(l, b, ns)                                 \
+        {                                                               \
+                .type = NAND_OP_DATA_OUT_INSTR,                         \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.out = b,                                   \
+                        .force_8bit = true,                             \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+#define NAND_OP_WAIT_RDY(tout_ms, ns)                                   \
+        {                                                               \
+                .type = NAND_OP_WAITRDY_INSTR,                          \
+                .ctx.waitrdy.timeout_ms = tout_ms,                      \
+                .delay_ns = ns,                                         \
+        }
+/**
+ * struct nand_subop - a sub operation
+ * @instrs: array of instructions
+ * @ninstrs: length of the @instrs array
+ * @first_instr_start_off: offset to start from for the first instruction
+ *                         of the sub-operation
+ * @last_instr_end_off: offset to end at (excluded) for the last instruction
+ *                      of the sub-operation
+ *
+ * Both @first_instr_start_off and @last_instr_end_off only apply to data or
+ * address instructions.
+ *
+ * When an operation cannot be handled as is by the NAND controller, it will
+ * be split by the parser into sub-operations which will be passed to the
+ * controller driver.
+ */
+struct nand_subop {
+        const struct nand_op_instr *instrs;
+        unsigned int ninstrs;
+        unsigned int first_instr_start_off;
+        unsigned int last_instr_end_off;
+};
+int nand_subop_get_addr_start_off(const struct nand_subop *subop,
+                                  unsigned int op_id);
+int nand_subop_get_num_addr_cyc(const struct nand_subop *subop,
+                                unsigned int op_id);
+int nand_subop_get_data_start_off(const struct nand_subop *subop,
+                                  unsigned int op_id);
+int nand_subop_get_data_len(const struct nand_subop *subop,
+                            unsigned int op_id);
+/**
+ * struct nand_op_parser_addr_constraints - Constraints for address instructions
+ * @maxcycles: maximum number of address cycles the controller can issue in a
+ *             single step
+ */
+struct nand_op_parser_addr_constraints {
+        unsigned int maxcycles;
+};
+/**
+ * struct nand_op_parser_data_constraints - Constraints for data instructions
+ * @maxlen: maximum data length that the controller can handle in a single step
+ */
+struct nand_op_parser_data_constraints {
+        unsigned int maxlen;
+};
+/**
+ * struct nand_op_parser_pattern_elem - One element of a pattern
+ * @type: the instructuction type
+ * @optional: whether this element of the pattern is optional or mandatory
+ * @addr/@data: address or data constraint (number of cycles or data length)
+ */
+struct nand_op_parser_pattern_elem {
+        enum nand_op_instr_type type;
+        bool optional;
+        union {
+                struct nand_op_parser_addr_constraints addr;
+                struct nand_op_parser_data_constraints data;
+        } ctx;
+};
+#define NAND_OP_PARSER_PAT_CMD_ELEM(_opt)                       \
+        {                                                       \
+                .type = NAND_OP_CMD_INSTR,                      \
+                .optional = _opt,                               \
+        }
+#define NAND_OP_PARSER_PAT_ADDR_ELEM(_opt, _maxcycles)          \
+        {                                                       \
+                .type = NAND_OP_ADDR_INSTR,                     \
+                .optional = _opt,                               \
+                .ctx.addr.maxcycles = _maxcycles,               \
+        }
+#define NAND_OP_PARSER_PAT_DATA_IN_ELEM(_opt, _maxlen)          \
+        {                                                       \
+                .type = NAND_OP_DATA_IN_INSTR,                  \
+                .optional = _opt,                               \
+                .ctx.data.maxlen = _maxlen,                     \
+        }
+#define NAND_OP_PARSER_PAT_DATA_OUT_ELEM(_opt, _maxlen)         \
+        {                                                       \
+                .type = NAND_OP_DATA_OUT_INSTR,                 \
+                .optional = _opt,                               \
+                .ctx.data.maxlen = _maxlen,                     \
+        }
+#define NAND_OP_PARSER_PAT_WAITRDY_ELEM(_opt)                   \
+        {                                                       \
+                .type = NAND_OP_WAITRDY_INSTR,                  \
+                .optional = _opt,                               \
+        }
+/**
+ * struct nand_op_parser_pattern - NAND sub-operation pattern descriptor
+ * @elems: array of pattern elements
+ * @nelems: number of pattern elements in @elems array
+ * @exec: the function that will issue a sub-operation
+ *
+ * A pattern is a list of elements, each element reprensenting one instruction
+ * with its constraints. The pattern itself is used by the core to match NAND
+ * chip operation with NAND controller operations.
+ * Once a match between a NAND controller operation pattern and a NAND chip
+ * operation (or a sub-set of a NAND operation) is found, the pattern ->exec()
+ * hook is called so that the controller driver can issue the operation on the
+ * bus.
+ *
+ * Controller drivers should declare as many patterns as they support and pass
+ * this list of patterns (created with the help of the following macro) to
+ * the nand_op_parser_exec_op() helper.
+ */
+struct nand_op_parser_pattern {
+        const struct nand_op_parser_pattern_elem *elems;
+        unsigned int nelems;
+        int (*exec)(struct nand_chip *chip, const struct nand_subop *subop);
+};
+#define NAND_OP_PARSER_PATTERN(_exec, ...)                                                      \
+        {                                                                                       \
+                .exec = _exec,                                                                  \
+                .elems = (struct nand_op_parser_pattern_elem[]) { __VA_ARGS__ },                \
+                .nelems = sizeof((struct nand_op_parser_pattern_elem[]) { __VA_ARGS__ }) /      \
+                          sizeof(struct nand_op_parser_pattern_elem),                           \
+        }
+/**
+ * struct nand_op_parser - NAND controller operation parser descriptor
+ * @patterns: array of supported patterns
+ * @npatterns: length of the @patterns array
+ *
+ * The parser descriptor is just an array of supported patterns which will be
+ * iterated by nand_op_parser_exec_op() everytime it tries to execute an
+ * NAND operation (or tries to determine if a specific operation is supported).
+ *
+ * It is worth mentioning that patterns will be tested in their declaration
+ * order, and the first match will be taken, so it's important to order patterns
+ * appropriately so that simple/inefficient patterns are placed at the end of
+ * the list. Usually, this is where you put single instruction patterns.
+ */
+struct nand_op_parser {
+        const struct nand_op_parser_pattern *patterns;
+        unsigned int npatterns;
+};
+#define NAND_OP_PARSER(...)                                                                     \
+        {                                                                                       \
+                .patterns = (struct nand_op_parser_pattern[]) { __VA_ARGS__ },                  \
+                .npatterns = sizeof((struct nand_op_parser_pattern[]) { __VA_ARGS__ }) /        \
+                             sizeof(struct nand_op_parser_pattern),                             \
+        }
+/**
+ * struct nand_operation - NAND operation descriptor
+ * @instrs: array of instructions to execute
+ * @ninstrs: length of the @instrs array
+ *
+ * The actual operation structure that will be passed to chip->exec_op().
+ */
+struct nand_operation {
+        const struct nand_op_instr *instrs;
+        unsigned int ninstrs;
+};
+#define NAND_OPERATION(_instrs)                                 \
+        {                                                       \
+                .instrs = _instrs,                              \
+                .ninstrs = ARRAY_SIZE(_instrs),                 \
+        }
+int nand_op_parser_exec_op(struct nand_chip *chip,
+                           const struct nand_op_parser *parser,
+                           const struct nand_operation *op, bool check_only);
+/**
 * struct nand_chip - NAND Private Flash Chip Data
 * @mtd:                MTD device registered to the MTD framework
 * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the
@@ -787,10 +1104,13 @@ struct nand_manufacturer_ops {
 *                      commands to the chip.
 * @waitfunc:           [REPLACEABLE] hardwarespecific function for wait on
 *                      ready.
+ * @exec_op:            controller specific method to execute NAND operations.
+ *                      This method replaces ->cmdfunc(),
+ *                      ->{read,write}_{buf,byte,word}(), ->dev_ready() and
+ *                      ->waifunc().
 * @setup_read_retry:   [FLASHSPECIFIC] flash (vendor) specific function for
 *                      setting the read-retry mode. Mostly needed for MLC NAND.
 * @ecc:                [BOARDSPECIFIC] ECC control structure
- * @buffers:            buffer structure for read/write
 * @buf_align:          minimum buffer alignment required by a platform
 * @hwcontrol:          platform-specific hardware control structure
 * @erase:              [REPLACEABLE] erase function
@@ -830,6 +1150,7 @@ struct nand_manufacturer_ops {
 * @numchips:           [INTERN] number of physical chips
 * @chipsize:           [INTERN] the size of one chip for multichip arrays
 * @pagemask:           [INTERN] page number mask = number of (pages / chip) - 1
+ * @data_buf:           [INTERN] buffer for data, size is (page size + oobsize).
 * @pagebuf:            [INTERN] holds the pagenumber which is currently in
 *                      data_buf.
 * @pagebuf_bitflips:   [INTERN] holds the bitflip count for the page which is
@@ -886,6 +1207,9 @@ struct nand_chip {
        void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column,
                        int page_addr);
        int(*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
+        int (*exec_op)(struct nand_chip *chip,
+                       const struct nand_operation *op,
+                       bool check_only);
        int (*erase)(struct mtd_info *mtd, int page);
        int (*scan_bbt)(struct mtd_info *mtd);
        int (*onfi_set_features)(struct mtd_info *mtd, struct nand_chip *chip,
@@ -896,7 +1220,6 @@ struct nand_chip {
        int (*setup_data_interface)(struct mtd_info *mtd, int chipnr,
                                    const struct nand_data_interface *conf);
        int chip_delay;
        unsigned int options;
        unsigned int bbt_options;
@@ -908,6 +1231,7 @@ struct nand_chip {
        int numchips;
        uint64_t chipsize;
        int pagemask;
+        u8 *data_buf;
        int pagebuf;
        unsigned int pagebuf_bitflips;
        int subpagesize;
@@ -928,7 +1252,7 @@ struct nand_chip {
        u16 max_bb_per_die;
        u32 blocks_per_die;
-        struct nand_data_interface *data_interface;
+        struct nand_data_interface data_interface;
        int read_retries;
@@ -938,7 +1262,6 @@ struct nand_chip {
        struct nand_hw_control *controller;
        struct nand_ecc_ctrl ecc;
-        struct nand_buffers *buffers;
        unsigned long buf_align;
        struct nand_hw_control hwcontrol;
@@ -956,6 +1279,15 @@ struct nand_chip {
        } manufacturer;
 };
+static inline int nand_exec_op(struct nand_chip *chip,
+                               const struct nand_operation *op)
+{
+        if (!chip->exec_op)
+                return -ENOTSUPP;
+        return chip->exec_op(chip, op, false);
+}
 extern const struct mtd_ooblayout_ops nand_ooblayout_sp_ops;
 extern const struct mtd_ooblayout_ops nand_ooblayout_lp_ops;
@@ -1225,8 +1557,7 @@ static inline int onfi_get_sync_timing_mode(struct nand_chip *chip)
        return le16_to_cpu(chip->onfi_params.src_sync_timing_mode);
 }
-int onfi_init_data_interface(struct nand_chip *chip,
+int onfi_fill_data_interface(struct nand_chip *chip,
-                             struct nand_data_interface *iface,
                             enum nand_data_interface_type type,
                             int timing_mode);
@@ -1269,8 +1600,6 @@ static inline int jedec_feature(struct nand_chip *chip)
 /* get timing characteristics from ONFI timing mode. */
 const struct nand_sdr_timings *onfi_async_timing_mode_to_sdr_timings(int mode);
-/* get data interface from ONFI timing mode 0, used after reset. */
-const struct nand_data_interface *nand_get_default_data_interface(void);
 int nand_check_erased_ecc_chunk(void *data, int datalen,
                                void *ecc, int ecclen,
@@ -1316,9 +1645,45 @@ int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
 /* Reset and initialize a NAND device */
 int nand_reset(struct nand_chip *chip, int chipnr);
+/* NAND operation helpers */
+int nand_reset_op(struct nand_chip *chip);
+int nand_readid_op(struct nand_chip *chip, u8 addr, void *buf,
+                   unsigned int len);
+int nand_status_op(struct nand_chip *chip, u8 *status);
+int nand_exit_status_op(struct nand_chip *chip);
+int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock);
+int nand_read_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, void *buf, unsigned int len);
+int nand_change_read_column_op(struct nand_chip *chip,
+                               unsigned int offset_in_page, void *buf,
+                               unsigned int len, bool force_8bit);
+int nand_read_oob_op(struct nand_chip *chip, unsigned int page,
+                     unsigned int offset_in_page, void *buf, unsigned int len);
+int nand_prog_page_begin_op(struct nand_chip *chip, unsigned int page,
+                            unsigned int offset_in_page, const void *buf,
+                            unsigned int len);
+int nand_prog_page_end_op(struct nand_chip *chip);
+int nand_prog_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, const void *buf,
+                      unsigned int len);
+int nand_change_write_column_op(struct nand_chip *chip,
+                                unsigned int offset_in_page, const void *buf,
+                                unsigned int len, bool force_8bit);
+int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
+                      bool force_8bit);
+int nand_write_data_op(struct nand_chip *chip, const void *buf,
+                       unsigned int len, bool force_8bit);
 /* Free resources held by the NAND device */
 void nand_cleanup(struct nand_chip *chip);
 /* Default extended ID decoding function */
 void nand_decode_ext_id(struct nand_chip *chip);
+/*
+ * External helper for controller drivers that have to implement the WAITRDY
+ * instruction and have no physical pin to check it.
+ */
+int nand_soft_waitrdy(struct nand_chip *chip, unsigned long timeout_ms);
 #endif /* __LINUX_MTD_RAWNAND_H */
diff --git a/include/linux/omap-gpmc.h b/include/linux/omap-gpmc.h
index edfa280c3d56..053feb41510a 100644
--- a/include/linux/omap-gpmc.h
+++ b/include/linux/omap-gpmc.h
@@ -25,15 +25,43 @@ struct gpmc_nand_ops {
 struct gpmc_nand_regs;
+struct gpmc_onenand_info {
+        bool sync_read;
+        bool sync_write;
+        int burst_len;
+};
 #if IS_ENABLED(CONFIG_OMAP_GPMC)
 struct gpmc_nand_ops *gpmc_omap_get_nand_ops(struct gpmc_nand_regs *regs,
                                             int cs);
+/**
+ * gpmc_omap_onenand_set_timings - set optimized sync timings.
+ * @cs:      Chip Select Region
+ * @freq:    Chip frequency
+ * @latency: Burst latency cycle count
+ * @info:    Structure describing parameters used
+ *
+ * Sets optimized timings for the @cs region based on @freq and @latency.
+ * Updates the @info structure based on the GPMC settings.
+ */
+int gpmc_omap_onenand_set_timings(struct device *dev, int cs, int freq,
+                                  int latency,
+                                  struct gpmc_onenand_info *info);
 #else
 static inline struct gpmc_nand_ops *gpmc_omap_get_nand_ops(struct gpmc_nand_regs *regs,
                                                           int cs)
 {
        return NULL;
 }
+static inline
+int gpmc_omap_onenand_set_timings(struct device *dev, int cs, int freq,
+                                  int latency,
+                                  struct gpmc_onenand_info *info)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_OMAP_GPMC */
 extern int gpmc_calc_timings(struct gpmc_timings *gpmc_t,
diff --git a/include/linux/platform_data/mtd-onenand-omap2.h b/include/linux/platform_data/mtd-onenand-omap2.h
deleted file mode 100644
index 56ff0e6f5ad1..000000000000
--- a/include/linux/platform_data/mtd-onenand-omap2.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2006 Nokia Corporation
- * Author: Juha Yrjola
- *
- * 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
- * published by the Free Software Foundation.
- */
-#ifndef __MTD_ONENAND_OMAP2_H
-#define __MTD_ONENAND_OMAP2_H
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/partitions.h>
-#define ONENAND_SYNC_READ       (1 << 0)
-#define ONENAND_SYNC_READWRITE  (1 << 1)
-#define ONENAND_IN_OMAP34XX     (1 << 2)
-struct omap_onenand_platform_data {
-        int                     cs;
-        int                     gpio_irq;
-        struct mtd_partition    *parts;
-        int                     nr_parts;
-        int                     (*onenand_setup)(void __iomem *, int *freq_ptr);
-        int                     dma_channel;
-        u8                      flags;
-        u8                      regulator_can_sleep;
-        u8                      skip_initial_unlocking;
-        /* for passing the partitions */
-        struct device_node      *of_node;
-};
-#endif
author	Boris Brezillon <boris.brezillon@free-electrons.com>	2018-01-29 03:58:36 -0500
committer	Boris Brezillon <boris.brezillon@free-electrons.com>	2018-01-29 03:58:36 -0500
commit	571cb17b23eccc22f18c4fc0a0fc34cf0abca7ef (patch)
tree	c371417fc983700fc74fe35a017973cb8580eec2
parent	c8f22b02a8bbc74525d17dd37d39bdf599e68a79 (diff)
parent	f4c6cd1a7f2275d5bc0e494b21fff26f8dde80f0 (diff)