300 files changed, 16285 insertions, 7871 deletions

diff --git a/Documentation/DocBook/mtdnand.tmpl b/Documentation/DocBook/mtdnand.tmpl
index e0aedb7a7827..fe122d6e686f 100644
--- a/Documentation/DocBook/mtdnand.tmpl
+++ b/Documentation/DocBook/mtdnand.tmpl
@@ -1216,8 +1216,6 @@ in this page</entry>
 #define NAND_BBT_LASTBLOCK      0x00000010
 /* The bbt is at the given page, else we must scan for the bbt */
 #define NAND_BBT_ABSPAGE        0x00000020
-/* The bbt is at the given page, else we must scan for the bbt */
-#define NAND_BBT_SEARCH         0x00000040
 /* bbt is stored per chip on multichip devices */
 #define NAND_BBT_PERCHIP        0x00000080
 /* bbt has a version counter at offset veroffs */
diff --git a/Documentation/devicetree/bindings/arm/davinci/nand.txt b/Documentation/devicetree/bindings/arm/davinci/nand.txt
new file mode 100644
index 000000000000..e37241f1fdd8
--- /dev/null
+++ b/Documentation/devicetree/bindings/arm/davinci/nand.txt
@@ -0,0 +1,51 @@
+* Texas Instruments Davinci NAND
+
+This file provides information, what the device node for the
+davinci nand interface contain.
+
+Required properties:
+- compatible: "ti,davinci-nand";
+- reg : contain 2 offset/length values:
+        - offset and length for the access window
+        - offset and length for accessing the aemif control registers
+- ti,davinci-chipselect: Indicates on the davinci_nand driver which
+                         chipselect is used for accessing the nand.
+
+Recommended properties :
+- ti,davinci-mask-ale: mask for ale
+- ti,davinci-mask-cle: mask for cle
+- ti,davinci-mask-chipsel: mask for chipselect
+- ti,davinci-ecc-mode: ECC mode valid values for davinci driver:
+                - "none"
+                - "soft"
+                - "hw"
+- ti,davinci-ecc-bits: used ECC bits, currently supported 1 or 4.
+- ti,davinci-nand-buswidth: buswidth 8 or 16
+- ti,davinci-nand-use-bbt: use flash based bad block table support.
+
+Example (enbw_cmc board):
+aemif@60000000 {
+        compatible = "ti,davinci-aemif";
+        #address-cells = <2>;
+        #size-cells = <1>;
+        reg = <0x68000000 0x80000>;
+        ranges = <2 0 0x60000000 0x02000000
+                  3 0 0x62000000 0x02000000
+                  4 0 0x64000000 0x02000000
+                  5 0 0x66000000 0x02000000
+                  6 0 0x68000000 0x02000000>;
+        nand@3,0 {
+                compatible = "ti,davinci-nand";
+                reg = <3 0x0 0x807ff
+                        6 0x0 0x8000>;
+                #address-cells = <1>;
+                #size-cells = <1>;
+                ti,davinci-chipselect = <1>;
+                ti,davinci-mask-ale = <0>;
+                ti,davinci-mask-cle = <0>;
+                ti,davinci-mask-chipsel = <0>;
+                ti,davinci-ecc-mode = "hw";
+                ti,davinci-ecc-bits = <4>;
+                ti,davinci-nand-use-bbt;
+        };
+};
diff --git a/Documentation/devicetree/bindings/mmc/atmel-hsmci.txt b/Documentation/devicetree/bindings/mmc/atmel-hsmci.txt
new file mode 100644
index 000000000000..0a85c70cd30a
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/atmel-hsmci.txt
@@ -0,0 +1,68 @@
+* Atmel High Speed MultiMedia Card Interface
+
+This controller on atmel products provides an interface for MMC, SD and SDIO
+types of memory cards.
+
+This file documents differences between the core properties described
+by mmc.txt and the properties used by the atmel-mci driver.
+
+1) MCI node
+
+Required properties:
+- compatible: should be "atmel,hsmci"
+- #address-cells: should be one. The cell is the slot id.
+- #size-cells: should be zero.
+- at least one slot node
+
+The node contains child nodes for each slot that the platform uses
+
+Example MCI node:
+
+mmc0: mmc@f0008000 {
+        compatible = "atmel,hsmci";
+        reg = <0xf0008000 0x600>;
+        interrupts = <12 4>;
+        #address-cells = <1>;
+        #size-cells = <0>;
+
+        [ child node definitions...]
+};
+
+2) slot nodes
+
+Required properties:
+- reg: should contain the slot id.
+- bus-width: number of data lines connected to the controller
+
+Optional properties:
+- cd-gpios: specify GPIOs for card detection
+- cd-inverted: invert the value of external card detect gpio line
+- wp-gpios: specify GPIOs for write protection
+
+Example slot node:
+
+slot@0 {
+        reg = <0>;
+        bus-width = <4>;
+        cd-gpios = <&pioD 15 0>
+        cd-inverted;
+};
+
+Example full MCI node:
+mmc0: mmc@f0008000 {
+        compatible = "atmel,hsmci";
+        reg = <0xf0008000 0x600>;
+        interrupts = <12 4>;
+        #address-cells = <1>;
+        #size-cells = <0>;
+        slot@0 {
+                reg = <0>;
+                bus-width = <4>;
+                cd-gpios = <&pioD 15 0>
+                cd-inverted;
+        };
+        slot@1 {
+                reg = <1>;
+                bus-width = <4>;
+        };
+};
diff --git a/Documentation/devicetree/bindings/mmc/exynos-dw-mshc.txt b/Documentation/devicetree/bindings/mmc/exynos-dw-mshc.txt
new file mode 100644
index 000000000000..792768953330
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/exynos-dw-mshc.txt
@@ -0,0 +1,87 @@
+* Samsung Exynos specific extensions to the Synopsis Designware Mobile
+  Storage Host Controller
+
+The Synopsis designware mobile storage host controller is used to interface
+a SoC with storage medium such as eMMC or SD/MMC cards. This file documents
+differences between the core Synopsis dw mshc controller properties described
+by synposis-dw-mshc.txt and the properties used by the Samsung Exynos specific
+extensions to the Synopsis Designware Mobile Storage Host Controller.
+
+Required Properties:
+
+* compatible: should be
+        - "samsung,exynos4210-dw-mshc": for controllers with Samsung Exynos4210
+          specific extentions.
+        - "samsung,exynos4412-dw-mshc": for controllers with Samsung Exynos4412
+          specific extentions.
+        - "samsung,exynos5250-dw-mshc": for controllers with Samsung Exynos5250
+          specific extentions.
+
+* samsung,dw-mshc-ciu-div: Specifies the divider value for the card interface
+  unit (ciu) clock. This property is applicable only for Exynos5 SoC's and
+  ignored for Exynos4 SoC's. The valid range of divider value is 0 to 7.
+
+* samsung,dw-mshc-sdr-timing: Specifies the value of CIU clock phase shift value
+  in transmit mode and CIU clock phase shift value in receive mode for single
+  data rate mode operation. Refer notes below for the order of the cells and the
+  valid values.
+
+* samsung,dw-mshc-ddr-timing: Specifies the value of CUI clock phase shift value
+  in transmit mode and CIU clock phase shift value in receive mode for double
+  data rate mode operation. Refer notes below for the order of the cells and the
+  valid values.
+
+  Notes for the sdr-timing and ddr-timing values:
+
+    The order of the cells should be
+      - First Cell: CIU clock phase shift value for tx mode.
+      - Second Cell: CIU clock phase shift value for rx mode.
+
+    Valid values for SDR and DDR CIU clock timing for Exynos5250:
+      - valid value for tx phase shift and rx phase shift is 0 to 7.
+      - when CIU clock divider value is set to 3, all possible 8 phase shift
+        values can be used.
+      - if CIU clock divider value is 0 (that is divide by 1), both tx and rx
+        phase shift clocks should be 0.
+
+Required properties for a slot:
+
+* gpios: specifies a list of gpios used for command, clock and data bus. The
+  first gpio is the command line and the second gpio is the clock line. The
+  rest of the gpios (depending on the bus-width property) are the data lines in
+  no particular order. The format of the gpio specifier depends on the gpio
+  controller.
+
+Example:
+
+  The MSHC controller node can be split into two portions, SoC specific and
+  board specific portions as listed below.
+
+        dwmmc0@12200000 {
+                compatible = "samsung,exynos5250-dw-mshc";
+                reg = <0x12200000 0x1000>;
+                interrupts = <0 75 0>;
+                #address-cells = <1>;
+                #size-cells = <0>;
+        };
+
+        dwmmc0@12200000 {
+                num-slots = <1>;
+                supports-highspeed;
+                broken-cd;
+                fifo-depth = <0x80>;
+                card-detect-delay = <200>;
+                samsung,dw-mshc-ciu-div = <3>;
+                samsung,dw-mshc-sdr-timing = <2 3>;
+                samsung,dw-mshc-ddr-timing = <1 2>;
+
+                slot@0 {
+                        reg = <0>;
+                        bus-width = <8>;
+                        gpios = <&gpc0 0 2 0 3>, <&gpc0 1 2 0 3>,
+                                <&gpc1 0 2 3 3>, <&gpc1 1 2 3 3>,
+                                <&gpc1 2 2 3 3>, <&gpc1 3 2 3 3>,
+                                <&gpc0 3 2 3 3>, <&gpc0 4 2 3 3>,
+                                <&gpc0 5 2 3 3>, <&gpc0 6 2 3 3>;
+                };
+        };
diff --git a/Documentation/devicetree/bindings/mmc/mmc.txt b/Documentation/devicetree/bindings/mmc/mmc.txt
index 8a6811f4a02f..8e2e0ba2f486 100644
--- a/Documentation/devicetree/bindings/mmc/mmc.txt
+++ b/Documentation/devicetree/bindings/mmc/mmc.txt
@@ -9,12 +9,17 @@ Interpreted by the OF core:
 Required properties:
 - bus-width: Number of data lines, can be <1>, <4>, or <8>
 
+Card detection:
+If no property below is supplied, standard SDHCI card detect is used.
+Only one of the properties in this section should be supplied:
+  - broken-cd: There is no card detection available; polling must be used.
+  - cd-gpios: Specify GPIOs for card detection, see gpio binding
+  - non-removable: non-removable slot (like eMMC); assume always present.
+
 Optional properties:
-- cd-gpios: Specify GPIOs for card detection, see gpio binding
 - wp-gpios: Specify GPIOs for write protection, see gpio binding
 - cd-inverted: when present, polarity on the cd gpio line is inverted
 - wp-inverted: when present, polarity on the wp gpio line is inverted
-- non-removable: non-removable slot (like eMMC)
 - max-frequency: maximum operating clock frequency
 
 Example:
diff --git a/Documentation/devicetree/bindings/mmc/pxa-mmc.txt b/Documentation/devicetree/bindings/mmc/pxa-mmc.txt
new file mode 100644
index 000000000000..b7025de7dced
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/pxa-mmc.txt
@@ -0,0 +1,25 @@
+* PXA MMC drivers
+
+Driver bindings for the PXA MCI (MMC/SDIO) interfaces
+
+Required properties:
+- compatible: Should be "marvell,pxa-mmc".
+- vmmc-supply: A regulator for VMMC
+
+Optional properties:
+- marvell,detect-delay-ms: sets the detection delay timeout in ms.
+- marvell,gpio-power: GPIO spec for the card power enable pin
+
+This file documents differences between the core properties in mmc.txt
+and the properties used by the pxa-mmc driver.
+
+Examples:
+
+mmc0: mmc@41100000 {
+        compatible = "marvell,pxa-mmc";
+        reg = <0x41100000 0x1000>;
+        interrupts = <23>;
+        cd-gpios = <&gpio 23 0>;
+        wp-gpios = <&gpio 24 0>;
+};
+
diff --git a/Documentation/devicetree/bindings/mmc/samsung-sdhci.txt b/Documentation/devicetree/bindings/mmc/samsung-sdhci.txt
new file mode 100644
index 000000000000..630a7d7f4718
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/samsung-sdhci.txt
@@ -0,0 +1,53 @@
+* Samsung's SDHCI Controller device tree bindings
+
+Samsung's SDHCI controller is used as a connectivity interface with external
+MMC, SD and eMMC storage mediums. This file documents differences between the
+core mmc properties described by mmc.txt and the properties used by the
+Samsung implmentation of the SDHCI controller.
+
+Note: The mmc core bindings documentation states that if none of the core
+card-detect bindings are used, then the standard sdhci card detect mechanism
+is used. The Samsung's SDHCI controller bindings extends this as listed below.
+
+[A] The property "samsung,cd-pinmux-gpio" can be used as stated in the
+    "Optional Board Specific Properties" section below.
+
+[B] If core card-detect bindings and "samsung,cd-pinmux-gpio" property
+    is not specified, it is assumed that there is no card detection
+    mechanism used.
+
+Required SoC Specific Properties:
+- compatible: should be one of the following
+  - "samsung,s3c6410-sdhci": For controllers compatible with s3c6410 sdhci
+    controller.
+  - "samsung,exynos4210-sdhci": For controllers compatible with Exynos4 sdhci
+    controller.
+
+Required Board Specific Properties:
+- gpios: Should specify the gpios used for clock, command and data lines. The
+  gpio specifier format depends on the gpio controller.
+
+Optional Board Specific Properties:
+- samsung,cd-pinmux-gpio: Specifies the card detect line that is routed
+  through a pinmux to the card-detect pin of the card slot. This property
+  should be used only if none of the mmc core card-detect properties are
+  used.
+
+Example:
+        sdhci@12530000 {
+                compatible = "samsung,exynos4210-sdhci";
+                reg = <0x12530000 0x100>;
+                interrupts = <0 75 0>;
+                bus-width = <4>;
+                cd-gpios = <&gpk2 2 2 3 3>;
+                gpios = <&gpk2 0 2 0 3>,  /* clock line */
+                        <&gpk2 1 2 0 3>,  /* command line */
+                        <&gpk2 3 2 3 3>,  /* data line 0 */
+                        <&gpk2 4 2 3 3>,  /* data line 1 */
+                        <&gpk2 5 2 3 3>,  /* data line 2 */
+                        <&gpk2 6 2 3 3>;  /* data line 3 */
+        };
+
+        Note: This example shows both SoC specific and board specific properties
+        in a single device node. The properties can be actually be seperated
+        into SoC specific node and board specific node.
diff --git a/Documentation/devicetree/bindings/mmc/sdhci-dove.txt b/Documentation/devicetree/bindings/mmc/sdhci-dove.txt
new file mode 100644
index 000000000000..ae9aab9abcd7
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/sdhci-dove.txt
@@ -0,0 +1,14 @@
+* Marvell sdhci-dove controller
+
+This file documents differences between the core properties in mmc.txt
+and the properties used by the sdhci-pxav2 and sdhci-pxav3 drivers.
+
+- compatible: Should be "marvell,dove-sdhci".
+
+Example:
+
+sdio0: sdio@92000 {
+        compatible = "marvell,dove-sdhci";
+        reg = <0x92000 0x100>;
+        interrupts = <35>;
+};
diff --git a/Documentation/devicetree/bindings/mmc/sdhci-spear.txt b/Documentation/devicetree/bindings/mmc/sdhci-spear.txt
new file mode 100644
index 000000000000..fd3643e7e467
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/sdhci-spear.txt
@@ -0,0 +1,18 @@
+* SPEAr SDHCI Controller
+
+This file documents differences between the core properties in mmc.txt
+and the properties used by the sdhci-spear driver.
+
+Required properties:
+- compatible: "st,spear300-sdhci"
+
+Optional properties:
+- cd-gpios: card detect gpio, with zero flags.
+
+Example:
+
+        sdhci@fc000000 {
+                compatible = "st,spear300-sdhci";
+                reg = <0xfc000000 0x1000>;
+                cd-gpios = <&gpio0 6 0>;
+        };
diff --git a/Documentation/devicetree/bindings/mmc/synposis-dw-mshc.txt b/Documentation/devicetree/bindings/mmc/synposis-dw-mshc.txt
new file mode 100644
index 000000000000..06cd32d08052
--- /dev/null
+++ b/Documentation/devicetree/bindings/mmc/synposis-dw-mshc.txt
@@ -0,0 +1,79 @@
+* Synopsis Designware Mobile Storage Host Controller
+
+The Synopsis designware mobile storage host controller is used to interface
+a SoC with storage medium such as eMMC or SD/MMC cards. This file documents
+differences between the core mmc properties described by mmc.txt and the
+properties used by the Synopsis Designware Mobile Storage Host Controller.
+
+Required Properties:
+
+* compatible: should be
+        - snps,dw-mshc: for controllers compliant with synopsis dw-mshc.
+* #address-cells: should be 1.
+* #size-cells: should be 0.
+
+# Slots: The slot specific information are contained within child-nodes with
+  each child-node representing a supported slot. There should be atleast one
+  child node representing a card slot. The name of the child node representing
+  the slot is recommended to be slot@n where n is the unique number of the slot
+  connnected to the controller. The following are optional properties which
+  can be included in the slot child node.
+
+        * reg: specifies the physical slot number. The valid values of this
+          property is 0 to (num-slots -1), where num-slots is the value
+          specified by the num-slots property.
+
+        * bus-width: as documented in mmc core bindings.
+
+        * wp-gpios: specifies the write protect gpio line. The format of the
+          gpio specifier depends on the gpio controller. If the write-protect
+          line is not available, this property is optional.
+
+Optional properties:
+
+* num-slots: specifies the number of slots supported by the controller.
+  The number of physical slots actually used could be equal or less than the
+  value specified by num-slots. If this property is not specified, the value
+  of num-slot property is assumed to be 1.
+
+* fifo-depth: The maximum size of the tx/rx fifo's. If this property is not
+  specified, the default value of the fifo size is determined from the
+  controller registers.
+
+* card-detect-delay: Delay in milli-seconds before detecting card after card
+  insert event. The default value is 0.
+
+* supports-highspeed: Enables support for high speed cards (upto 50MHz)
+
+* broken-cd: as documented in mmc core bindings.
+
+Aliases:
+
+- All the MSHC controller nodes should be represented in the aliases node using
+  the following format 'mshc{n}' where n is a unique number for the alias.
+
+Example:
+
+The MSHC controller node can be split into two portions, SoC specific and
+board specific portions as listed below.
+
+        dwmmc0@12200000 {
+                compatible = "snps,dw-mshc";
+                reg = <0x12200000 0x1000>;
+                interrupts = <0 75 0>;
+                #address-cells = <1>;
+                #size-cells = <0>;
+        };
+
+        dwmmc0@12200000 {
+                num-slots = <1>;
+                supports-highspeed;
+                broken-cd;
+                fifo-depth = <0x80>;
+                card-detect-delay = <200>;
+
+                slot@0 {
+                        reg = <0>;
+                        bus-width = <8>;
+                };
+        };
diff --git a/Documentation/devicetree/bindings/mtd/atmel-nand.txt b/Documentation/devicetree/bindings/mtd/atmel-nand.txt
index a20069502f5a..d555421ea49f 100644
--- a/Documentation/devicetree/bindings/mtd/atmel-nand.txt
+++ b/Documentation/devicetree/bindings/mtd/atmel-nand.txt
@@ -3,7 +3,9 @@ Atmel NAND flash
 Required properties:
 - compatible : "atmel,at91rm9200-nand".
 - reg : should specify localbus address and size used for the chip,
-        and if availlable the ECC.
+        and hardware ECC controller if available.
+        If the hardware ECC is PMECC, it should contain address and size for
+        PMECC, PMECC Error Location controller and ROM which has lookup tables.
 - atmel,nand-addr-offset : offset for the address latch.
 - atmel,nand-cmd-offset : offset for the command latch.
 - #address-cells, #size-cells : Must be present if the device has sub-nodes
@@ -16,6 +18,15 @@ Optional properties:
 - nand-ecc-mode : String, operation mode of the NAND ecc mode, soft by default.
   Supported values are: "none", "soft", "hw", "hw_syndrome", "hw_oob_first",
   "soft_bch".
+- atmel,has-pmecc : boolean to enable Programmable Multibit ECC hardware.
+  Only supported by at91sam9x5 or later sam9 product.
+- atmel,pmecc-cap : error correct capability for Programmable Multibit ECC
+  Controller. Supported values are: 2, 4, 8, 12, 24.
+- atmel,pmecc-sector-size : sector size for ECC computation. Supported values
+  are: 512, 1024.
+- atmel,pmecc-lookup-table-offset : includes two offsets of lookup table in ROM
+  for different sector size. First one is for sector size 512, the next is for
+  sector size 1024.
 - nand-bus-width : 8 or 16 bus width if not present 8
 - nand-on-flash-bbt: boolean to enable on flash bbt option if not present false
 
@@ -39,3 +50,30 @@ nand0: nand@40000000,0 {
                 ...
         };
 };
+
+/* for PMECC supported chips */
+nand0: nand@40000000 {
+        compatible = "atmel,at91rm9200-nand";
+        #address-cells = <1>;
+        #size-cells = <1>;
+        reg = < 0x40000000 0x10000000   /* bus addr & size */
+                0xffffe000 0x00000600   /* PMECC addr & size */
+                0xffffe600 0x00000200   /* PMECC ERRLOC addr & size */
+                0x00100000 0x00100000   /* ROM addr & size */
+                >;
+        atmel,nand-addr-offset = <21>;  /* ale */
+        atmel,nand-cmd-offset = <22>;   /* cle */
+        nand-on-flash-bbt;
+        nand-ecc-mode = "hw";
+        atmel,has-pmecc;        /* enable PMECC */
+        atmel,pmecc-cap = <2>;
+        atmel,pmecc-sector-size = <512>;
+        atmel,pmecc-lookup-table-offset = <0x8000 0x10000>;
+        gpios = <&pioD 5 0      /* rdy */
+                 &pioD 4 0      /* nce */
+                 0              /* cd */
+                >;
+        partition@0 {
+                ...
+        };
+};
diff --git a/Documentation/devicetree/bindings/mtd/gpmi-nand.txt b/Documentation/devicetree/bindings/mtd/gpmi-nand.txt
index 1a5bbd346d22..3fb3f9015365 100644
--- a/Documentation/devicetree/bindings/mtd/gpmi-nand.txt
+++ b/Documentation/devicetree/bindings/mtd/gpmi-nand.txt
@@ -12,6 +12,10 @@ Required properties:
   - interrupt-names : The interrupt names "gpmi-dma", "bch";
   - fsl,gpmi-dma-channel : Should contain the dma channel it uses.
 
+Optional properties:
+  - nand-on-flash-bbt: boolean to enable on flash bbt option if not
+                       present false
+
 The device tree may optionally contain sub-nodes describing partitions of the
 address space. See partition.txt for more detail.
 
diff --git a/Documentation/devicetree/bindings/mtd/lpc32xx-mlc.txt b/Documentation/devicetree/bindings/mtd/lpc32xx-mlc.txt
new file mode 100644
index 000000000000..d0a37252eb22
--- /dev/null
+++ b/Documentation/devicetree/bindings/mtd/lpc32xx-mlc.txt
@@ -0,0 +1,50 @@
+NXP LPC32xx SoC NAND MLC controller
+
+Required properties:
+- compatible: "nxp,lpc3220-mlc"
+- reg: Address and size of the controller
+- interrupts: The NAND interrupt specification
+- gpios: GPIO specification for NAND write protect
+
+The following required properties are very controller specific. See the LPC32xx
+User Manual 7.5.14 MLC NAND Timing Register (the values here are specified in
+Hz, to make them independent of actual clock speed and to provide for good
+accuracy:)
+- nxp,tcea_delay: TCEA_DELAY
+- nxp,busy_delay: BUSY_DELAY
+- nxp,nand_ta: NAND_TA
+- nxp,rd_high: RD_HIGH
+- nxp,rd_low: RD_LOW
+- nxp,wr_high: WR_HIGH
+- nxp,wr_low: WR_LOW
+
+Optional subnodes:
+- Partitions, see Documentation/devicetree/bindings/mtd/partition.txt
+
+Example:
+
+        mlc: flash@200A8000 {
+                compatible = "nxp,lpc3220-mlc";
+                reg = <0x200A8000 0x11000>;
+                interrupts = <11 0>;
+                #address-cells = <1>;
+                #size-cells = <1>;
+
+                nxp,tcea-delay = <333333333>;
+                nxp,busy-delay = <10000000>;
+                nxp,nand-ta = <18181818>;
+                nxp,rd-high = <31250000>;
+                nxp,rd-low = <45454545>;
+                nxp,wr-high = <40000000>;
+                nxp,wr-low = <83333333>;
+                gpios = <&gpio 5 19 1>; /* GPO_P3 19, active low */
+
+                mtd0@00000000 {
+                        label = "boot";
+                        reg = <0x00000000 0x00064000>;
+                        read-only;
+                };
+
+                ...
+
+        };
diff --git a/Documentation/devicetree/bindings/mtd/lpc32xx-slc.txt b/Documentation/devicetree/bindings/mtd/lpc32xx-slc.txt
new file mode 100644
index 000000000000..d94edc0fc554
--- /dev/null
+++ b/Documentation/devicetree/bindings/mtd/lpc32xx-slc.txt
@@ -0,0 +1,52 @@
+NXP LPC32xx SoC NAND SLC controller
+
+Required properties:
+- compatible: "nxp,lpc3220-slc"
+- reg: Address and size of the controller
+- nand-on-flash-bbt: Use bad block table on flash
+- gpios: GPIO specification for NAND write protect
+
+The following required properties are very controller specific. See the LPC32xx
+User Manual:
+- nxp,wdr-clks: Delay before Ready signal is tested on write (W_RDY)
+- nxp,rdr-clks: Delay before Ready signal is tested on read (R_RDY)
+(The following values are specified in Hz, to make them independent of actual
+clock speed:)
+- nxp,wwidth: Write pulse width (W_WIDTH)
+- nxp,whold: Write hold time (W_HOLD)
+- nxp,wsetup: Write setup time (W_SETUP)
+- nxp,rwidth: Read pulse width (R_WIDTH)
+- nxp,rhold: Read hold time (R_HOLD)
+- nxp,rsetup: Read setup time (R_SETUP)
+
+Optional subnodes:
+- Partitions, see Documentation/devicetree/bindings/mtd/partition.txt
+
+Example:
+
+        slc: flash@20020000 {
+                compatible = "nxp,lpc3220-slc";
+                reg = <0x20020000 0x1000>;
+                #address-cells = <1>;
+                #size-cells = <1>;
+
+                nxp,wdr-clks = <14>;
+                nxp,wwidth = <40000000>;
+                nxp,whold = <100000000>;
+                nxp,wsetup = <100000000>;
+                nxp,rdr-clks = <14>;
+                nxp,rwidth = <40000000>;
+                nxp,rhold = <66666666>;
+                nxp,rsetup = <100000000>;
+                nand-on-flash-bbt;
+                gpios = <&gpio 5 19 1>; /* GPO_P3 19, active low */
+
+                mtd0@00000000 {
+                        label = "phy3250-boot";
+                        reg = <0x00000000 0x00064000>;
+                        read-only;
+                };
+
+                ...
+
+        };
diff --git a/Documentation/devicetree/bindings/mtd/mtd-physmap.txt b/Documentation/devicetree/bindings/mtd/mtd-physmap.txt
index a63c2bd7de2b..94de19b8f16b 100644
--- a/Documentation/devicetree/bindings/mtd/mtd-physmap.txt
+++ b/Documentation/devicetree/bindings/mtd/mtd-physmap.txt
@@ -16,6 +16,13 @@ file systems on embedded devices.
  - #address-cells, #size-cells : Must be present if the device has
    sub-nodes representing partitions (see below).  In this case
    both #address-cells and #size-cells must be equal to 1.
+ - no-unaligned-direct-access: boolean to disable the default direct
+   mapping of the flash.
+   On some platforms (e.g. MPC5200) a direct 1:1 mapping may cause
+   problems with JFFS2 usage, as the local bus (LPB) doesn't support
+   unaligned accesses as implemented in the JFFS2 code via memcpy().
+   By defining "no-unaligned-direct-access", the flash will not be
+   exposed directly to the MTD users (e.g. JFFS2) any more.
 
 For JEDEC compatible devices, the following additional properties
 are defined:
diff --git a/MAINTAINERS b/MAINTAINERS
index eae3cd86831e..0f6ff811da07 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1544,7 +1544,7 @@ S:	Supported
 F:      drivers/rtc/rtc-bfin.c
 
 BLACKFIN SDH DRIVER
-M:      Cliff Cai <cliff.cai@analog.com>
+M:      Sonic Zhang <sonic.zhang@analog.com>
 L:      uclinux-dist-devel@blackfin.uclinux.org
 W:      http://blackfin.uclinux.org
 S:      Supported
@@ -5207,8 +5207,10 @@ S:	Maintained
 F:      drivers/mmc/host/omap.c
 
 OMAP HS MMC SUPPORT
+M:      Venkatraman S <svenkatr@ti.com>
+L:      linux-mmc@vger.kernel.org
 L:      linux-omap@vger.kernel.org
-S:      Orphan
+S:      Maintained
 F:      drivers/mmc/host/omap_hsmmc.c
 
 OMAP RANDOM NUMBER GENERATOR SUPPORT
diff --git a/arch/arm/boot/dts/imx51.dtsi b/arch/arm/boot/dts/imx51.dtsi
index 2f71a91ca98e..75d069fcf897 100644
--- a/arch/arm/boot/dts/imx51.dtsi
+++ b/arch/arm/boot/dts/imx51.dtsi
@@ -407,6 +407,13 @@
                                 status = "disabled";
                         };
 
+                        nand@83fdb000 {
+                                compatible = "fsl,imx51-nand";
+                                reg = <0x83fdb000 0x1000 0xcfff0000 0x10000>;
+                                interrupts = <8>;
+                                status = "disabled";
+                        };
+
                         ssi3: ssi@83fe8000 {
                                 compatible = "fsl,imx51-ssi", "fsl,imx21-ssi";
                                 reg = <0x83fe8000 0x4000>;
diff --git a/arch/arm/boot/dts/imx53.dtsi b/arch/arm/boot/dts/imx53.dtsi
index 221cf3321b0a..76ebb1ad2675 100644
--- a/arch/arm/boot/dts/imx53.dtsi
+++ b/arch/arm/boot/dts/imx53.dtsi
@@ -518,6 +518,13 @@
                                 status = "disabled";
                         };
 
+                        nand@63fdb000 {
+                                compatible = "fsl,imx53-nand";
+                                reg = <0x63fdb000 0x1000 0xf7ff0000 0x10000>;
+                                interrupts = <8>;
+                                status = "disabled";
+                        };
+
                         ssi3: ssi@63fe8000 {
                                 compatible = "fsl,imx53-ssi", "fsl,imx21-ssi";
                                 reg = <0x63fe8000 0x4000>;
diff --git a/arch/arm/boot/dts/spear300-evb.dts b/arch/arm/boot/dts/spear300-evb.dts
index d71b8d581e3d..1e7c7a8e2123 100644
--- a/arch/arm/boot/dts/spear300-evb.dts
+++ b/arch/arm/boot/dts/spear300-evb.dts
@@ -80,8 +80,7 @@
                 };
 
                 sdhci@70000000 {
-                        int-gpio = <&gpio1 0 0>;
-                        power-gpio = <&gpio1 2 1>;
+                        cd-gpios = <&gpio1 0 0>;
                         status = "okay";
                 };
 
diff --git a/arch/arm/boot/dts/spear320-evb.dts b/arch/arm/boot/dts/spear320-evb.dts
index e4e912f95024..082328bd64ab 100644
--- a/arch/arm/boot/dts/spear320-evb.dts
+++ b/arch/arm/boot/dts/spear320-evb.dts
@@ -103,8 +103,6 @@
                 };
 
                 sdhci@70000000 {
-                        power-gpio = <&gpio0 2 1>;
-                        power_always_enb;
                         status = "okay";
                 };
 
diff --git a/arch/arm/configs/cam60_defconfig b/arch/arm/configs/cam60_defconfig
index cedc92ef88ab..14579711d8fc 100644
--- a/arch/arm/configs/cam60_defconfig
+++ b/arch/arm/configs/cam60_defconfig
@@ -49,7 +49,6 @@ CONFIG_MTD_COMPLEX_MAPPINGS=y
 CONFIG_MTD_PLATRAM=m
 CONFIG_MTD_DATAFLASH=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_ATMEL=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
diff --git a/arch/arm/configs/corgi_defconfig b/arch/arm/configs/corgi_defconfig
index e53c47563845..4b8a25d9e686 100644
--- a/arch/arm/configs/corgi_defconfig
+++ b/arch/arm/configs/corgi_defconfig
@@ -97,7 +97,6 @@ CONFIG_MTD_BLOCK=y
 CONFIG_MTD_ROM=y
 CONFIG_MTD_COMPLEX_MAPPINGS=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_SHARPSL=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_IDE=y
diff --git a/arch/arm/configs/ep93xx_defconfig b/arch/arm/configs/ep93xx_defconfig
index 8e97b2f7ceec..806005a4c4c1 100644
--- a/arch/arm/configs/ep93xx_defconfig
+++ b/arch/arm/configs/ep93xx_defconfig
@@ -61,7 +61,6 @@ CONFIG_MTD_CFI_STAA=y
 CONFIG_MTD_ROM=y
 CONFIG_MTD_PHYSMAP=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_BLK_DEV_NBD=y
 CONFIG_EEPROM_LEGACY=y
 CONFIG_SCSI=y
diff --git a/arch/arm/configs/mini2440_defconfig b/arch/arm/configs/mini2440_defconfig
index 082175c54e7c..00630e6af45c 100644
--- a/arch/arm/configs/mini2440_defconfig
+++ b/arch/arm/configs/mini2440_defconfig
@@ -102,7 +102,6 @@ CONFIG_MTD_CFI_STAA=y
 CONFIG_MTD_RAM=y
 CONFIG_MTD_ROM=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_S3C2410=y
 CONFIG_MTD_NAND_PLATFORM=y
 CONFIG_MTD_LPDDR=y
diff --git a/arch/arm/configs/mv78xx0_defconfig b/arch/arm/configs/mv78xx0_defconfig
index 7305ebddb510..1f08219c1b3c 100644
--- a/arch/arm/configs/mv78xx0_defconfig
+++ b/arch/arm/configs/mv78xx0_defconfig
@@ -49,7 +49,6 @@ CONFIG_MTD_CFI_INTELEXT=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_ORION=y
 CONFIG_BLK_DEV_LOOP=y
 # CONFIG_SCSI_PROC_FS is not set
diff --git a/arch/arm/configs/nhk8815_defconfig b/arch/arm/configs/nhk8815_defconfig
index bf123c5384d4..240b25eea565 100644
--- a/arch/arm/configs/nhk8815_defconfig
+++ b/arch/arm/configs/nhk8815_defconfig
@@ -57,7 +57,6 @@ CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
 CONFIG_MTD_NAND=y
 CONFIG_MTD_NAND_ECC_SMC=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_NOMADIK=y
 CONFIG_MTD_ONENAND=y
 CONFIG_MTD_ONENAND_VERIFY_WRITE=y
diff --git a/arch/arm/configs/orion5x_defconfig b/arch/arm/configs/orion5x_defconfig
index a288d7033950..cd5e6ba9a54d 100644
--- a/arch/arm/configs/orion5x_defconfig
+++ b/arch/arm/configs/orion5x_defconfig
@@ -72,7 +72,6 @@ CONFIG_MTD_CFI_INTELEXT=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_PLATFORM=y
 CONFIG_MTD_NAND_ORION=y
 CONFIG_BLK_DEV_LOOP=y
diff --git a/arch/arm/configs/pxa3xx_defconfig b/arch/arm/configs/pxa3xx_defconfig
index 1677a0607ca9..60e313834b3f 100644
--- a/arch/arm/configs/pxa3xx_defconfig
+++ b/arch/arm/configs/pxa3xx_defconfig
@@ -36,7 +36,6 @@ CONFIG_MTD_CONCAT=y
 CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_PXA3xx=y
 CONFIG_MTD_NAND_PXA3xx_BUILTIN=y
 CONFIG_MTD_ONENAND=y
diff --git a/arch/arm/configs/spitz_defconfig b/arch/arm/configs/spitz_defconfig
index 70158273c6dd..df77931a4326 100644
--- a/arch/arm/configs/spitz_defconfig
+++ b/arch/arm/configs/spitz_defconfig
@@ -94,7 +94,6 @@ CONFIG_MTD_BLOCK=y
 CONFIG_MTD_ROM=y
 CONFIG_MTD_COMPLEX_MAPPINGS=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_SHARPSL=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_IDE=y
diff --git a/arch/arm/mach-clps711x/autcpu12.c b/arch/arm/mach-clps711x/autcpu12.c
index 3fb79a1d0bde..32871918bb6e 100644
--- a/arch/arm/mach-clps711x/autcpu12.c
+++ b/arch/arm/mach-clps711x/autcpu12.c
@@ -23,6 +23,8 @@
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
 
 #include <mach/hardware.h>
 #include <asm/sizes.h>
@@ -62,9 +64,26 @@ void __init autcpu12_map_io(void)
         iotable_init(autcpu12_io_desc, ARRAY_SIZE(autcpu12_io_desc));
 }
 
+static struct resource autcpu12_nvram_resource[] __initdata = {
+        DEFINE_RES_MEM_NAMED(AUTCPU12_PHYS_NVRAM, SZ_128K, "SRAM"),
+};
+
+static struct platform_device autcpu12_nvram_pdev __initdata = {
+        .name           = "autcpu12_nvram",
+        .id             = -1,
+        .resource       = autcpu12_nvram_resource,
+        .num_resources  = ARRAY_SIZE(autcpu12_nvram_resource),
+};
+
+static void __init autcpu12_init(void)
+{
+        platform_device_register(&autcpu12_nvram_pdev);
+}
+
 MACHINE_START(AUTCPU12, "autronix autcpu12")
         /* Maintainer: Thomas Gleixner */
         .atag_offset    = 0x20000,
+        .init_machine   = autcpu12_init,
         .map_io         = autcpu12_map_io,
         .init_irq       = clps711x_init_irq,
         .timer          = &clps711x_timer,
diff --git a/arch/arm/mach-exynos/dma.c b/arch/arm/mach-exynos/dma.c
index f60b66dbcf84..21d568b3b149 100644
--- a/arch/arm/mach-exynos/dma.c
+++ b/arch/arm/mach-exynos/dma.c
@@ -303,10 +303,12 @@ static int __init exynos_dma_init(void)
 
         dma_cap_set(DMA_SLAVE, exynos_pdma0_pdata.cap_mask);
         dma_cap_set(DMA_CYCLIC, exynos_pdma0_pdata.cap_mask);
+        dma_cap_set(DMA_PRIVATE, exynos_pdma0_pdata.cap_mask);
         amba_device_register(&exynos_pdma0_device, &iomem_resource);
 
         dma_cap_set(DMA_SLAVE, exynos_pdma1_pdata.cap_mask);
         dma_cap_set(DMA_CYCLIC, exynos_pdma1_pdata.cap_mask);
+        dma_cap_set(DMA_PRIVATE, exynos_pdma1_pdata.cap_mask);
         amba_device_register(&exynos_pdma1_device, &iomem_resource);
 
         dma_cap_set(DMA_MEMCPY, exynos_mdma1_pdata.cap_mask);
diff --git a/arch/arm/mach-imx/clk-imx51-imx53.c b/arch/arm/mach-imx/clk-imx51-imx53.c
index e5165a84f93f..a0bf84803eac 100644
--- a/arch/arm/mach-imx/clk-imx51-imx53.c
+++ b/arch/arm/mach-imx/clk-imx51-imx53.c
@@ -369,6 +369,7 @@ int __init mx51_clocks_init(unsigned long rate_ckil, unsigned long rate_osc,
         clk_register_clkdev(clk[ssi1_ipg_gate], NULL, "83fcc000.ssi");
         clk_register_clkdev(clk[ssi2_ipg_gate], NULL, "70014000.ssi");
         clk_register_clkdev(clk[ssi3_ipg_gate], NULL, "83fe8000.ssi");
+        clk_register_clkdev(clk[nfc_gate], NULL, "83fdb000.nand");
 
         /* set the usboh3 parent to pll2_sw */
         clk_set_parent(clk[usboh3_sel], clk[pll2_sw]);
@@ -461,6 +462,7 @@ int __init mx53_clocks_init(unsigned long rate_ckil, unsigned long rate_osc,
         clk_register_clkdev(clk[ssi1_ipg_gate], NULL, "63fcc000.ssi");
         clk_register_clkdev(clk[ssi2_ipg_gate], NULL, "50014000.ssi");
         clk_register_clkdev(clk[ssi3_ipg_gate], NULL, "63fd0000.ssi");
+        clk_register_clkdev(clk[nfc_gate], NULL, "63fdb000.nand");
         clk_register_clkdev(clk[can1_ipg_gate], "ipg", "53fc8000.can");
         clk_register_clkdev(clk[can1_serial_gate], "per", "53fc8000.can");
         clk_register_clkdev(clk[can2_ipg_gate], "ipg", "53fcc000.can");
diff --git a/arch/arm/mach-spear13xx/spear13xx.c b/arch/arm/mach-spear13xx/spear13xx.c
index e10648801b2e..5633d698f1e1 100644
--- a/arch/arm/mach-spear13xx/spear13xx.c
+++ b/arch/arm/mach-spear13xx/spear13xx.c
@@ -78,6 +78,9 @@ struct dw_dma_platform_data dmac_plat_data = {
         .nr_channels = 8,
         .chan_allocation_order = CHAN_ALLOCATION_DESCENDING,
         .chan_priority = CHAN_PRIORITY_DESCENDING,
+        .block_size = 4095U,
+        .nr_masters = 2,
+        .data_width = { 3, 3, 0, 0 },
 };
 
 void __init spear13xx_l2x0_init(void)
diff --git a/arch/arm/plat-mxc/devices/platform-mxc_nand.c b/arch/arm/plat-mxc/devices/platform-mxc_nand.c
index 1568f39fba8b..95b75cc70515 100644
--- a/arch/arm/plat-mxc/devices/platform-mxc_nand.c
+++ b/arch/arm/plat-mxc/devices/platform-mxc_nand.c
@@ -63,10 +63,6 @@ struct platform_device *__init imx_add_mxc_nand(
         /* AXI has to come first, that's how the mxc_nand driver expect it */
         struct resource res[] = {
                 {
-                        .start = data->axibase,
-                        .end = data->axibase + SZ_16K - 1,
-                        .flags = IORESOURCE_MEM,
-                }, {
                         .start = data->iobase,
                         .end = data->iobase + data->iosize - 1,
                         .flags = IORESOURCE_MEM,
@@ -74,10 +70,13 @@ struct platform_device *__init imx_add_mxc_nand(
                         .start = data->irq,
                         .end = data->irq,
                         .flags = IORESOURCE_IRQ,
+                }, {
+                        .start = data->axibase,
+                        .end = data->axibase + SZ_16K - 1,
+                        .flags = IORESOURCE_MEM,
                 },
         };
         return imx_add_platform_device("mxc_nand", data->id,
-                        res + !data->axibase,
-                        ARRAY_SIZE(res) - !data->axibase,
+                        res, ARRAY_SIZE(res) - !data->axibase,
                         pdata, sizeof(*pdata));
 }
diff --git a/arch/avr32/mach-at32ap/at32ap700x.c b/arch/avr32/mach-at32ap/at32ap700x.c
index 0445c4fd67e3..b323d8d3185b 100644
--- a/arch/avr32/mach-at32ap/at32ap700x.c
+++ b/arch/avr32/mach-at32ap/at32ap700x.c
@@ -605,6 +605,9 @@ static void __init genclk_init_parent(struct clk *clk)
 
 static struct dw_dma_platform_data dw_dmac0_data = {
         .nr_channels    = 3,
+        .block_size     = 4095U,
+        .nr_masters     = 2,
+        .data_width     = { 2, 2, 0, 0 },
 };
 
 static struct resource dw_dmac0_resource[] = {
diff --git a/arch/blackfin/configs/BF561-ACVILON_defconfig b/arch/blackfin/configs/BF561-ACVILON_defconfig
index 0fdc4ecaa531..91988370b75e 100644
--- a/arch/blackfin/configs/BF561-ACVILON_defconfig
+++ b/arch/blackfin/configs/BF561-ACVILON_defconfig
@@ -57,7 +57,6 @@ CONFIG_MTD_PLATRAM=y
 CONFIG_MTD_PHRAM=y
 CONFIG_MTD_BLOCK2MTD=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_PLATFORM=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
diff --git a/arch/mips/configs/rb532_defconfig b/arch/mips/configs/rb532_defconfig
index 55902d9cd0f2..b85b121397c8 100644
--- a/arch/mips/configs/rb532_defconfig
+++ b/arch/mips/configs/rb532_defconfig
@@ -119,7 +119,6 @@ CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
 CONFIG_MTD_BLOCK2MTD=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_PLATFORM=y
 CONFIG_ATA=y
 # CONFIG_ATA_VERBOSE_ERROR is not set
diff --git a/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig b/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
index 126ef1b08a01..e4ad2e27551a 100644
--- a/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
+++ b/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
@@ -38,7 +38,6 @@ CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP_OF=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_FSL_ELBC=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
diff --git a/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig b/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
index abcf00ad939e..34ff5686be08 100644
--- a/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
+++ b/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
@@ -37,7 +37,6 @@ CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP_OF=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
diff --git a/arch/powerpc/configs/mpc83xx_defconfig b/arch/powerpc/configs/mpc83xx_defconfig
index 9352e4430c3b..09116c6a6719 100644
--- a/arch/powerpc/configs/mpc83xx_defconfig
+++ b/arch/powerpc/configs/mpc83xx_defconfig
@@ -50,7 +50,6 @@ CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP_OF=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_VERIFY_WRITE=y
 CONFIG_MTD_NAND_FSL_ELBC=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild
index f80ff93f6f75..61d41c11ee0a 100644
--- a/arch/sparc/include/asm/Kbuild
+++ b/arch/sparc/include/asm/Kbuild
@@ -1,21 +1,5 @@
 # User exported sparc header files
-include include/asm-generic/Kbuild.asm
 
-header-y += apc.h
-header-y += asi.h
-header-y += display7seg.h
-header-y += envctrl.h
-header-y += fbio.h
-header-y += jsflash.h
-header-y += openpromio.h
-header-y += perfctr.h
-header-y += psrcompat.h
-header-y += psr.h
-header-y += pstate.h
-header-y += traps.h
-header-y += uctx.h
-header-y += utrap.h
-header-y += watchdog.h
 
 generic-y += clkdev.h
 generic-y += div64.h
diff --git a/arch/sparc/include/asm/fbio.h b/arch/sparc/include/asm/fbio.h
index 0a21da87f7d6..1d9afe277e9c 100644
--- a/arch/sparc/include/asm/fbio.h
+++ b/arch/sparc/include/asm/fbio.h
@@ -1,225 +1,10 @@
 #ifndef __LINUX_FBIO_H
 #define __LINUX_FBIO_H
 
-#include <linux/compiler.h>
-#include <linux/types.h>
+#include <uapi/asm/fbio.h>
 
-/* Constants used for fbio SunOS compatibility */
-/* (C) 1996 Miguel de Icaza */
-
-/* Frame buffer types */
-#define FBTYPE_NOTYPE           -1
-#define FBTYPE_SUN1BW           0   /* mono */
-#define FBTYPE_SUN1COLOR        1 
-#define FBTYPE_SUN2BW           2 
-#define FBTYPE_SUN2COLOR        3 
-#define FBTYPE_SUN2GP           4 
-#define FBTYPE_SUN5COLOR        5 
-#define FBTYPE_SUN3COLOR        6 
-#define FBTYPE_MEMCOLOR         7 
-#define FBTYPE_SUN4COLOR        8 
- 
-#define FBTYPE_NOTSUN1          9 
-#define FBTYPE_NOTSUN2          10
-#define FBTYPE_NOTSUN3          11
- 
-#define FBTYPE_SUNFAST_COLOR    12  /* cg6 */
-#define FBTYPE_SUNROP_COLOR     13
-#define FBTYPE_SUNFB_VIDEO      14
-#define FBTYPE_SUNGIFB          15
-#define FBTYPE_SUNGPLAS         16
-#define FBTYPE_SUNGP3           17
-#define FBTYPE_SUNGT            18
-#define FBTYPE_SUNLEO           19      /* zx Leo card */
-#define FBTYPE_MDICOLOR         20      /* cg14 */
-#define FBTYPE_TCXCOLOR         21      /* SUNW,tcx card */
-
-#define FBTYPE_LASTPLUSONE      21      /* This is not last + 1 in fact... */
-
-/* Does not seem to be listed in the Sun file either */
-#define FBTYPE_CREATOR          22
-#define FBTYPE_PCI_IGA1682      23
-#define FBTYPE_P9100COLOR       24
-
-#define FBTYPE_PCI_GENERIC      1000
-#define FBTYPE_PCI_MACH64       1001
-
-/* fbio ioctls */
-/* Returned by FBIOGTYPE */
-struct  fbtype {
-        int     fb_type;        /* fb type, see above */
-        int     fb_height;      /* pixels */
-        int     fb_width;       /* pixels */
-        int     fb_depth;
-        int     fb_cmsize;      /* color map entries */
-        int     fb_size;        /* fb size in bytes */
-};
-#define FBIOGTYPE _IOR('F', 0, struct fbtype)
-
-struct  fbcmap {
-        int             index;          /* first element (0 origin) */
-        int             count;
-        unsigned char   __user *red;
-        unsigned char   __user *green;
-        unsigned char   __user *blue;
-};
-
-#ifdef __KERNEL__
 #define FBIOPUTCMAP_SPARC _IOW('F', 3, struct fbcmap)
 #define FBIOGETCMAP_SPARC _IOW('F', 4, struct fbcmap)
-#else
-#define FBIOPUTCMAP _IOW('F', 3, struct fbcmap)
-#define FBIOGETCMAP _IOW('F', 4, struct fbcmap)
-#endif
-
-/* # of device specific values */
-#define FB_ATTR_NDEVSPECIFIC    8
-/* # of possible emulations */
-#define FB_ATTR_NEMUTYPES       4
- 
-struct fbsattr {
-        int     flags;
-        int     emu_type;       /* -1 if none */
-        int     dev_specific[FB_ATTR_NDEVSPECIFIC];
-};
- 
-struct fbgattr {
-        int     real_type;      /* real frame buffer type */
-        int     owner;          /* unknown */
-        struct fbtype fbtype;   /* real frame buffer fbtype */
-        struct fbsattr sattr;   
-        int     emu_types[FB_ATTR_NEMUTYPES]; /* supported emulations */
-};
-#define FBIOSATTR  _IOW('F', 5, struct fbgattr) /* Unsupported: */
-#define FBIOGATTR  _IOR('F', 6, struct fbgattr) /* supported */
-
-#define FBIOSVIDEO _IOW('F', 7, int)
-#define FBIOGVIDEO _IOR('F', 8, int)
-
-struct fbcursor {
-        short set;              /* what to set, choose from the list above */
-        short enable;           /* cursor on/off */
-        struct fbcurpos pos;    /* cursor position */
-        struct fbcurpos hot;    /* cursor hot spot */
-        struct fbcmap cmap;     /* color map info */
-        struct fbcurpos size;   /* cursor bit map size */
-        char __user *image;     /* cursor image bits */
-        char __user *mask;      /* cursor mask bits */
-};
-
-/* set/get cursor attributes/shape */
-#define FBIOSCURSOR     _IOW('F', 24, struct fbcursor)
-#define FBIOGCURSOR     _IOWR('F', 25, struct fbcursor)
- 
-/* set/get cursor position */
-#define FBIOSCURPOS     _IOW('F', 26, struct fbcurpos)
-#define FBIOGCURPOS     _IOW('F', 27, struct fbcurpos)
- 
-/* get max cursor size */
-#define FBIOGCURMAX     _IOR('F', 28, struct fbcurpos)
-
-/* wid manipulation */
-struct fb_wid_alloc {
-#define FB_WID_SHARED_8         0
-#define FB_WID_SHARED_24        1
-#define FB_WID_DBL_8            2
-#define FB_WID_DBL_24           3
-        __u32   wa_type;
-        __s32   wa_index;       /* Set on return */
-        __u32   wa_count;       
-};
-struct fb_wid_item {
-        __u32   wi_type;
-        __s32   wi_index;
-        __u32   wi_attrs;
-        __u32   wi_values[32];
-};
-struct fb_wid_list {
-        __u32   wl_flags;
-        __u32   wl_count;
-        struct fb_wid_item      *wl_list;
-};
-
-#define FBIO_WID_ALLOC  _IOWR('F', 30, struct fb_wid_alloc)
-#define FBIO_WID_FREE   _IOW('F', 31, struct fb_wid_alloc)
-#define FBIO_WID_PUT    _IOW('F', 32, struct fb_wid_list)
-#define FBIO_WID_GET    _IOWR('F', 33, struct fb_wid_list)
-
-/* Creator ioctls */
-#define FFB_IOCTL       ('F'<<8)
-#define FFB_SYS_INFO            (FFB_IOCTL|80)
-#define FFB_CLUTREAD            (FFB_IOCTL|81)
-#define FFB_CLUTPOST            (FFB_IOCTL|82)
-#define FFB_SETDIAGMODE         (FFB_IOCTL|83)
-#define FFB_GETMONITORID        (FFB_IOCTL|84)
-#define FFB_GETVIDEOMODE        (FFB_IOCTL|85)
-#define FFB_SETVIDEOMODE        (FFB_IOCTL|86)
-#define FFB_SETSERVER           (FFB_IOCTL|87)
-#define FFB_SETOVCTL            (FFB_IOCTL|88)
-#define FFB_GETOVCTL            (FFB_IOCTL|89)
-#define FFB_GETSAXNUM           (FFB_IOCTL|90)
-#define FFB_FBDEBUG             (FFB_IOCTL|91)
-
-/* Cg14 ioctls */
-#define MDI_IOCTL          ('M'<<8)
-#define MDI_RESET          (MDI_IOCTL|1)
-#define MDI_GET_CFGINFO    (MDI_IOCTL|2)
-#define MDI_SET_PIXELMODE  (MDI_IOCTL|3)
-#    define MDI_32_PIX     32
-#    define MDI_16_PIX     16
-#    define MDI_8_PIX      8
-
-struct mdi_cfginfo {
-        int     mdi_ncluts;     /* Number of implemented CLUTs in this MDI */
-        int     mdi_type;       /* FBTYPE name */
-        int     mdi_height;     /* height */
-        int     mdi_width;      /* width */
-        int     mdi_size;       /* available ram */
-        int     mdi_mode;       /* 8bpp, 16bpp or 32bpp */
-        int     mdi_pixfreq;    /* pixel clock (from PROM) */
-};
-
-/* SparcLinux specific ioctl for the MDI, should be replaced for
- * the SET_XLUT/SET_CLUTn ioctls instead
- */
-#define MDI_CLEAR_XLUT       (MDI_IOCTL|9)
-
-/* leo & ffb ioctls */
-struct fb_clut_alloc {
-        __u32   clutid; /* Set on return */
-        __u32   flag;
-        __u32   index;
-};
-
-struct fb_clut {
-#define FB_CLUT_WAIT    0x00000001      /* Not yet implemented */
-        __u32   flag;
-        __u32   clutid;
-        __u32   offset;
-        __u32   count;
-        char *  red;
-        char *  green;
-        char *  blue;
-};
-
-struct fb_clut32 {
-        __u32   flag;
-        __u32   clutid;
-        __u32   offset;
-        __u32   count;
-        __u32   red;
-        __u32   green;
-        __u32   blue;
-};
-
-#define LEO_CLUTALLOC   _IOWR('L', 53, struct fb_clut_alloc)
-#define LEO_CLUTFREE    _IOW('L', 54, struct fb_clut_alloc)
-#define LEO_CLUTREAD    _IOW('L', 55, struct fb_clut)
-#define LEO_CLUTPOST    _IOW('L', 56, struct fb_clut)
-#define LEO_SETGAMMA    _IOW('L', 68, int) /* Not yet implemented */
-#define LEO_GETGAMMA    _IOR('L', 69, int) /* Not yet implemented */
-
-#ifdef __KERNEL__
 /* Addresses on the fd of a cgsix that are mappable */
 #define CG6_FBC    0x70000000
 #define CG6_TEC    0x70001000
@@ -260,47 +45,6 @@ struct fb_clut32 {
 #define CG14_CLUT3       0x6000  /* Color Look Up Table */
 #define CG14_AUTO        0xf000
 
-#endif /* KERNEL */
-
-/* These are exported to userland for applications to use */
-/* Mappable offsets for the cg14: control registers */
-#define MDI_DIRECT_MAP 0x10000000
-#define MDI_CTLREG_MAP 0x20000000
-#define MDI_CURSOR_MAP 0x30000000
-#define MDI_SHDW_VRT_MAP 0x40000000
-
-/* Mappable offsets for the cg14: frame buffer resolutions */
-/* 32 bits */
-#define MDI_CHUNKY_XBGR_MAP 0x50000000
-#define MDI_CHUNKY_BGR_MAP 0x60000000
-
-/* 16 bits */
-#define MDI_PLANAR_X16_MAP 0x70000000
-#define MDI_PLANAR_C16_MAP 0x80000000
-
-/* 8 bit is done as CG3 MMAP offset */
-/* 32 bits, planar */
-#define MDI_PLANAR_X32_MAP 0x90000000
-#define MDI_PLANAR_B32_MAP 0xa0000000
-#define MDI_PLANAR_G32_MAP 0xb0000000
-#define MDI_PLANAR_R32_MAP 0xc0000000
-
-/* Mappable offsets on leo */
-#define LEO_SS0_MAP            0x00000000
-#define LEO_LC_SS0_USR_MAP     0x00800000
-#define LEO_LD_SS0_MAP         0x00801000
-#define LEO_LX_CURSOR_MAP      0x00802000
-#define LEO_SS1_MAP            0x00803000
-#define LEO_LC_SS1_USR_MAP     0x01003000
-#define LEO_LD_SS1_MAP         0x01004000
-#define LEO_UNK_MAP            0x01005000
-#define LEO_LX_KRN_MAP         0x01006000
-#define LEO_LC_SS0_KRN_MAP     0x01007000
-#define LEO_LC_SS1_KRN_MAP     0x01008000
-#define LEO_LD_GBL_MAP         0x01009000
-#define LEO_UNK2_MAP           0x0100a000
-
-#ifdef __KERNEL__
 struct  fbcmap32 {
         int             index;          /* first element (0 origin) */
         int             count;
@@ -325,6 +69,4 @@ struct fbcursor32 {
 
 #define FBIOSCURSOR32   _IOW('F', 24, struct fbcursor32)
 #define FBIOGCURSOR32   _IOW('F', 25, struct fbcursor32)
-#endif
-
 #endif /* __LINUX_FBIO_H */
diff --git a/arch/sparc/include/asm/ioctls.h b/arch/sparc/include/asm/ioctls.h
index 28d0c8b02cc3..77413b7e3a18 100644
--- a/arch/sparc/include/asm/ioctls.h
+++ b/arch/sparc/include/asm/ioctls.h
@@ -1,123 +1,8 @@
 #ifndef _ASM_SPARC_IOCTLS_H
 #define _ASM_SPARC_IOCTLS_H
 
-#include <asm/ioctl.h>
+#include <uapi/asm/ioctls.h>
 
-/* Big T */
-#define TCGETA          _IOR('T', 1, struct termio)
-#define TCSETA          _IOW('T', 2, struct termio)
-#define TCSETAW         _IOW('T', 3, struct termio)
-#define TCSETAF         _IOW('T', 4, struct termio)
-#define TCSBRK          _IO('T', 5)
-#define TCXONC          _IO('T', 6)
-#define TCFLSH          _IO('T', 7)
-#define TCGETS          _IOR('T', 8, struct termios)
-#define TCSETS          _IOW('T', 9, struct termios)
-#define TCSETSW         _IOW('T', 10, struct termios)
-#define TCSETSF         _IOW('T', 11, struct termios)
-#define TCGETS2         _IOR('T', 12, struct termios2)
-#define TCSETS2         _IOW('T', 13, struct termios2)
-#define TCSETSW2        _IOW('T', 14, struct termios2)
-#define TCSETSF2        _IOW('T', 15, struct termios2)
-#define TIOCGDEV        _IOR('T',0x32, unsigned int) /* Get primary device node of /dev/console */
-#define TIOCVHANGUP     _IO('T', 0x37)
-
-/* Note that all the ioctls that are not available in Linux have a 
- * double underscore on the front to: a) avoid some programs to
- * think we support some ioctls under Linux (autoconfiguration stuff)
- */
-/* Little t */
-#define TIOCGETD        _IOR('t', 0, int)
-#define TIOCSETD        _IOW('t', 1, int)
-#define __TIOCHPCL        _IO('t', 2) /* SunOS Specific */
-#define __TIOCMODG        _IOR('t', 3, int) /* SunOS Specific */
-#define __TIOCMODS        _IOW('t', 4, int) /* SunOS Specific */
-#define __TIOCGETP        _IOR('t', 8, struct sgttyb) /* SunOS Specific */
-#define __TIOCSETP        _IOW('t', 9, struct sgttyb) /* SunOS Specific */
-#define __TIOCSETN        _IOW('t', 10, struct sgttyb) /* SunOS Specific */
-#define TIOCEXCL        _IO('t', 13)
-#define TIOCNXCL        _IO('t', 14)
-#define __TIOCFLUSH       _IOW('t', 16, int) /* SunOS Specific */
-#define __TIOCSETC        _IOW('t', 17, struct tchars) /* SunOS Specific */
-#define __TIOCGETC        _IOR('t', 18, struct tchars) /* SunOS Specific */
-#define __TIOCTCNTL       _IOW('t', 32, int) /* SunOS Specific */
-#define __TIOCSIGNAL      _IOW('t', 33, int) /* SunOS Specific */
-#define __TIOCSETX        _IOW('t', 34, int) /* SunOS Specific */
-#define __TIOCGETX        _IOR('t', 35, int) /* SunOS Specific */
-#define TIOCCONS        _IO('t', 36)
-#define TIOCGSOFTCAR    _IOR('t', 100, int)
-#define TIOCSSOFTCAR    _IOW('t', 101, int)
-#define __TIOCUCNTL       _IOW('t', 102, int) /* SunOS Specific */
-#define TIOCSWINSZ      _IOW('t', 103, struct winsize)
-#define TIOCGWINSZ      _IOR('t', 104, struct winsize)
-#define __TIOCREMOTE      _IOW('t', 105, int) /* SunOS Specific */
-#define TIOCMGET        _IOR('t', 106, int)
-#define TIOCMBIC        _IOW('t', 107, int)
-#define TIOCMBIS        _IOW('t', 108, int)
-#define TIOCMSET        _IOW('t', 109, int)
-#define TIOCSTART       _IO('t', 110)
-#define TIOCSTOP        _IO('t', 111)
-#define TIOCPKT         _IOW('t', 112, int)
-#define TIOCNOTTY       _IO('t', 113)
-#define TIOCSTI         _IOW('t', 114, char)
-#define TIOCOUTQ        _IOR('t', 115, int)
-#define __TIOCGLTC        _IOR('t', 116, struct ltchars) /* SunOS Specific */
-#define __TIOCSLTC        _IOW('t', 117, struct ltchars) /* SunOS Specific */
-/* 118 is the non-posix setpgrp tty ioctl */
-/* 119 is the non-posix getpgrp tty ioctl */
-#define __TIOCCDTR        _IO('t', 120) /* SunOS Specific */
-#define __TIOCSDTR        _IO('t', 121) /* SunOS Specific */
-#define TIOCCBRK        _IO('t', 122)
-#define TIOCSBRK        _IO('t', 123)
-#define __TIOCLGET        _IOW('t', 124, int) /* SunOS Specific */
-#define __TIOCLSET        _IOW('t', 125, int) /* SunOS Specific */
-#define __TIOCLBIC        _IOW('t', 126, int) /* SunOS Specific */
-#define __TIOCLBIS        _IOW('t', 127, int) /* SunOS Specific */
-#define __TIOCISPACE      _IOR('t', 128, int) /* SunOS Specific */
-#define __TIOCISIZE       _IOR('t', 129, int) /* SunOS Specific */
-#define TIOCSPGRP       _IOW('t', 130, int)
-#define TIOCGPGRP       _IOR('t', 131, int)
-#define TIOCSCTTY       _IO('t', 132)
-#define TIOCGSID        _IOR('t', 133, int)
-/* Get minor device of a pty master's FD -- Solaris equiv is ISPTM */
-#define TIOCGPTN        _IOR('t', 134, unsigned int) /* Get Pty Number */
-#define TIOCSPTLCK      _IOW('t', 135, int) /* Lock/unlock PTY */
-#define TIOCSIG         _IOW('t', 136, int) /* Generate signal on Pty slave */
-
-/* Little f */
-#define FIOCLEX         _IO('f', 1)
-#define FIONCLEX        _IO('f', 2)
-#define FIOASYNC        _IOW('f', 125, int)
-#define FIONBIO         _IOW('f', 126, int)
-#define FIONREAD        _IOR('f', 127, int)
-#define TIOCINQ         FIONREAD
-#define FIOQSIZE        _IOR('f', 128, loff_t)
-
-/* SCARY Rutgers local SunOS kernel hackery, perhaps I will support it
- * someday.  This is completely bogus, I know...
- */
-#define __TCGETSTAT       _IO('T', 200) /* Rutgers specific */
-#define __TCSETSTAT       _IO('T', 201) /* Rutgers specific */
-
-/* Linux specific, no SunOS equivalent. */
-#define TIOCLINUX       0x541C
-#define TIOCGSERIAL     0x541E
-#define TIOCSSERIAL     0x541F
-#define TCSBRKP         0x5425
-#define TIOCSERCONFIG   0x5453
-#define TIOCSERGWILD    0x5454
-#define TIOCSERSWILD    0x5455
-#define TIOCGLCKTRMIOS  0x5456
-#define TIOCSLCKTRMIOS  0x5457
-#define TIOCSERGSTRUCT  0x5458 /* For debugging only */
-#define TIOCSERGETLSR   0x5459 /* Get line status register */
-#define TIOCSERGETMULTI 0x545A /* Get multiport config  */
-#define TIOCSERSETMULTI 0x545B /* Set multiport config */
-#define TIOCMIWAIT      0x545C /* Wait for change on serial input line(s) */
-#define TIOCGICOUNT     0x545D /* Read serial port inline interrupt counts */
-
-/* Kernel definitions */
-#ifdef __KERNEL__
 #define TIOCGETC __TIOCGETC
 #define TIOCGETP __TIOCGETP
 #define TIOCGLTC __TIOCGLTC
@@ -125,16 +10,4 @@
 #define TIOCSETP __TIOCSETP
 #define TIOCSETN __TIOCSETN
 #define TIOCSETC __TIOCSETC
-#endif
-
-/* Used for packet mode */
-#define TIOCPKT_DATA             0
-#define TIOCPKT_FLUSHREAD        1
-#define TIOCPKT_FLUSHWRITE       2
-#define TIOCPKT_STOP             4
-#define TIOCPKT_START            8
-#define TIOCPKT_NOSTOP          16
-#define TIOCPKT_DOSTOP          32
-#define TIOCPKT_IOCTL           64
-
 #endif /* !(_ASM_SPARC_IOCTLS_H) */
diff --git a/arch/sparc/include/asm/mman.h b/arch/sparc/include/asm/mman.h
index c3029ad6619a..59bb5938d852 100644
--- a/arch/sparc/include/asm/mman.h
+++ b/arch/sparc/include/asm/mman.h
@@ -1,33 +1,10 @@
 #ifndef __SPARC_MMAN_H__
 #define __SPARC_MMAN_H__
 
-#include <asm-generic/mman-common.h>
+#include <uapi/asm/mman.h>
 
-/* SunOS'ified... */
-
-#define MAP_RENAME      MAP_ANONYMOUS   /* In SunOS terminology */
-#define MAP_NORESERVE   0x40            /* don't reserve swap pages */
-#define MAP_INHERIT     0x80            /* SunOS doesn't do this, but... */
-#define MAP_LOCKED      0x100           /* lock the mapping */
-#define _MAP_NEW        0x80000000      /* Binary compatibility is fun... */
-
-#define MAP_GROWSDOWN   0x0200          /* stack-like segment */
-#define MAP_DENYWRITE   0x0800          /* ETXTBSY */
-#define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
-
-#define MCL_CURRENT     0x2000          /* lock all currently mapped pages */
-#define MCL_FUTURE      0x4000          /* lock all additions to address space */
-
-#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
-#define MAP_NONBLOCK    0x10000         /* do not block on IO */
-#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
-#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
-
-#ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 #define arch_mmap_check(addr,len,flags) sparc_mmap_check(addr,len)
 int sparc_mmap_check(unsigned long addr, unsigned long len);
 #endif
-#endif
-
 #endif /* __SPARC_MMAN_H__ */
diff --git a/arch/sparc/include/asm/psr.h b/arch/sparc/include/asm/psr.h
index cee7ed9c927d..e71eb57945e0 100644
--- a/arch/sparc/include/asm/psr.h
+++ b/arch/sparc/include/asm/psr.h
@@ -7,43 +7,11 @@
  *
  * Copyright (C) 1994 David S. Miller (davem@caip.rutgers.edu)
  */
-
 #ifndef __LINUX_SPARC_PSR_H
 #define __LINUX_SPARC_PSR_H
 
-/* The Sparc PSR fields are laid out as the following:
- *
- *  ------------------------------------------------------------------------
- *  | impl  | vers  | icc   | resv  | EC | EF | PIL  | S | PS | ET |  CWP  |
- *  | 31-28 | 27-24 | 23-20 | 19-14 | 13 | 12 | 11-8 | 7 | 6  | 5  |  4-0  |
- *  ------------------------------------------------------------------------
- */
-#define PSR_CWP     0x0000001f         /* current window pointer     */
-#define PSR_ET      0x00000020         /* enable traps field         */
-#define PSR_PS      0x00000040         /* previous privilege level   */
-#define PSR_S       0x00000080         /* current privilege level    */
-#define PSR_PIL     0x00000f00         /* processor interrupt level  */
-#define PSR_EF      0x00001000         /* enable floating point      */
-#define PSR_EC      0x00002000         /* enable co-processor        */
-#define PSR_SYSCALL 0x00004000         /* inside of a syscall        */
-#define PSR_LE      0x00008000         /* SuperSparcII little-endian */
-#define PSR_ICC     0x00f00000         /* integer condition codes    */
-#define PSR_C       0x00100000         /* carry bit                  */
-#define PSR_V       0x00200000         /* overflow bit               */
-#define PSR_Z       0x00400000         /* zero bit                   */
-#define PSR_N       0x00800000         /* negative bit               */
-#define PSR_VERS    0x0f000000         /* cpu-version field          */
-#define PSR_IMPL    0xf0000000         /* cpu-implementation field   */
-
-#define PSR_VERS_SHIFT          24
-#define PSR_IMPL_SHIFT          28
-#define PSR_VERS_SHIFTED_MASK   0xf
-#define PSR_IMPL_SHIFTED_MASK   0xf
-
-#define PSR_IMPL_TI             0x4
-#define PSR_IMPL_LEON           0xf
+#include <uapi/asm/psr.h>
 
-#ifdef __KERNEL__
 
 #ifndef __ASSEMBLY__
 /* Get the %psr register. */
@@ -96,6 +64,4 @@ static inline unsigned int get_fsr(void)
 
 #endif /* !(__ASSEMBLY__) */
 
-#endif /* (__KERNEL__) */
-
 #endif /* !(__LINUX_SPARC_PSR_H) */
diff --git a/arch/sparc/include/asm/ptrace.h b/arch/sparc/include/asm/ptrace.h
index fd9c3f21cbf0..0c6f6b068289 100644
--- a/arch/sparc/include/asm/ptrace.h
+++ b/arch/sparc/include/asm/ptrace.h
@@ -1,169 +1,11 @@
 #ifndef __SPARC_PTRACE_H
 #define __SPARC_PTRACE_H
 
-#if defined(__sparc__) && defined(__arch64__)
-/* 64 bit sparc */
-#include <asm/pstate.h>
-
-/* This struct defines the way the registers are stored on the
- * stack during a system call and basically all traps.
- */
-
-/* This magic value must have the low 9 bits clear,
- * as that is where we encode the %tt value, see below.
- */
-#define PT_REGS_MAGIC 0x57ac6c00
-
-#ifndef __ASSEMBLY__
-
-#include <linux/types.h>
-
-struct pt_regs {
-        unsigned long u_regs[16]; /* globals and ins */
-        unsigned long tstate;
-        unsigned long tpc;
-        unsigned long tnpc;
-        unsigned int y;
-
-        /* We encode a magic number, PT_REGS_MAGIC, along
-         * with the %tt (trap type) register value at trap
-         * entry time.  The magic number allows us to identify
-         * accurately a trap stack frame in the stack
-         * unwinder, and the %tt value allows us to test
-         * things like "in a system call" etc. for an arbitray
-         * process.
-         *
-         * The PT_REGS_MAGIC is chosen such that it can be
-         * loaded completely using just a sethi instruction.
-         */
-        unsigned int magic;
-};
-
-struct pt_regs32 {
-        unsigned int psr;
-        unsigned int pc;
-        unsigned int npc;
-        unsigned int y;
-        unsigned int u_regs[16]; /* globals and ins */
-};
-
-/* A V9 register window */
-struct reg_window {
-        unsigned long locals[8];
-        unsigned long ins[8];
-};
-
-/* A 32-bit register window. */
-struct reg_window32 {
-        unsigned int locals[8];
-        unsigned int ins[8];
-};
-
-/* A V9 Sparc stack frame */
-struct sparc_stackf {
-        unsigned long locals[8];
-        unsigned long ins[6];
-        struct sparc_stackf *fp;
-        unsigned long callers_pc;
-        char *structptr;
-        unsigned long xargs[6];
-        unsigned long xxargs[1];
-};
-
-/* A 32-bit Sparc stack frame */
-struct sparc_stackf32 {
-        unsigned int locals[8];
-        unsigned int ins[6];
-        unsigned int fp;
-        unsigned int callers_pc;
-        unsigned int structptr;
-        unsigned int xargs[6];
-        unsigned int xxargs[1];
-};
-
-struct sparc_trapf {
-        unsigned long locals[8];
-        unsigned long ins[8];
-        unsigned long _unused;
-        struct pt_regs *regs;
-};
-#endif /* (!__ASSEMBLY__) */
-#else
-/* 32 bit sparc */
-
-#include <asm/psr.h>
-
-/* This struct defines the way the registers are stored on the
- * stack during a system call and basically all traps.
- */
-#ifndef __ASSEMBLY__
-
-#include <linux/types.h>
-
-struct pt_regs {
-        unsigned long psr;
-        unsigned long pc;
-        unsigned long npc;
-        unsigned long y;
-        unsigned long u_regs[16]; /* globals and ins */
-};
-
-/* A 32-bit register window. */
-struct reg_window32 {
-        unsigned long locals[8];
-        unsigned long ins[8];
-};
-
-/* A Sparc stack frame */
-struct sparc_stackf {
-        unsigned long locals[8];
-        unsigned long ins[6];
-        struct sparc_stackf *fp;
-        unsigned long callers_pc;
-        char *structptr;
-        unsigned long xargs[6];
-        unsigned long xxargs[1];
-};
-#endif /* (!__ASSEMBLY__) */
-
-#endif /* (defined(__sparc__) && defined(__arch64__))*/
-
-#ifndef __ASSEMBLY__
-
-#define TRACEREG_SZ     sizeof(struct pt_regs)
-#define STACKFRAME_SZ   sizeof(struct sparc_stackf)
-
-#define TRACEREG32_SZ   sizeof(struct pt_regs32)
-#define STACKFRAME32_SZ sizeof(struct sparc_stackf32)
-
-#endif /* (!__ASSEMBLY__) */
-
-#define UREG_G0        0
-#define UREG_G1        1
-#define UREG_G2        2
-#define UREG_G3        3
-#define UREG_G4        4
-#define UREG_G5        5
-#define UREG_G6        6
-#define UREG_G7        7
-#define UREG_I0        8
-#define UREG_I1        9
-#define UREG_I2        10
-#define UREG_I3        11
-#define UREG_I4        12
-#define UREG_I5        13
-#define UREG_I6        14
-#define UREG_I7        15
-#define UREG_FP        UREG_I6
-#define UREG_RETPC     UREG_I7
+#include <uapi/asm/ptrace.h>
 
 #if defined(__sparc__) && defined(__arch64__)
-/* 64 bit sparc */
-
 #ifndef __ASSEMBLY__
 
-#ifdef __KERNEL__
-
 #include <linux/threads.h>
 #include <asm/switch_to.h>
 
@@ -223,24 +65,10 @@ extern unsigned long profile_pc(struct pt_regs *);
 #else
 #define profile_pc(regs) instruction_pointer(regs)
 #endif
-#endif /* (__KERNEL__) */
-
 #else /* __ASSEMBLY__ */
-/* For assembly code. */
-#define TRACEREG_SZ             0xa0
-#define STACKFRAME_SZ           0xc0
-
-#define TRACEREG32_SZ           0x50
-#define STACKFRAME32_SZ         0x60
 #endif /* __ASSEMBLY__ */
-
 #else /* (defined(__sparc__) && defined(__arch64__)) */
-
-/* 32 bit sparc */
-
 #ifndef __ASSEMBLY__
-
-#ifdef __KERNEL__
 #include <asm/switch_to.h>
 
 static inline bool pt_regs_is_syscall(struct pt_regs *regs)
@@ -265,158 +93,10 @@ static inline bool pt_regs_clear_syscall(struct pt_regs *regs)
 #define instruction_pointer(regs) ((regs)->pc)
 #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP])
 unsigned long profile_pc(struct pt_regs *);
-#endif /* (__KERNEL__) */
-
 #else /* (!__ASSEMBLY__) */
-/* For assembly code. */
-#define TRACEREG_SZ       0x50
-#define STACKFRAME_SZ     0x60
 #endif /* (!__ASSEMBLY__) */
-
 #endif /* (defined(__sparc__) && defined(__arch64__)) */
-
-#ifdef __KERNEL__
 #define STACK_BIAS              2047
-#endif
-
-/* These are for pt_regs. */
-#define PT_V9_G0     0x00
-#define PT_V9_G1     0x08
-#define PT_V9_G2     0x10
-#define PT_V9_G3     0x18
-#define PT_V9_G4     0x20
-#define PT_V9_G5     0x28
-#define PT_V9_G6     0x30
-#define PT_V9_G7     0x38
-#define PT_V9_I0     0x40
-#define PT_V9_I1     0x48
-#define PT_V9_I2     0x50
-#define PT_V9_I3     0x58
-#define PT_V9_I4     0x60
-#define PT_V9_I5     0x68
-#define PT_V9_I6     0x70
-#define PT_V9_FP     PT_V9_I6
-#define PT_V9_I7     0x78
-#define PT_V9_TSTATE 0x80
-#define PT_V9_TPC    0x88
-#define PT_V9_TNPC   0x90
-#define PT_V9_Y      0x98
-#define PT_V9_MAGIC  0x9c
-#define PT_TSTATE       PT_V9_TSTATE
-#define PT_TPC          PT_V9_TPC
-#define PT_TNPC         PT_V9_TNPC
-
-/* These for pt_regs32. */
-#define PT_PSR    0x0
-#define PT_PC     0x4
-#define PT_NPC    0x8
-#define PT_Y      0xc
-#define PT_G0     0x10
-#define PT_WIM    PT_G0
-#define PT_G1     0x14
-#define PT_G2     0x18
-#define PT_G3     0x1c
-#define PT_G4     0x20
-#define PT_G5     0x24
-#define PT_G6     0x28
-#define PT_G7     0x2c
-#define PT_I0     0x30
-#define PT_I1     0x34
-#define PT_I2     0x38
-#define PT_I3     0x3c
-#define PT_I4     0x40
-#define PT_I5     0x44
-#define PT_I6     0x48
-#define PT_FP     PT_I6
-#define PT_I7     0x4c
-
-/* Reg_window offsets */
-#define RW_V9_L0     0x00
-#define RW_V9_L1     0x08
-#define RW_V9_L2     0x10
-#define RW_V9_L3     0x18
-#define RW_V9_L4     0x20
-#define RW_V9_L5     0x28
-#define RW_V9_L6     0x30
-#define RW_V9_L7     0x38
-#define RW_V9_I0     0x40
-#define RW_V9_I1     0x48
-#define RW_V9_I2     0x50
-#define RW_V9_I3     0x58
-#define RW_V9_I4     0x60
-#define RW_V9_I5     0x68
-#define RW_V9_I6     0x70
-#define RW_V9_I7     0x78
-
-#define RW_L0     0x00
-#define RW_L1     0x04
-#define RW_L2     0x08
-#define RW_L3     0x0c
-#define RW_L4     0x10
-#define RW_L5     0x14
-#define RW_L6     0x18
-#define RW_L7     0x1c
-#define RW_I0     0x20
-#define RW_I1     0x24
-#define RW_I2     0x28
-#define RW_I3     0x2c
-#define RW_I4     0x30
-#define RW_I5     0x34
-#define RW_I6     0x38
-#define RW_I7     0x3c
-
-/* Stack_frame offsets */
-#define SF_V9_L0     0x00
-#define SF_V9_L1     0x08
-#define SF_V9_L2     0x10
-#define SF_V9_L3     0x18
-#define SF_V9_L4     0x20
-#define SF_V9_L5     0x28
-#define SF_V9_L6     0x30
-#define SF_V9_L7     0x38
-#define SF_V9_I0     0x40
-#define SF_V9_I1     0x48
-#define SF_V9_I2     0x50
-#define SF_V9_I3     0x58
-#define SF_V9_I4     0x60
-#define SF_V9_I5     0x68
-#define SF_V9_FP     0x70
-#define SF_V9_PC     0x78
-#define SF_V9_RETP   0x80
-#define SF_V9_XARG0  0x88
-#define SF_V9_XARG1  0x90
-#define SF_V9_XARG2  0x98
-#define SF_V9_XARG3  0xa0
-#define SF_V9_XARG4  0xa8
-#define SF_V9_XARG5  0xb0
-#define SF_V9_XXARG  0xb8
-
-#define SF_L0     0x00
-#define SF_L1     0x04
-#define SF_L2     0x08
-#define SF_L3     0x0c
-#define SF_L4     0x10
-#define SF_L5     0x14
-#define SF_L6     0x18
-#define SF_L7     0x1c
-#define SF_I0     0x20
-#define SF_I1     0x24
-#define SF_I2     0x28
-#define SF_I3     0x2c
-#define SF_I4     0x30
-#define SF_I5     0x34
-#define SF_FP     0x38
-#define SF_PC     0x3c
-#define SF_RETP   0x40
-#define SF_XARG0  0x44
-#define SF_XARG1  0x48
-#define SF_XARG2  0x4c
-#define SF_XARG3  0x50
-#define SF_XARG4  0x54
-#define SF_XARG5  0x58
-#define SF_XXARG  0x5c
-
-#ifdef __KERNEL__
 
 /* global_reg_snapshot offsets */
 #define GR_SNAP_TSTATE  0x00
@@ -428,29 +108,4 @@ unsigned long profile_pc(struct pt_regs *);
 #define GR_SNAP_THREAD  0x30
 #define GR_SNAP_PAD1    0x38
 
-#endif  /*  __KERNEL__  */
-
-/* Stuff for the ptrace system call */
-#define PTRACE_SPARC_DETACH       11
-#define PTRACE_GETREGS            12
-#define PTRACE_SETREGS            13
-#define PTRACE_GETFPREGS          14
-#define PTRACE_SETFPREGS          15
-#define PTRACE_READDATA           16
-#define PTRACE_WRITEDATA          17
-#define PTRACE_READTEXT           18
-#define PTRACE_WRITETEXT          19
-#define PTRACE_GETFPAREGS         20
-#define PTRACE_SETFPAREGS         21
-
-/* There are for debugging 64-bit processes, either from a 32 or 64 bit
- * parent.  Thus their complements are for debugging 32-bit processes only.
- */
-
-#define PTRACE_GETREGS64          22
-#define PTRACE_SETREGS64          23
-/* PTRACE_SYSCALL is 24 */
-#define PTRACE_GETFPREGS64        25
-#define PTRACE_SETFPREGS64        26
-
 #endif /* !(__SPARC_PTRACE_H) */
diff --git a/arch/sparc/include/asm/setup.h b/arch/sparc/include/asm/setup.h
index 8a83699a5507..5e35e0517318 100644
--- a/arch/sparc/include/asm/setup.h
+++ b/arch/sparc/include/asm/setup.h
@@ -1,17 +1,11 @@
 /*
  *      Just a place holder. 
  */
-
 #ifndef _SPARC_SETUP_H
 #define _SPARC_SETUP_H
 
-#if defined(__sparc__) && defined(__arch64__)
-# define COMMAND_LINE_SIZE 2048
-#else
-# define COMMAND_LINE_SIZE 256
-#endif
+#include <uapi/asm/setup.h>
 
-#ifdef __KERNEL__
 
 extern char reboot_command[];
 
@@ -34,6 +28,4 @@ extern void sun_do_break(void);
 extern int stop_a_enabled;
 extern int scons_pwroff;
 
-#endif /* __KERNEL__ */
-
 #endif /* _SPARC_SETUP_H */
diff --git a/arch/sparc/include/asm/sigcontext.h b/arch/sparc/include/asm/sigcontext.h
index 69914d748130..fc2df1e892cb 100644
--- a/arch/sparc/include/asm/sigcontext.h
+++ b/arch/sparc/include/asm/sigcontext.h
@@ -1,8 +1,8 @@
 #ifndef __SPARC_SIGCONTEXT_H
 #define __SPARC_SIGCONTEXT_H
 
-#ifdef __KERNEL__
 #include <asm/ptrace.h>
+#include <uapi/asm/sigcontext.h>
 
 #ifndef __ASSEMBLY__
 
@@ -105,6 +105,4 @@ typedef struct {
 
 #endif /* !(__ASSEMBLY__) */
 
-#endif /* (__KERNEL__) */
-
 #endif /* !(__SPARC_SIGCONTEXT_H) */
diff --git a/arch/sparc/include/asm/siginfo.h b/arch/sparc/include/asm/siginfo.h
index dbc182c438b4..48c34c19f810 100644
--- a/arch/sparc/include/asm/siginfo.h
+++ b/arch/sparc/include/asm/siginfo.h
@@ -1,19 +1,8 @@
 #ifndef __SPARC_SIGINFO_H
 #define __SPARC_SIGINFO_H
 
-#if defined(__sparc__) && defined(__arch64__)
+#include <uapi/asm/siginfo.h>
 
-#define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int))
-#define __ARCH_SI_BAND_T int
-
-#endif /* defined(__sparc__) && defined(__arch64__) */
-
-
-#define __ARCH_SI_TRAPNO
-
-#include <asm-generic/siginfo.h>
-
-#ifdef __KERNEL__
 
 #ifdef CONFIG_COMPAT
 
@@ -21,14 +10,4 @@ struct compat_siginfo;
 
 #endif /* CONFIG_COMPAT */
 
-#endif /* __KERNEL__ */
-
-#define SI_NOINFO       32767           /* no information in siginfo_t */
-
-/*
- * SIGEMT si_codes
- */
-#define EMT_TAGOVF      (__SI_FAULT|1)  /* tag overflow */
-#define NSIGEMT         1
-
 #endif /* !(__SPARC_SIGINFO_H) */
diff --git a/arch/sparc/include/asm/signal.h b/arch/sparc/include/asm/signal.h
index aa42fe30d5b9..d243c2ae02d2 100644
--- a/arch/sparc/include/asm/signal.h
+++ b/arch/sparc/include/asm/signal.h
@@ -1,168 +1,13 @@
 #ifndef __SPARC_SIGNAL_H
 #define __SPARC_SIGNAL_H
 
-#include <asm/sigcontext.h>
-#include <linux/compiler.h>
-
-#ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 #include <linux/personality.h>
 #include <linux/types.h>
 #endif
-#endif
-
-/* On the Sparc the signal handlers get passed a 'sub-signal' code
- * for certain signal types, which we document here.
- */
-#define SIGHUP           1
-#define SIGINT           2
-#define SIGQUIT          3
-#define SIGILL           4
-#define    SUBSIG_STACK       0
-#define    SUBSIG_ILLINST     2
-#define    SUBSIG_PRIVINST    3
-#define    SUBSIG_BADTRAP(t)  (0x80 + (t))
-
-#define SIGTRAP          5
-#define SIGABRT          6
-#define SIGIOT           6
-
-#define SIGEMT           7
-#define    SUBSIG_TAG    10
-
-#define SIGFPE           8
-#define    SUBSIG_FPDISABLED     0x400
-#define    SUBSIG_FPERROR        0x404
-#define    SUBSIG_FPINTOVFL      0x001
-#define    SUBSIG_FPSTSIG        0x002
-#define    SUBSIG_IDIVZERO       0x014
-#define    SUBSIG_FPINEXACT      0x0c4
-#define    SUBSIG_FPDIVZERO      0x0c8
-#define    SUBSIG_FPUNFLOW       0x0cc
-#define    SUBSIG_FPOPERROR      0x0d0
-#define    SUBSIG_FPOVFLOW       0x0d4
-
-#define SIGKILL          9
-#define SIGBUS          10
-#define    SUBSIG_BUSTIMEOUT    1
-#define    SUBSIG_ALIGNMENT     2
-#define    SUBSIG_MISCERROR     5
-
-#define SIGSEGV         11
-#define    SUBSIG_NOMAPPING     3
-#define    SUBSIG_PROTECTION    4
-#define    SUBSIG_SEGERROR      5
-
-#define SIGSYS          12
-
-#define SIGPIPE         13
-#define SIGALRM         14
-#define SIGTERM         15
-#define SIGURG          16
-
-/* SunOS values which deviate from the Linux/i386 ones */
-#define SIGSTOP         17
-#define SIGTSTP         18
-#define SIGCONT         19
-#define SIGCHLD         20
-#define SIGTTIN         21
-#define SIGTTOU         22
-#define SIGIO           23
-#define SIGPOLL         SIGIO   /* SysV name for SIGIO */
-#define SIGXCPU         24
-#define SIGXFSZ         25
-#define SIGVTALRM       26
-#define SIGPROF         27
-#define SIGWINCH        28
-#define SIGLOST         29
-#define SIGPWR          SIGLOST
-#define SIGUSR1         30
-#define SIGUSR2         31
-
-/* Most things should be clean enough to redefine this at will, if care
-   is taken to make libc match.  */
-
-#define __OLD_NSIG      32
-#define __NEW_NSIG      64
-#ifdef __arch64__
-#define _NSIG_BPW       64
-#else
-#define _NSIG_BPW       32
-#endif
-#define _NSIG_WORDS     (__NEW_NSIG / _NSIG_BPW)
-
-#define SIGRTMIN       32
-#define SIGRTMAX       __NEW_NSIG
-
-#if defined(__KERNEL__) || defined(__WANT_POSIX1B_SIGNALS__)
-#define _NSIG                   __NEW_NSIG
-#define __new_sigset_t          sigset_t
-#define __new_sigaction         sigaction
-#define __new_sigaction32       sigaction32
-#define __old_sigset_t          old_sigset_t
-#define __old_sigaction         old_sigaction
-#define __old_sigaction32       old_sigaction32
-#else
-#define _NSIG                   __OLD_NSIG
-#define NSIG                    _NSIG
-#define __old_sigset_t          sigset_t
-#define __old_sigaction         sigaction
-#define __old_sigaction32       sigaction32
-#endif
+#include <uapi/asm/signal.h>
 
 #ifndef __ASSEMBLY__
-
-typedef unsigned long __old_sigset_t;            /* at least 32 bits */
-
-typedef struct {
-       unsigned long sig[_NSIG_WORDS];
-} __new_sigset_t;
-
-/* A SunOS sigstack */
-struct sigstack {
-        /* XXX 32-bit pointers pinhead XXX */
-        char *the_stack;
-        int   cur_status;
-};
-
-/* Sigvec flags */
-#define _SV_SSTACK    1u    /* This signal handler should use sig-stack */
-#define _SV_INTR      2u    /* Sig return should not restart system call */
-#define _SV_RESET     4u    /* Set handler to SIG_DFL upon taken signal */
-#define _SV_IGNCHILD  8u    /* Do not send SIGCHLD */
-
-/*
- * sa_flags values: SA_STACK is not currently supported, but will allow the
- * usage of signal stacks by using the (now obsolete) sa_restorer field in
- * the sigaction structure as a stack pointer. This is now possible due to
- * the changes in signal handling. LBT 010493.
- * SA_RESTART flag to get restarting signals (which were the default long ago)
- */
-#define SA_NOCLDSTOP    _SV_IGNCHILD
-#define SA_STACK        _SV_SSTACK
-#define SA_ONSTACK      _SV_SSTACK
-#define SA_RESTART      _SV_INTR
-#define SA_ONESHOT      _SV_RESET
-#define SA_NODEFER      0x20u
-#define SA_NOCLDWAIT    0x100u
-#define SA_SIGINFO      0x200u
-
-#define SA_NOMASK       SA_NODEFER
-
-#define SIG_BLOCK          0x01 /* for blocking signals */
-#define SIG_UNBLOCK        0x02 /* for unblocking signals */
-#define SIG_SETMASK        0x04 /* for setting the signal mask */
-
-/*
- * sigaltstack controls
- */
-#define SS_ONSTACK      1
-#define SS_DISABLE      2
-
-#define MINSIGSTKSZ     4096
-#define SIGSTKSZ        16384
-
-#ifdef __KERNEL__
 /*
  * DJHR
  * SA_STATIC_ALLOC is used for the sparc32 system to indicate that this
@@ -175,31 +20,6 @@ struct sigstack {
  *
  */
 #define SA_STATIC_ALLOC         0x8000
-#endif
-
-#include <asm-generic/signal-defs.h>
-
-struct __new_sigaction {
-        __sighandler_t          sa_handler;
-        unsigned long           sa_flags;
-        __sigrestore_t          sa_restorer;  /* not used by Linux/SPARC yet */
-        __new_sigset_t          sa_mask;
-};
-
-struct __old_sigaction {
-        __sighandler_t          sa_handler;
-        __old_sigset_t          sa_mask;
-        unsigned long           sa_flags;
-        void                    (*sa_restorer)(void);  /* not used by Linux/SPARC yet */
-};
-
-typedef struct sigaltstack {
-        void                    __user *ss_sp;
-        int                     ss_flags;
-        size_t                  ss_size;
-} stack_t;
-
-#ifdef __KERNEL__
 
 struct k_sigaction {
         struct                  __new_sigaction sa;
@@ -208,8 +28,5 @@ struct k_sigaction {
 
 #define ptrace_signal_deliver(regs, cookie) do { } while (0)
 
-#endif /* !(__KERNEL__) */
-
 #endif /* !(__ASSEMBLY__) */
-
 #endif /* !(__SPARC_SIGNAL_H) */
diff --git a/arch/sparc/include/asm/termbits.h b/arch/sparc/include/asm/termbits.h
index 23b10ff08df2..948067065ac5 100644
--- a/arch/sparc/include/asm/termbits.h
+++ b/arch/sparc/include/asm/termbits.h
@@ -1,266 +1,8 @@
 #ifndef _SPARC_TERMBITS_H
 #define _SPARC_TERMBITS_H
 
-#include <linux/posix_types.h>
+#include <uapi/asm/termbits.h>
 
-typedef unsigned char   cc_t;
-typedef unsigned int    speed_t;
-
-#if defined(__sparc__) && defined(__arch64__)
-typedef unsigned int    tcflag_t;
-#else
-typedef unsigned long   tcflag_t;
-#endif
-
-#define NCC 8
-struct termio {
-        unsigned short c_iflag;         /* input mode flags */
-        unsigned short c_oflag;         /* output mode flags */
-        unsigned short c_cflag;         /* control mode flags */
-        unsigned short c_lflag;         /* local mode flags */
-        unsigned char c_line;           /* line discipline */
-        unsigned char c_cc[NCC];        /* control characters */
-};
-
-#define NCCS 17
-struct termios {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-#ifndef __KERNEL__
-        cc_t c_cc[NCCS];                /* control characters */
-#else
-        cc_t c_cc[NCCS+2];      /* kernel needs 2 more to hold vmin/vtime */
-#define SIZEOF_USER_TERMIOS sizeof (struct termios) - (2*sizeof (cc_t))
-#endif
-};
-
-struct termios2 {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-        cc_t c_cc[NCCS+2];              /* control characters */
-        speed_t c_ispeed;               /* input speed */
-        speed_t c_ospeed;               /* output speed */
-};
-
-struct ktermios {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-        cc_t c_cc[NCCS+2];              /* control characters */
-        speed_t c_ispeed;               /* input speed */
-        speed_t c_ospeed;               /* output speed */
-};
-
-/* c_cc characters */
-#define VINTR    0
-#define VQUIT    1
-#define VERASE   2
-#define VKILL    3
-#define VEOF     4
-#define VEOL     5
-#define VEOL2    6
-#define VSWTC    7
-#define VSTART   8
-#define VSTOP    9
-
-
-
-#define VSUSP    10
-#define VDSUSP   11  /* SunOS POSIX nicety I do believe... */
-#define VREPRINT 12
-#define VDISCARD 13
-#define VWERASE  14
-#define VLNEXT   15
-
-/* Kernel keeps vmin/vtime separated, user apps assume vmin/vtime is
- * shared with eof/eol
- */
-#ifdef __KERNEL__
 #define VMIN     16
 #define VTIME    17
-#else
-#define VMIN     VEOF
-#define VTIME    VEOL
-#endif
-
-/* c_iflag bits */
-#define IGNBRK  0x00000001
-#define BRKINT  0x00000002
-#define IGNPAR  0x00000004
-#define PARMRK  0x00000008
-#define INPCK   0x00000010
-#define ISTRIP  0x00000020
-#define INLCR   0x00000040
-#define IGNCR   0x00000080
-#define ICRNL   0x00000100
-#define IUCLC   0x00000200
-#define IXON    0x00000400
-#define IXANY   0x00000800
-#define IXOFF   0x00001000
-#define IMAXBEL 0x00002000
-#define IUTF8   0x00004000
-
-/* c_oflag bits */
-#define OPOST   0x00000001
-#define OLCUC   0x00000002
-#define ONLCR   0x00000004
-#define OCRNL   0x00000008
-#define ONOCR   0x00000010
-#define ONLRET  0x00000020
-#define OFILL   0x00000040
-#define OFDEL   0x00000080
-#define NLDLY   0x00000100
-#define   NL0   0x00000000
-#define   NL1   0x00000100
-#define CRDLY   0x00000600
-#define   CR0   0x00000000
-#define   CR1   0x00000200
-#define   CR2   0x00000400
-#define   CR3   0x00000600
-#define TABDLY  0x00001800
-#define   TAB0  0x00000000
-#define   TAB1  0x00000800
-#define   TAB2  0x00001000
-#define   TAB3  0x00001800
-#define   XTABS 0x00001800
-#define BSDLY   0x00002000
-#define   BS0   0x00000000
-#define   BS1   0x00002000
-#define VTDLY   0x00004000
-#define   VT0   0x00000000
-#define   VT1   0x00004000
-#define FFDLY   0x00008000
-#define   FF0   0x00000000
-#define   FF1   0x00008000
-#define PAGEOUT 0x00010000  /* SUNOS specific */
-#define WRAP    0x00020000  /* SUNOS specific */
-
-/* c_cflag bit meaning */
-#define CBAUD     0x0000100f
-#define  B0       0x00000000   /* hang up */
-#define  B50      0x00000001
-#define  B75      0x00000002
-#define  B110     0x00000003
-#define  B134     0x00000004
-#define  B150     0x00000005
-#define  B200     0x00000006
-#define  B300     0x00000007
-#define  B600     0x00000008
-#define  B1200    0x00000009
-#define  B1800    0x0000000a
-#define  B2400    0x0000000b
-#define  B4800    0x0000000c
-#define  B9600    0x0000000d
-#define  B19200   0x0000000e
-#define  B38400   0x0000000f
-#define EXTA      B19200
-#define EXTB      B38400
-#define  CSIZE    0x00000030
-#define   CS5     0x00000000
-#define   CS6     0x00000010
-#define   CS7     0x00000020
-#define   CS8     0x00000030
-#define CSTOPB    0x00000040
-#define CREAD     0x00000080
-#define PARENB    0x00000100
-#define PARODD    0x00000200
-#define HUPCL     0x00000400
-#define CLOCAL    0x00000800
-#define CBAUDEX   0x00001000
-/* We'll never see these speeds with the Zilogs, but for completeness... */
-#define  BOTHER   0x00001000
-#define  B57600   0x00001001
-#define  B115200  0x00001002
-#define  B230400  0x00001003
-#define  B460800  0x00001004
-/* This is what we can do with the Zilogs. */
-#define  B76800   0x00001005
-/* This is what we can do with the SAB82532. */
-#define  B153600  0x00001006
-#define  B307200  0x00001007
-#define  B614400  0x00001008
-#define  B921600  0x00001009
-/* And these are the rest... */
-#define  B500000  0x0000100a
-#define  B576000  0x0000100b
-#define B1000000  0x0000100c
-#define B1152000  0x0000100d
-#define B1500000  0x0000100e
-#define B2000000  0x0000100f
-/* These have totally bogus values and nobody uses them
-   so far. Later on we'd have to use say 0x10000x and
-   adjust CBAUD constant and drivers accordingly.
-#define B2500000  0x00001010
-#define B3000000  0x00001011
-#define B3500000  0x00001012
-#define B4000000  0x00001013  */
-#define CIBAUD    0x100f0000  /* input baud rate (not used) */
-#define CMSPAR    0x40000000  /* mark or space (stick) parity */
-#define CRTSCTS   0x80000000  /* flow control */
-
-#define IBSHIFT   16            /* Shift from CBAUD to CIBAUD */
-
-/* c_lflag bits */
-#define ISIG    0x00000001
-#define ICANON  0x00000002
-#define XCASE   0x00000004
-#define ECHO    0x00000008
-#define ECHOE   0x00000010
-#define ECHOK   0x00000020
-#define ECHONL  0x00000040
-#define NOFLSH  0x00000080
-#define TOSTOP  0x00000100
-#define ECHOCTL 0x00000200
-#define ECHOPRT 0x00000400
-#define ECHOKE  0x00000800
-#define DEFECHO 0x00001000  /* SUNOS thing, what is it? */
-#define FLUSHO  0x00002000
-#define PENDIN  0x00004000
-#define IEXTEN  0x00008000
-#define EXTPROC 0x00010000
-
-/* modem lines */
-#define TIOCM_LE        0x001
-#define TIOCM_DTR       0x002
-#define TIOCM_RTS       0x004
-#define TIOCM_ST        0x008
-#define TIOCM_SR        0x010
-#define TIOCM_CTS       0x020
-#define TIOCM_CAR       0x040
-#define TIOCM_RNG       0x080
-#define TIOCM_DSR       0x100
-#define TIOCM_CD        TIOCM_CAR
-#define TIOCM_RI        TIOCM_RNG
-#define TIOCM_OUT1      0x2000
-#define TIOCM_OUT2      0x4000
-#define TIOCM_LOOP      0x8000
-
-/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
-#define TIOCSER_TEMT    0x01    /* Transmitter physically empty */
-
-
-/* tcflow() and TCXONC use these */
-#define TCOOFF          0
-#define TCOON           1
-#define TCIOFF          2
-#define TCION           3
-
-/* tcflush() and TCFLSH use these */
-#define TCIFLUSH        0
-#define TCOFLUSH        1
-#define TCIOFLUSH       2
-
-/* tcsetattr uses these */
-#define TCSANOW         0
-#define TCSADRAIN       1
-#define TCSAFLUSH       2
-
 #endif /* !(_SPARC_TERMBITS_H) */
diff --git a/arch/sparc/include/asm/termios.h b/arch/sparc/include/asm/termios.h
index e2f46705a210..0c2414ddd52c 100644
--- a/arch/sparc/include/asm/termios.h
+++ b/arch/sparc/include/asm/termios.h
@@ -1,45 +1,8 @@
 #ifndef _SPARC_TERMIOS_H
 #define _SPARC_TERMIOS_H
 
-#include <asm/ioctls.h>
-#include <asm/termbits.h>
+#include <uapi/asm/termios.h>
 
-#if defined(__KERNEL__) || defined(__DEFINE_BSD_TERMIOS)
-struct sgttyb {
-        char    sg_ispeed;
-        char    sg_ospeed;
-        char    sg_erase;
-        char    sg_kill;
-        short   sg_flags;
-};
-
-struct tchars {
-        char    t_intrc;
-        char    t_quitc;
-        char    t_startc;
-        char    t_stopc;
-        char    t_eofc;
-        char    t_brkc;
-};
-
-struct ltchars {
-        char    t_suspc;
-        char    t_dsuspc;
-        char    t_rprntc;
-        char    t_flushc;
-        char    t_werasc;
-        char    t_lnextc;
-};
-#endif /* __KERNEL__ */
-
-struct winsize {
-        unsigned short ws_row;
-        unsigned short ws_col;
-        unsigned short ws_xpixel;
-        unsigned short ws_ypixel;
-};
-
-#ifdef __KERNEL__
 
 /*
  * c_cc characters in the termio structure.  Oh, how I love being
@@ -180,6 +143,4 @@ struct winsize {
         err; \
 })
 
-#endif  /* __KERNEL__ */
-
 #endif /* _SPARC_TERMIOS_H */
diff --git a/arch/sparc/include/asm/traps.h b/arch/sparc/include/asm/traps.h
index 3aa62dde343f..51abcb1f9b3b 100644
--- a/arch/sparc/include/asm/traps.h
+++ b/arch/sparc/include/asm/traps.h
@@ -3,14 +3,12 @@
  *
  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  */
-
 #ifndef _SPARC_TRAPS_H
 #define _SPARC_TRAPS_H
 
-#define NUM_SPARC_TRAPS  255
+#include <uapi/asm/traps.h>
 
 #ifndef __ASSEMBLY__
-#ifdef __KERNEL__
 /* This is for V8 compliant Sparc CPUS */
 struct tt_entry {
         unsigned long inst_one;
@@ -22,112 +20,5 @@ struct tt_entry {
 /* We set this to _start in system setup. */
 extern struct tt_entry *sparc_ttable;
 
-#endif /* (__KERNEL__) */
 #endif /* !(__ASSEMBLY__) */
-
-/* For patching the trap table at boot time, we need to know how to
- * form various common Sparc instructions.  Thus these macros...
- */
-
-#define SPARC_MOV_CONST_L3(const) (0xa6102000 | (const&0xfff))
-
-/* The following assumes that the branch lies before the place we
- * are branching to.  This is the case for a trap vector...
- * You have been warned.
- */
-#define SPARC_BRANCH(dest_addr, inst_addr) \
-          (0x10800000 | (((dest_addr-inst_addr)>>2)&0x3fffff))
-
-#define SPARC_RD_PSR_L0  (0xa1480000)
-#define SPARC_RD_WIM_L3  (0xa7500000)
-#define SPARC_NOP (0x01000000)
-
-/* Various interesting trap levels. */
-/* First, hardware traps. */
-#define SP_TRAP_TFLT    0x1          /* Text fault */
-#define SP_TRAP_II      0x2          /* Illegal Instruction */
-#define SP_TRAP_PI      0x3          /* Privileged Instruction */
-#define SP_TRAP_FPD     0x4          /* Floating Point Disabled */
-#define SP_TRAP_WOVF    0x5          /* Window Overflow */
-#define SP_TRAP_WUNF    0x6          /* Window Underflow */
-#define SP_TRAP_MNA     0x7          /* Memory Address Unaligned */
-#define SP_TRAP_FPE     0x8          /* Floating Point Exception */
-#define SP_TRAP_DFLT    0x9          /* Data Fault */
-#define SP_TRAP_TOF     0xa          /* Tag Overflow */
-#define SP_TRAP_WDOG    0xb          /* Watchpoint Detected */
-#define SP_TRAP_IRQ1    0x11         /* IRQ level 1 */
-#define SP_TRAP_IRQ2    0x12         /* IRQ level 2 */
-#define SP_TRAP_IRQ3    0x13         /* IRQ level 3 */
-#define SP_TRAP_IRQ4    0x14         /* IRQ level 4 */
-#define SP_TRAP_IRQ5    0x15         /* IRQ level 5 */
-#define SP_TRAP_IRQ6    0x16         /* IRQ level 6 */
-#define SP_TRAP_IRQ7    0x17         /* IRQ level 7 */
-#define SP_TRAP_IRQ8    0x18         /* IRQ level 8 */
-#define SP_TRAP_IRQ9    0x19         /* IRQ level 9 */
-#define SP_TRAP_IRQ10   0x1a         /* IRQ level 10 */
-#define SP_TRAP_IRQ11   0x1b         /* IRQ level 11 */
-#define SP_TRAP_IRQ12   0x1c         /* IRQ level 12 */
-#define SP_TRAP_IRQ13   0x1d         /* IRQ level 13 */
-#define SP_TRAP_IRQ14   0x1e         /* IRQ level 14 */
-#define SP_TRAP_IRQ15   0x1f         /* IRQ level 15 Non-maskable */
-#define SP_TRAP_RACC    0x20         /* Register Access Error ??? */
-#define SP_TRAP_IACC    0x21         /* Instruction Access Error */
-#define SP_TRAP_CPDIS   0x24         /* Co-Processor Disabled */
-#define SP_TRAP_BADFL   0x25         /* Unimplemented Flush Instruction */
-#define SP_TRAP_CPEXP   0x28         /* Co-Processor Exception */
-#define SP_TRAP_DACC    0x29         /* Data Access Error */
-#define SP_TRAP_DIVZ    0x2a         /* Divide By Zero */
-#define SP_TRAP_DSTORE  0x2b         /* Data Store Error ??? */
-#define SP_TRAP_DMM     0x2c         /* Data Access MMU Miss ??? */
-#define SP_TRAP_IMM     0x3c         /* Instruction Access MMU Miss ??? */
-
-/* Now the Software Traps... */
-#define SP_TRAP_SUNOS   0x80         /* SunOS System Call */
-#define SP_TRAP_SBPT    0x81         /* Software Breakpoint */
-#define SP_TRAP_SDIVZ   0x82         /* Software Divide-by-Zero trap */
-#define SP_TRAP_FWIN    0x83         /* Flush Windows */
-#define SP_TRAP_CWIN    0x84         /* Clean Windows */
-#define SP_TRAP_RCHK    0x85         /* Range Check */
-#define SP_TRAP_FUNA    0x86         /* Fix Unaligned Access */
-#define SP_TRAP_IOWFL   0x87         /* Integer Overflow */
-#define SP_TRAP_SOLARIS 0x88         /* Solaris System Call */
-#define SP_TRAP_NETBSD  0x89         /* NetBSD System Call */
-#define SP_TRAP_LINUX   0x90         /* Linux System Call */
-
-/* Names used for compatibility with SunOS */
-#define ST_SYSCALL              0x00
-#define ST_BREAKPOINT           0x01
-#define ST_DIV0                 0x02
-#define ST_FLUSH_WINDOWS        0x03
-#define ST_CLEAN_WINDOWS        0x04
-#define ST_RANGE_CHECK          0x05
-#define ST_FIX_ALIGN            0x06
-#define ST_INT_OVERFLOW         0x07
-
-/* Special traps... */
-#define SP_TRAP_KBPT1   0xfe         /* KADB/PROM Breakpoint one */
-#define SP_TRAP_KBPT2   0xff         /* KADB/PROM Breakpoint two */
-
-/* Handy Macros */
-/* Is this a trap we never expect to get? */
-#define BAD_TRAP_P(level) \
-        ((level > SP_TRAP_WDOG && level < SP_TRAP_IRQ1) || \
-         (level > SP_TRAP_IACC && level < SP_TRAP_CPDIS) || \
-         (level > SP_TRAP_BADFL && level < SP_TRAP_CPEXP) || \
-         (level > SP_TRAP_DMM && level < SP_TRAP_IMM) || \
-         (level > SP_TRAP_IMM && level < SP_TRAP_SUNOS) || \
-         (level > SP_TRAP_LINUX && level < SP_TRAP_KBPT1))
-
-/* Is this a Hardware trap? */
-#define HW_TRAP_P(level) ((level > 0) && (level < SP_TRAP_SUNOS))
-
-/* Is this a Software trap? */
-#define SW_TRAP_P(level) ((level >= SP_TRAP_SUNOS) && (level <= SP_TRAP_KBPT2))
-
-/* Is this a system call for some OS we know about? */
-#define SCALL_TRAP_P(level) ((level == SP_TRAP_SUNOS) || \
-                             (level == SP_TRAP_SOLARIS) || \
-                             (level == SP_TRAP_NETBSD) || \
-                             (level == SP_TRAP_LINUX))
-
 #endif /* !(_SPARC_TRAPS_H) */
diff --git a/arch/sparc/include/asm/unistd.h b/arch/sparc/include/asm/unistd.h
index d9a677c51926..0ecea6ed943e 100644
--- a/arch/sparc/include/asm/unistd.h
+++ b/arch/sparc/include/asm/unistd.h
@@ -1,6 +1,3 @@
-#ifndef _SPARC_UNISTD_H
-#define _SPARC_UNISTD_H
-
 /*
  * System calls under the Sparc.
  *
@@ -14,415 +11,15 @@
  *
  * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)
  */
-#ifndef __32bit_syscall_numbers__
-#ifndef __arch64__
-#define __32bit_syscall_numbers__
-#endif
-#endif
+#ifndef _SPARC_UNISTD_H
+#define _SPARC_UNISTD_H
+
+#include <uapi/asm/unistd.h>
 
-#define __NR_restart_syscall      0 /* Linux Specific                              */
-#define __NR_exit                 1 /* Common                                      */
-#define __NR_fork                 2 /* Common                                      */
-#define __NR_read                 3 /* Common                                      */
-#define __NR_write                4 /* Common                                      */
-#define __NR_open                 5 /* Common                                      */
-#define __NR_close                6 /* Common                                      */
-#define __NR_wait4                7 /* Common                                      */
-#define __NR_creat                8 /* Common                                      */
-#define __NR_link                 9 /* Common                                      */
-#define __NR_unlink              10 /* Common                                      */
-#define __NR_execv               11 /* SunOS Specific                              */
-#define __NR_chdir               12 /* Common                                      */
-#define __NR_chown               13 /* Common                                      */
-#define __NR_mknod               14 /* Common                                      */
-#define __NR_chmod               15 /* Common                                      */
-#define __NR_lchown              16 /* Common                                      */
-#define __NR_brk                 17 /* Common                                      */
-#define __NR_perfctr             18 /* Performance counter operations              */
-#define __NR_lseek               19 /* Common                                      */
-#define __NR_getpid              20 /* Common                                      */
-#define __NR_capget              21 /* Linux Specific                              */
-#define __NR_capset              22 /* Linux Specific                              */
-#define __NR_setuid              23 /* Implemented via setreuid in SunOS           */
-#define __NR_getuid              24 /* Common                                      */
-#define __NR_vmsplice            25 /* ENOSYS under SunOS                          */
-#define __NR_ptrace              26 /* Common                                      */
-#define __NR_alarm               27 /* Implemented via setitimer in SunOS          */
-#define __NR_sigaltstack         28 /* Common                                      */
-#define __NR_pause               29 /* Is sigblock(0)->sigpause() in SunOS         */
-#define __NR_utime               30 /* Implemented via utimes() under SunOS        */
-#ifdef __32bit_syscall_numbers__
-#define __NR_lchown32            31 /* Linux sparc32 specific                      */
-#define __NR_fchown32            32 /* Linux sparc32 specific                      */
-#endif
-#define __NR_access              33 /* Common                                      */
-#define __NR_nice                34 /* Implemented via get/setpriority() in SunOS  */
-#ifdef __32bit_syscall_numbers__
-#define __NR_chown32             35 /* Linux sparc32 specific                      */
-#endif
-#define __NR_sync                36 /* Common                                      */
-#define __NR_kill                37 /* Common                                      */
-#define __NR_stat                38 /* Common                                      */
-#define __NR_sendfile            39 /* Linux Specific                              */
-#define __NR_lstat               40 /* Common                                      */
-#define __NR_dup                 41 /* Common                                      */
-#define __NR_pipe                42 /* Common                                      */
-#define __NR_times               43 /* Implemented via getrusage() in SunOS        */
-#ifdef __32bit_syscall_numbers__
-#define __NR_getuid32            44 /* Linux sparc32 specific                      */
-#endif
-#define __NR_umount2             45 /* Linux Specific                              */
-#define __NR_setgid              46 /* Implemented via setregid() in SunOS         */
-#define __NR_getgid              47 /* Common                                      */
-#define __NR_signal              48 /* Implemented via sigvec() in SunOS           */
-#define __NR_geteuid             49 /* SunOS calls getuid()                        */
-#define __NR_getegid             50 /* SunOS calls getgid()                        */
-#define __NR_acct                51 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_getgid32            53 /* Linux sparc32 specific                      */
-#else
-#define __NR_memory_ordering     52 /* Linux Specific                              */
-#endif
-#define __NR_ioctl               54 /* Common                                      */
-#define __NR_reboot              55 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_mmap2               56 /* Linux sparc32 Specific                      */
-#endif
-#define __NR_symlink             57 /* Common                                      */
-#define __NR_readlink            58 /* Common                                      */
-#define __NR_execve              59 /* Common                                      */
-#define __NR_umask               60 /* Common                                      */
-#define __NR_chroot              61 /* Common                                      */
-#define __NR_fstat               62 /* Common                                      */
-#define __NR_fstat64             63 /* Linux Specific                              */
-#define __NR_getpagesize         64 /* Common                                      */
-#define __NR_msync               65 /* Common in newer 1.3.x revs...               */
-#define __NR_vfork               66 /* Common                                      */
-#define __NR_pread64             67 /* Linux Specific                              */
-#define __NR_pwrite64            68 /* Linux Specific                              */
-#ifdef __32bit_syscall_numbers__
-#define __NR_geteuid32           69 /* Linux sparc32, sbrk under SunOS             */
-#define __NR_getegid32           70 /* Linux sparc32, sstk under SunOS             */
-#endif
-#define __NR_mmap                71 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setreuid32          72 /* Linux sparc32, vadvise under SunOS          */
-#endif
-#define __NR_munmap              73 /* Common                                      */
-#define __NR_mprotect            74 /* Common                                      */
-#define __NR_madvise             75 /* Common                                      */
-#define __NR_vhangup             76 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_truncate64          77 /* Linux sparc32 Specific                      */
-#endif
-#define __NR_mincore             78 /* Common                                      */
-#define __NR_getgroups           79 /* Common                                      */
-#define __NR_setgroups           80 /* Common                                      */
-#define __NR_getpgrp             81 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setgroups32         82 /* Linux sparc32, setpgrp under SunOS          */
-#endif
-#define __NR_setitimer           83 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_ftruncate64         84 /* Linux sparc32 Specific                      */
-#endif
-#define __NR_swapon              85 /* Common                                      */
-#define __NR_getitimer           86 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setuid32            87 /* Linux sparc32, gethostname under SunOS      */
-#endif
-#define __NR_sethostname         88 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setgid32            89 /* Linux sparc32, getdtablesize under SunOS    */
-#endif
-#define __NR_dup2                90 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setfsuid32          91 /* Linux sparc32, getdopt under SunOS          */
-#endif
-#define __NR_fcntl               92 /* Common                                      */
-#define __NR_select              93 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setfsgid32          94 /* Linux sparc32, setdopt under SunOS          */
-#endif
-#define __NR_fsync               95 /* Common                                      */
-#define __NR_setpriority         96 /* Common                                      */
-#define __NR_socket              97 /* Common                                      */
-#define __NR_connect             98 /* Common                                      */
-#define __NR_accept              99 /* Common                                      */
-#define __NR_getpriority        100 /* Common                                      */
-#define __NR_rt_sigreturn       101 /* Linux Specific                              */
-#define __NR_rt_sigaction       102 /* Linux Specific                              */
-#define __NR_rt_sigprocmask     103 /* Linux Specific                              */
-#define __NR_rt_sigpending      104 /* Linux Specific                              */
-#define __NR_rt_sigtimedwait    105 /* Linux Specific                              */
-#define __NR_rt_sigqueueinfo    106 /* Linux Specific                              */
-#define __NR_rt_sigsuspend      107 /* Linux Specific                              */
-#ifdef __32bit_syscall_numbers__
-#define __NR_setresuid32        108 /* Linux Specific, sigvec under SunOS          */
-#define __NR_getresuid32        109 /* Linux Specific, sigblock under SunOS        */
-#define __NR_setresgid32        110 /* Linux Specific, sigsetmask under SunOS      */
-#define __NR_getresgid32        111 /* Linux Specific, sigpause under SunOS        */
-#define __NR_setregid32         112 /* Linux sparc32, sigstack under SunOS         */
-#else
-#define __NR_setresuid          108 /* Linux Specific, sigvec under SunOS          */
-#define __NR_getresuid          109 /* Linux Specific, sigblock under SunOS        */
-#define __NR_setresgid          110 /* Linux Specific, sigsetmask under SunOS      */
-#define __NR_getresgid          111 /* Linux Specific, sigpause under SunOS        */
-#endif
-#define __NR_recvmsg            113 /* Common                                      */
-#define __NR_sendmsg            114 /* Common                                      */
-#ifdef __32bit_syscall_numbers__
-#define __NR_getgroups32        115 /* Linux sparc32, vtrace under SunOS           */
-#endif
-#define __NR_gettimeofday       116 /* Common                                      */
-#define __NR_getrusage          117 /* Common                                      */
-#define __NR_getsockopt         118 /* Common                                      */
-#define __NR_getcwd             119 /* Linux Specific                              */
-#define __NR_readv              120 /* Common                                      */
-#define __NR_writev             121 /* Common                                      */
-#define __NR_settimeofday       122 /* Common                                      */
-#define __NR_fchown             123 /* Common                                      */
-#define __NR_fchmod             124 /* Common                                      */
-#define __NR_recvfrom           125 /* Common                                      */
-#define __NR_setreuid           126 /* Common                                      */
-#define __NR_setregid           127 /* Common                                      */
-#define __NR_rename             128 /* Common                                      */
-#define __NR_truncate           129 /* Common                                      */
-#define __NR_ftruncate          130 /* Common                                      */
-#define __NR_flock              131 /* Common                                      */
-#define __NR_lstat64            132 /* Linux Specific                              */
-#define __NR_sendto             133 /* Common                                      */
-#define __NR_shutdown           134 /* Common                                      */
-#define __NR_socketpair         135 /* Common                                      */
-#define __NR_mkdir              136 /* Common                                      */
-#define __NR_rmdir              137 /* Common                                      */
-#define __NR_utimes             138 /* SunOS Specific                              */
-#define __NR_stat64             139 /* Linux Specific                              */
-#define __NR_sendfile64         140 /* adjtime under SunOS                         */
-#define __NR_getpeername        141 /* Common                                      */
-#define __NR_futex              142 /* gethostid under SunOS                       */
-#define __NR_gettid             143 /* ENOSYS under SunOS                          */
-#define __NR_getrlimit          144 /* Common                                      */
-#define __NR_setrlimit          145 /* Common                                      */
-#define __NR_pivot_root         146 /* Linux Specific, killpg under SunOS          */
-#define __NR_prctl              147 /* ENOSYS under SunOS                          */
-#define __NR_pciconfig_read     148 /* ENOSYS under SunOS                          */
-#define __NR_pciconfig_write    149 /* ENOSYS under SunOS                          */
-#define __NR_getsockname        150 /* Common                                      */
-#define __NR_inotify_init       151 /* Linux specific                              */
-#define __NR_inotify_add_watch  152 /* Linux specific                              */
-#define __NR_poll               153 /* Common                                      */
-#define __NR_getdents64         154 /* Linux specific                              */
-#ifdef __32bit_syscall_numbers__
-#define __NR_fcntl64            155 /* Linux sparc32 Specific                      */
-#endif
-#define __NR_inotify_rm_watch   156 /* Linux specific                              */
-#define __NR_statfs             157 /* Common                                      */
-#define __NR_fstatfs            158 /* Common                                      */
-#define __NR_umount             159 /* Common                                      */
-#define __NR_sched_set_affinity 160 /* Linux specific, async_daemon under SunOS    */
-#define __NR_sched_get_affinity 161 /* Linux specific, getfh under SunOS           */
-#define __NR_getdomainname      162 /* SunOS Specific                              */
-#define __NR_setdomainname      163 /* Common                                      */
-#ifndef __32bit_syscall_numbers__
-#define __NR_utrap_install      164 /* SYSV ABI/v9 required                        */
-#endif
-#define __NR_quotactl           165 /* Common                                      */
-#define __NR_set_tid_address    166 /* Linux specific, exportfs under SunOS        */
-#define __NR_mount              167 /* Common                                      */
-#define __NR_ustat              168 /* Common                                      */
-#define __NR_setxattr           169 /* SunOS: semsys                               */
-#define __NR_lsetxattr          170 /* SunOS: msgsys                               */
-#define __NR_fsetxattr          171 /* SunOS: shmsys                               */
-#define __NR_getxattr           172 /* SunOS: auditsys                             */
-#define __NR_lgetxattr          173 /* SunOS: rfssys                               */
-#define __NR_getdents           174 /* Common                                      */
-#define __NR_setsid             175 /* Common                                      */
-#define __NR_fchdir             176 /* Common                                      */
-#define __NR_fgetxattr          177 /* SunOS: fchroot                              */
-#define __NR_listxattr          178 /* SunOS: vpixsys                              */
-#define __NR_llistxattr         179 /* SunOS: aioread                              */
-#define __NR_flistxattr         180 /* SunOS: aiowrite                             */
-#define __NR_removexattr        181 /* SunOS: aiowait                              */
-#define __NR_lremovexattr       182 /* SunOS: aiocancel                            */
-#define __NR_sigpending         183 /* Common                                      */
-#define __NR_query_module       184 /* Linux Specific                              */
-#define __NR_setpgid            185 /* Common                                      */
-#define __NR_fremovexattr       186 /* SunOS: pathconf                             */
-#define __NR_tkill              187 /* SunOS: fpathconf                            */
-#define __NR_exit_group         188 /* Linux specific, sysconf undef SunOS         */
-#define __NR_uname              189 /* Linux Specific                              */
-#define __NR_init_module        190 /* Linux Specific                              */
-#define __NR_personality        191 /* Linux Specific                              */
-#define __NR_remap_file_pages   192 /* Linux Specific                              */
-#define __NR_epoll_create       193 /* Linux Specific                              */
-#define __NR_epoll_ctl          194 /* Linux Specific                              */
-#define __NR_epoll_wait         195 /* Linux Specific                              */
-#define __NR_ioprio_set         196 /* Linux Specific                              */
-#define __NR_getppid            197 /* Linux Specific                              */
-#define __NR_sigaction          198 /* Linux Specific                              */
-#define __NR_sgetmask           199 /* Linux Specific                              */
-#define __NR_ssetmask           200 /* Linux Specific                              */
-#define __NR_sigsuspend         201 /* Linux Specific                              */
-#define __NR_oldlstat           202 /* Linux Specific                              */
-#define __NR_uselib             203 /* Linux Specific                              */
-#define __NR_readdir            204 /* Linux Specific                              */
-#define __NR_readahead          205 /* Linux Specific                              */
-#define __NR_socketcall         206 /* Linux Specific                              */
-#define __NR_syslog             207 /* Linux Specific                              */
-#define __NR_lookup_dcookie     208 /* Linux Specific                              */
-#define __NR_fadvise64          209 /* Linux Specific                              */
-#define __NR_fadvise64_64       210 /* Linux Specific                              */
-#define __NR_tgkill             211 /* Linux Specific                              */
-#define __NR_waitpid            212 /* Linux Specific                              */
-#define __NR_swapoff            213 /* Linux Specific                              */
-#define __NR_sysinfo            214 /* Linux Specific                              */
-#define __NR_ipc                215 /* Linux Specific                              */
-#define __NR_sigreturn          216 /* Linux Specific                              */
-#define __NR_clone              217 /* Linux Specific                              */
-#define __NR_ioprio_get         218 /* Linux Specific                              */
-#define __NR_adjtimex           219 /* Linux Specific                              */
-#define __NR_sigprocmask        220 /* Linux Specific                              */
-#define __NR_create_module      221 /* Linux Specific                              */
-#define __NR_delete_module      222 /* Linux Specific                              */
-#define __NR_get_kernel_syms    223 /* Linux Specific                              */
-#define __NR_getpgid            224 /* Linux Specific                              */
-#define __NR_bdflush            225 /* Linux Specific                              */
-#define __NR_sysfs              226 /* Linux Specific                              */
-#define __NR_afs_syscall        227 /* Linux Specific                              */
-#define __NR_setfsuid           228 /* Linux Specific                              */
-#define __NR_setfsgid           229 /* Linux Specific                              */
-#define __NR__newselect         230 /* Linux Specific                              */
 #ifdef __32bit_syscall_numbers__
-#define __NR_time               231 /* Linux Specific                              */
 #else
-#ifdef __KERNEL__
 #define __NR_time               231 /* Linux sparc32                               */
 #endif
-#endif
-#define __NR_splice             232 /* Linux Specific                              */
-#define __NR_stime              233 /* Linux Specific                              */
-#define __NR_statfs64           234 /* Linux Specific                              */
-#define __NR_fstatfs64          235 /* Linux Specific                              */
-#define __NR__llseek            236 /* Linux Specific                              */
-#define __NR_mlock              237
-#define __NR_munlock            238
-#define __NR_mlockall           239
-#define __NR_munlockall         240
-#define __NR_sched_setparam     241
-#define __NR_sched_getparam     242
-#define __NR_sched_setscheduler 243
-#define __NR_sched_getscheduler 244
-#define __NR_sched_yield        245
-#define __NR_sched_get_priority_max 246
-#define __NR_sched_get_priority_min 247
-#define __NR_sched_rr_get_interval  248
-#define __NR_nanosleep          249
-#define __NR_mremap             250
-#define __NR__sysctl            251
-#define __NR_getsid             252
-#define __NR_fdatasync          253
-#define __NR_nfsservctl         254
-#define __NR_sync_file_range    255
-#define __NR_clock_settime      256
-#define __NR_clock_gettime      257
-#define __NR_clock_getres       258
-#define __NR_clock_nanosleep    259
-#define __NR_sched_getaffinity  260
-#define __NR_sched_setaffinity  261
-#define __NR_timer_settime      262
-#define __NR_timer_gettime      263
-#define __NR_timer_getoverrun   264
-#define __NR_timer_delete       265
-#define __NR_timer_create       266
-/* #define __NR_vserver         267 Reserved for VSERVER */
-#define __NR_io_setup           268
-#define __NR_io_destroy         269
-#define __NR_io_submit          270
-#define __NR_io_cancel          271
-#define __NR_io_getevents       272
-#define __NR_mq_open            273
-#define __NR_mq_unlink          274
-#define __NR_mq_timedsend       275
-#define __NR_mq_timedreceive    276
-#define __NR_mq_notify          277
-#define __NR_mq_getsetattr      278
-#define __NR_waitid             279
-#define __NR_tee                280
-#define __NR_add_key            281
-#define __NR_request_key        282
-#define __NR_keyctl             283
-#define __NR_openat             284
-#define __NR_mkdirat            285
-#define __NR_mknodat            286
-#define __NR_fchownat           287
-#define __NR_futimesat          288
-#define __NR_fstatat64          289
-#define __NR_unlinkat           290
-#define __NR_renameat           291
-#define __NR_linkat             292
-#define __NR_symlinkat          293
-#define __NR_readlinkat         294
-#define __NR_fchmodat           295
-#define __NR_faccessat          296
-#define __NR_pselect6           297
-#define __NR_ppoll              298
-#define __NR_unshare            299
-#define __NR_set_robust_list    300
-#define __NR_get_robust_list    301
-#define __NR_migrate_pages      302
-#define __NR_mbind              303
-#define __NR_get_mempolicy      304
-#define __NR_set_mempolicy      305
-#define __NR_kexec_load         306
-#define __NR_move_pages         307
-#define __NR_getcpu             308
-#define __NR_epoll_pwait        309
-#define __NR_utimensat          310
-#define __NR_signalfd           311
-#define __NR_timerfd_create     312
-#define __NR_eventfd            313
-#define __NR_fallocate          314
-#define __NR_timerfd_settime    315
-#define __NR_timerfd_gettime    316
-#define __NR_signalfd4          317
-#define __NR_eventfd2           318
-#define __NR_epoll_create1      319
-#define __NR_dup3               320
-#define __NR_pipe2              321
-#define __NR_inotify_init1      322
-#define __NR_accept4            323
-#define __NR_preadv             324
-#define __NR_pwritev            325
-#define __NR_rt_tgsigqueueinfo  326
-#define __NR_perf_event_open    327
-#define __NR_recvmmsg           328
-#define __NR_fanotify_init      329
-#define __NR_fanotify_mark      330
-#define __NR_prlimit64          331
-#define __NR_name_to_handle_at  332
-#define __NR_open_by_handle_at  333
-#define __NR_clock_adjtime      334
-#define __NR_syncfs             335
-#define __NR_sendmmsg           336
-#define __NR_setns              337
-#define __NR_process_vm_readv   338
-#define __NR_process_vm_writev  339
-
-#define NR_syscalls             340
-
-#ifdef __32bit_syscall_numbers__
-/* Sparc 32-bit only has the "setresuid32", "getresuid32" variants,
- * it never had the plain ones and there is no value to adding those
- * old versions into the syscall table.
- */
-#define __IGNORE_setresuid
-#define __IGNORE_getresuid
-#define __IGNORE_setresgid
-#define __IGNORE_getresgid
-#endif
-
-#ifdef __KERNEL__
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
 #define __ARCH_WANT_SYS_ALARM
@@ -458,5 +55,4 @@
  */
 #define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
 
-#endif /* __KERNEL__ */
 #endif /* _SPARC_UNISTD_H */
diff --git a/arch/sparc/include/uapi/asm/Kbuild b/arch/sparc/include/uapi/asm/Kbuild
index 7518ad286963..ce175aff71b7 100644
--- a/arch/sparc/include/uapi/asm/Kbuild
+++ b/arch/sparc/include/uapi/asm/Kbuild
@@ -3,3 +3,49 @@
 
 include include/uapi/asm-generic/Kbuild.asm
 
+header-y += apc.h
+header-y += asi.h
+header-y += auxvec.h
+header-y += bitsperlong.h
+header-y += byteorder.h
+header-y += display7seg.h
+header-y += envctrl.h
+header-y += errno.h
+header-y += fbio.h
+header-y += fcntl.h
+header-y += ioctl.h
+header-y += ioctls.h
+header-y += ipcbuf.h
+header-y += jsflash.h
+header-y += kvm_para.h
+header-y += mman.h
+header-y += msgbuf.h
+header-y += openpromio.h
+header-y += param.h
+header-y += perfctr.h
+header-y += poll.h
+header-y += posix_types.h
+header-y += psr.h
+header-y += psrcompat.h
+header-y += pstate.h
+header-y += ptrace.h
+header-y += resource.h
+header-y += sembuf.h
+header-y += setup.h
+header-y += shmbuf.h
+header-y += sigcontext.h
+header-y += siginfo.h
+header-y += signal.h
+header-y += socket.h
+header-y += sockios.h
+header-y += stat.h
+header-y += statfs.h
+header-y += swab.h
+header-y += termbits.h
+header-y += termios.h
+header-y += traps.h
+header-y += types.h
+header-y += uctx.h
+header-y += unistd.h
+header-y += utrap.h
+header-y += watchdog.h
diff --git a/arch/sparc/include/asm/apc.h b/arch/sparc/include/uapi/asm/apc.h
index 24e9a7d4d97e..24e9a7d4d97e 100644
--- a/arch/sparc/include/asm/apc.h
+++ b/arch/sparc/include/uapi/asm/apc.h
diff --git a/arch/sparc/include/asm/asi.h b/arch/sparc/include/uapi/asm/asi.h
index aace6f313716..aace6f313716 100644
--- a/arch/sparc/include/asm/asi.h
+++ b/arch/sparc/include/uapi/asm/asi.h
diff --git a/arch/sparc/include/asm/auxvec.h b/arch/sparc/include/uapi/asm/auxvec.h
index ad6f360261f6..ad6f360261f6 100644
--- a/arch/sparc/include/asm/auxvec.h
+++ b/arch/sparc/include/uapi/asm/auxvec.h
diff --git a/arch/sparc/include/asm/bitsperlong.h b/arch/sparc/include/uapi/asm/bitsperlong.h
index 40dcaa3aaa56..40dcaa3aaa56 100644
--- a/arch/sparc/include/asm/bitsperlong.h
+++ b/arch/sparc/include/uapi/asm/bitsperlong.h
diff --git a/arch/sparc/include/asm/byteorder.h b/arch/sparc/include/uapi/asm/byteorder.h
index ccc1b6b7de6c..ccc1b6b7de6c 100644
--- a/arch/sparc/include/asm/byteorder.h
+++ b/arch/sparc/include/uapi/asm/byteorder.h
diff --git a/arch/sparc/include/asm/display7seg.h b/arch/sparc/include/uapi/asm/display7seg.h
index 86d4a901df24..86d4a901df24 100644
--- a/arch/sparc/include/asm/display7seg.h
+++ b/arch/sparc/include/uapi/asm/display7seg.h
diff --git a/arch/sparc/include/asm/envctrl.h b/arch/sparc/include/uapi/asm/envctrl.h
index 624fa7e2da8e..624fa7e2da8e 100644
--- a/arch/sparc/include/asm/envctrl.h
+++ b/arch/sparc/include/uapi/asm/envctrl.h
diff --git a/arch/sparc/include/asm/errno.h b/arch/sparc/include/uapi/asm/errno.h
index c351aba997b7..c351aba997b7 100644
--- a/arch/sparc/include/asm/errno.h
+++ b/arch/sparc/include/uapi/asm/errno.h
diff --git a/arch/sparc/include/uapi/asm/fbio.h b/arch/sparc/include/uapi/asm/fbio.h
new file mode 100644
index 000000000000..d6cea07afb61
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/fbio.h
@@ -0,0 +1,259 @@
+#ifndef _UAPI__LINUX_FBIO_H
+#define _UAPI__LINUX_FBIO_H
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+/* Constants used for fbio SunOS compatibility */
+/* (C) 1996 Miguel de Icaza */
+
+/* Frame buffer types */
+#define FBTYPE_NOTYPE           -1
+#define FBTYPE_SUN1BW           0   /* mono */
+#define FBTYPE_SUN1COLOR        1 
+#define FBTYPE_SUN2BW           2 
+#define FBTYPE_SUN2COLOR        3 
+#define FBTYPE_SUN2GP           4 
+#define FBTYPE_SUN5COLOR        5 
+#define FBTYPE_SUN3COLOR        6 
+#define FBTYPE_MEMCOLOR         7 
+#define FBTYPE_SUN4COLOR        8 
+ 
+#define FBTYPE_NOTSUN1          9 
+#define FBTYPE_NOTSUN2          10
+#define FBTYPE_NOTSUN3          11
+ 
+#define FBTYPE_SUNFAST_COLOR    12  /* cg6 */
+#define FBTYPE_SUNROP_COLOR     13
+#define FBTYPE_SUNFB_VIDEO      14
+#define FBTYPE_SUNGIFB          15
+#define FBTYPE_SUNGPLAS         16
+#define FBTYPE_SUNGP3           17
+#define FBTYPE_SUNGT            18
+#define FBTYPE_SUNLEO           19      /* zx Leo card */
+#define FBTYPE_MDICOLOR         20      /* cg14 */
+#define FBTYPE_TCXCOLOR         21      /* SUNW,tcx card */
+
+#define FBTYPE_LASTPLUSONE      21      /* This is not last + 1 in fact... */
+
+/* Does not seem to be listed in the Sun file either */
+#define FBTYPE_CREATOR          22
+#define FBTYPE_PCI_IGA1682      23
+#define FBTYPE_P9100COLOR       24
+
+#define FBTYPE_PCI_GENERIC      1000
+#define FBTYPE_PCI_MACH64       1001
+
+/* fbio ioctls */
+/* Returned by FBIOGTYPE */
+struct  fbtype {
+        int     fb_type;        /* fb type, see above */
+        int     fb_height;      /* pixels */
+        int     fb_width;       /* pixels */
+        int     fb_depth;
+        int     fb_cmsize;      /* color map entries */
+        int     fb_size;        /* fb size in bytes */
+};
+#define FBIOGTYPE _IOR('F', 0, struct fbtype)
+
+struct  fbcmap {
+        int             index;          /* first element (0 origin) */
+        int             count;
+        unsigned char   __user *red;
+        unsigned char   __user *green;
+        unsigned char   __user *blue;
+};
+
+#ifndef __KERNEL__
+#define FBIOPUTCMAP _IOW('F', 3, struct fbcmap)
+#define FBIOGETCMAP _IOW('F', 4, struct fbcmap)
+#endif
+
+/* # of device specific values */
+#define FB_ATTR_NDEVSPECIFIC    8
+/* # of possible emulations */
+#define FB_ATTR_NEMUTYPES       4
+ 
+struct fbsattr {
+        int     flags;
+        int     emu_type;       /* -1 if none */
+        int     dev_specific[FB_ATTR_NDEVSPECIFIC];
+};
+ 
+struct fbgattr {
+        int     real_type;      /* real frame buffer type */
+        int     owner;          /* unknown */
+        struct fbtype fbtype;   /* real frame buffer fbtype */
+        struct fbsattr sattr;   
+        int     emu_types[FB_ATTR_NEMUTYPES]; /* supported emulations */
+};
+#define FBIOSATTR  _IOW('F', 5, struct fbgattr) /* Unsupported: */
+#define FBIOGATTR  _IOR('F', 6, struct fbgattr) /* supported */
+
+#define FBIOSVIDEO _IOW('F', 7, int)
+#define FBIOGVIDEO _IOR('F', 8, int)
+
+struct fbcursor {
+        short set;              /* what to set, choose from the list above */
+        short enable;           /* cursor on/off */
+        struct fbcurpos pos;    /* cursor position */
+        struct fbcurpos hot;    /* cursor hot spot */
+        struct fbcmap cmap;     /* color map info */
+        struct fbcurpos size;   /* cursor bit map size */
+        char __user *image;     /* cursor image bits */
+        char __user *mask;      /* cursor mask bits */
+};
+
+/* set/get cursor attributes/shape */
+#define FBIOSCURSOR     _IOW('F', 24, struct fbcursor)
+#define FBIOGCURSOR     _IOWR('F', 25, struct fbcursor)
+ 
+/* set/get cursor position */
+#define FBIOSCURPOS     _IOW('F', 26, struct fbcurpos)
+#define FBIOGCURPOS     _IOW('F', 27, struct fbcurpos)
+ 
+/* get max cursor size */
+#define FBIOGCURMAX     _IOR('F', 28, struct fbcurpos)
+
+/* wid manipulation */
+struct fb_wid_alloc {
+#define FB_WID_SHARED_8         0
+#define FB_WID_SHARED_24        1
+#define FB_WID_DBL_8            2
+#define FB_WID_DBL_24           3
+        __u32   wa_type;
+        __s32   wa_index;       /* Set on return */
+        __u32   wa_count;       
+};
+struct fb_wid_item {
+        __u32   wi_type;
+        __s32   wi_index;
+        __u32   wi_attrs;
+        __u32   wi_values[32];
+};
+struct fb_wid_list {
+        __u32   wl_flags;
+        __u32   wl_count;
+        struct fb_wid_item      *wl_list;
+};
+
+#define FBIO_WID_ALLOC  _IOWR('F', 30, struct fb_wid_alloc)
+#define FBIO_WID_FREE   _IOW('F', 31, struct fb_wid_alloc)
+#define FBIO_WID_PUT    _IOW('F', 32, struct fb_wid_list)
+#define FBIO_WID_GET    _IOWR('F', 33, struct fb_wid_list)
+
+/* Creator ioctls */
+#define FFB_IOCTL       ('F'<<8)
+#define FFB_SYS_INFO            (FFB_IOCTL|80)
+#define FFB_CLUTREAD            (FFB_IOCTL|81)
+#define FFB_CLUTPOST            (FFB_IOCTL|82)
+#define FFB_SETDIAGMODE         (FFB_IOCTL|83)
+#define FFB_GETMONITORID        (FFB_IOCTL|84)
+#define FFB_GETVIDEOMODE        (FFB_IOCTL|85)
+#define FFB_SETVIDEOMODE        (FFB_IOCTL|86)
+#define FFB_SETSERVER           (FFB_IOCTL|87)
+#define FFB_SETOVCTL            (FFB_IOCTL|88)
+#define FFB_GETOVCTL            (FFB_IOCTL|89)
+#define FFB_GETSAXNUM           (FFB_IOCTL|90)
+#define FFB_FBDEBUG             (FFB_IOCTL|91)
+
+/* Cg14 ioctls */
+#define MDI_IOCTL          ('M'<<8)
+#define MDI_RESET          (MDI_IOCTL|1)
+#define MDI_GET_CFGINFO    (MDI_IOCTL|2)
+#define MDI_SET_PIXELMODE  (MDI_IOCTL|3)
+#    define MDI_32_PIX     32
+#    define MDI_16_PIX     16
+#    define MDI_8_PIX      8
+
+struct mdi_cfginfo {
+        int     mdi_ncluts;     /* Number of implemented CLUTs in this MDI */
+        int     mdi_type;       /* FBTYPE name */
+        int     mdi_height;     /* height */
+        int     mdi_width;      /* width */
+        int     mdi_size;       /* available ram */
+        int     mdi_mode;       /* 8bpp, 16bpp or 32bpp */
+        int     mdi_pixfreq;    /* pixel clock (from PROM) */
+};
+
+/* SparcLinux specific ioctl for the MDI, should be replaced for
+ * the SET_XLUT/SET_CLUTn ioctls instead
+ */
+#define MDI_CLEAR_XLUT       (MDI_IOCTL|9)
+
+/* leo & ffb ioctls */
+struct fb_clut_alloc {
+        __u32   clutid; /* Set on return */
+        __u32   flag;
+        __u32   index;
+};
+
+struct fb_clut {
+#define FB_CLUT_WAIT    0x00000001      /* Not yet implemented */
+        __u32   flag;
+        __u32   clutid;
+        __u32   offset;
+        __u32   count;
+        char *  red;
+        char *  green;
+        char *  blue;
+};
+
+struct fb_clut32 {
+        __u32   flag;
+        __u32   clutid;
+        __u32   offset;
+        __u32   count;
+        __u32   red;
+        __u32   green;
+        __u32   blue;
+};
+
+#define LEO_CLUTALLOC   _IOWR('L', 53, struct fb_clut_alloc)
+#define LEO_CLUTFREE    _IOW('L', 54, struct fb_clut_alloc)
+#define LEO_CLUTREAD    _IOW('L', 55, struct fb_clut)
+#define LEO_CLUTPOST    _IOW('L', 56, struct fb_clut)
+#define LEO_SETGAMMA    _IOW('L', 68, int) /* Not yet implemented */
+#define LEO_GETGAMMA    _IOR('L', 69, int) /* Not yet implemented */
+
+
+/* These are exported to userland for applications to use */
+/* Mappable offsets for the cg14: control registers */
+#define MDI_DIRECT_MAP 0x10000000
+#define MDI_CTLREG_MAP 0x20000000
+#define MDI_CURSOR_MAP 0x30000000
+#define MDI_SHDW_VRT_MAP 0x40000000
+
+/* Mappable offsets for the cg14: frame buffer resolutions */
+/* 32 bits */
+#define MDI_CHUNKY_XBGR_MAP 0x50000000
+#define MDI_CHUNKY_BGR_MAP 0x60000000
+
+/* 16 bits */
+#define MDI_PLANAR_X16_MAP 0x70000000
+#define MDI_PLANAR_C16_MAP 0x80000000
+
+/* 8 bit is done as CG3 MMAP offset */
+/* 32 bits, planar */
+#define MDI_PLANAR_X32_MAP 0x90000000
+#define MDI_PLANAR_B32_MAP 0xa0000000
+#define MDI_PLANAR_G32_MAP 0xb0000000
+#define MDI_PLANAR_R32_MAP 0xc0000000
+
+/* Mappable offsets on leo */
+#define LEO_SS0_MAP            0x00000000
+#define LEO_LC_SS0_USR_MAP     0x00800000
+#define LEO_LD_SS0_MAP         0x00801000
+#define LEO_LX_CURSOR_MAP      0x00802000
+#define LEO_SS1_MAP            0x00803000
+#define LEO_LC_SS1_USR_MAP     0x01003000
+#define LEO_LD_SS1_MAP         0x01004000
+#define LEO_UNK_MAP            0x01005000
+#define LEO_LX_KRN_MAP         0x01006000
+#define LEO_LC_SS0_KRN_MAP     0x01007000
+#define LEO_LC_SS1_KRN_MAP     0x01008000
+#define LEO_LD_GBL_MAP         0x01009000
+#define LEO_UNK2_MAP           0x0100a000
+
+
+#endif /* _UAPI__LINUX_FBIO_H */
diff --git a/arch/sparc/include/asm/fcntl.h b/arch/sparc/include/uapi/asm/fcntl.h
index d0b83f66f356..d0b83f66f356 100644
--- a/arch/sparc/include/asm/fcntl.h
+++ b/arch/sparc/include/uapi/asm/fcntl.h
diff --git a/arch/sparc/include/asm/ioctl.h b/arch/sparc/include/uapi/asm/ioctl.h
index 7d6bd51321b9..7d6bd51321b9 100644
--- a/arch/sparc/include/asm/ioctl.h
+++ b/arch/sparc/include/uapi/asm/ioctl.h
diff --git a/arch/sparc/include/uapi/asm/ioctls.h b/arch/sparc/include/uapi/asm/ioctls.h
new file mode 100644
index 000000000000..9155f7041d44
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/ioctls.h
@@ -0,0 +1,131 @@
+#ifndef _UAPI_ASM_SPARC_IOCTLS_H
+#define _UAPI_ASM_SPARC_IOCTLS_H
+
+#include <asm/ioctl.h>
+
+/* Big T */
+#define TCGETA          _IOR('T', 1, struct termio)
+#define TCSETA          _IOW('T', 2, struct termio)
+#define TCSETAW         _IOW('T', 3, struct termio)
+#define TCSETAF         _IOW('T', 4, struct termio)
+#define TCSBRK          _IO('T', 5)
+#define TCXONC          _IO('T', 6)
+#define TCFLSH          _IO('T', 7)
+#define TCGETS          _IOR('T', 8, struct termios)
+#define TCSETS          _IOW('T', 9, struct termios)
+#define TCSETSW         _IOW('T', 10, struct termios)
+#define TCSETSF         _IOW('T', 11, struct termios)
+#define TCGETS2         _IOR('T', 12, struct termios2)
+#define TCSETS2         _IOW('T', 13, struct termios2)
+#define TCSETSW2        _IOW('T', 14, struct termios2)
+#define TCSETSF2        _IOW('T', 15, struct termios2)
+#define TIOCGDEV        _IOR('T',0x32, unsigned int) /* Get primary device node of /dev/console */
+#define TIOCVHANGUP     _IO('T', 0x37)
+
+/* Note that all the ioctls that are not available in Linux have a 
+ * double underscore on the front to: a) avoid some programs to
+ * think we support some ioctls under Linux (autoconfiguration stuff)
+ */
+/* Little t */
+#define TIOCGETD        _IOR('t', 0, int)
+#define TIOCSETD        _IOW('t', 1, int)
+#define __TIOCHPCL        _IO('t', 2) /* SunOS Specific */
+#define __TIOCMODG        _IOR('t', 3, int) /* SunOS Specific */
+#define __TIOCMODS        _IOW('t', 4, int) /* SunOS Specific */
+#define __TIOCGETP        _IOR('t', 8, struct sgttyb) /* SunOS Specific */
+#define __TIOCSETP        _IOW('t', 9, struct sgttyb) /* SunOS Specific */
+#define __TIOCSETN        _IOW('t', 10, struct sgttyb) /* SunOS Specific */
+#define TIOCEXCL        _IO('t', 13)
+#define TIOCNXCL        _IO('t', 14)
+#define __TIOCFLUSH       _IOW('t', 16, int) /* SunOS Specific */
+#define __TIOCSETC        _IOW('t', 17, struct tchars) /* SunOS Specific */
+#define __TIOCGETC        _IOR('t', 18, struct tchars) /* SunOS Specific */
+#define __TIOCTCNTL       _IOW('t', 32, int) /* SunOS Specific */
+#define __TIOCSIGNAL      _IOW('t', 33, int) /* SunOS Specific */
+#define __TIOCSETX        _IOW('t', 34, int) /* SunOS Specific */
+#define __TIOCGETX        _IOR('t', 35, int) /* SunOS Specific */
+#define TIOCCONS        _IO('t', 36)
+#define TIOCGSOFTCAR    _IOR('t', 100, int)
+#define TIOCSSOFTCAR    _IOW('t', 101, int)
+#define __TIOCUCNTL       _IOW('t', 102, int) /* SunOS Specific */
+#define TIOCSWINSZ      _IOW('t', 103, struct winsize)
+#define TIOCGWINSZ      _IOR('t', 104, struct winsize)
+#define __TIOCREMOTE      _IOW('t', 105, int) /* SunOS Specific */
+#define TIOCMGET        _IOR('t', 106, int)
+#define TIOCMBIC        _IOW('t', 107, int)
+#define TIOCMBIS        _IOW('t', 108, int)
+#define TIOCMSET        _IOW('t', 109, int)
+#define TIOCSTART       _IO('t', 110)
+#define TIOCSTOP        _IO('t', 111)
+#define TIOCPKT         _IOW('t', 112, int)
+#define TIOCNOTTY       _IO('t', 113)
+#define TIOCSTI         _IOW('t', 114, char)
+#define TIOCOUTQ        _IOR('t', 115, int)
+#define __TIOCGLTC        _IOR('t', 116, struct ltchars) /* SunOS Specific */
+#define __TIOCSLTC        _IOW('t', 117, struct ltchars) /* SunOS Specific */
+/* 118 is the non-posix setpgrp tty ioctl */
+/* 119 is the non-posix getpgrp tty ioctl */
+#define __TIOCCDTR        _IO('t', 120) /* SunOS Specific */
+#define __TIOCSDTR        _IO('t', 121) /* SunOS Specific */
+#define TIOCCBRK        _IO('t', 122)
+#define TIOCSBRK        _IO('t', 123)
+#define __TIOCLGET        _IOW('t', 124, int) /* SunOS Specific */
+#define __TIOCLSET        _IOW('t', 125, int) /* SunOS Specific */
+#define __TIOCLBIC        _IOW('t', 126, int) /* SunOS Specific */
+#define __TIOCLBIS        _IOW('t', 127, int) /* SunOS Specific */
+#define __TIOCISPACE      _IOR('t', 128, int) /* SunOS Specific */
+#define __TIOCISIZE       _IOR('t', 129, int) /* SunOS Specific */
+#define TIOCSPGRP       _IOW('t', 130, int)
+#define TIOCGPGRP       _IOR('t', 131, int)
+#define TIOCSCTTY       _IO('t', 132)
+#define TIOCGSID        _IOR('t', 133, int)
+/* Get minor device of a pty master's FD -- Solaris equiv is ISPTM */
+#define TIOCGPTN        _IOR('t', 134, unsigned int) /* Get Pty Number */
+#define TIOCSPTLCK      _IOW('t', 135, int) /* Lock/unlock PTY */
+#define TIOCSIG         _IOW('t', 136, int) /* Generate signal on Pty slave */
+
+/* Little f */
+#define FIOCLEX         _IO('f', 1)
+#define FIONCLEX        _IO('f', 2)
+#define FIOASYNC        _IOW('f', 125, int)
+#define FIONBIO         _IOW('f', 126, int)
+#define FIONREAD        _IOR('f', 127, int)
+#define TIOCINQ         FIONREAD
+#define FIOQSIZE        _IOR('f', 128, loff_t)
+
+/* SCARY Rutgers local SunOS kernel hackery, perhaps I will support it
+ * someday.  This is completely bogus, I know...
+ */
+#define __TCGETSTAT       _IO('T', 200) /* Rutgers specific */
+#define __TCSETSTAT       _IO('T', 201) /* Rutgers specific */
+
+/* Linux specific, no SunOS equivalent. */
+#define TIOCLINUX       0x541C
+#define TIOCGSERIAL     0x541E
+#define TIOCSSERIAL     0x541F
+#define TCSBRKP         0x5425
+#define TIOCSERCONFIG   0x5453
+#define TIOCSERGWILD    0x5454
+#define TIOCSERSWILD    0x5455
+#define TIOCGLCKTRMIOS  0x5456
+#define TIOCSLCKTRMIOS  0x5457
+#define TIOCSERGSTRUCT  0x5458 /* For debugging only */
+#define TIOCSERGETLSR   0x5459 /* Get line status register */
+#define TIOCSERGETMULTI 0x545A /* Get multiport config  */
+#define TIOCSERSETMULTI 0x545B /* Set multiport config */
+#define TIOCMIWAIT      0x545C /* Wait for change on serial input line(s) */
+#define TIOCGICOUNT     0x545D /* Read serial port inline interrupt counts */
+
+/* Kernel definitions */
+
+/* Used for packet mode */
+#define TIOCPKT_DATA             0
+#define TIOCPKT_FLUSHREAD        1
+#define TIOCPKT_FLUSHWRITE       2
+#define TIOCPKT_STOP             4
+#define TIOCPKT_START            8
+#define TIOCPKT_NOSTOP          16
+#define TIOCPKT_DOSTOP          32
+#define TIOCPKT_IOCTL           64
+
+#endif /* _UAPI_ASM_SPARC_IOCTLS_H */
diff --git a/arch/sparc/include/asm/ipcbuf.h b/arch/sparc/include/uapi/asm/ipcbuf.h
index 66013b4fe10d..66013b4fe10d 100644
--- a/arch/sparc/include/asm/ipcbuf.h
+++ b/arch/sparc/include/uapi/asm/ipcbuf.h
diff --git a/arch/sparc/include/asm/jsflash.h b/arch/sparc/include/uapi/asm/jsflash.h
index 0717d9e39d2d..0717d9e39d2d 100644
--- a/arch/sparc/include/asm/jsflash.h
+++ b/arch/sparc/include/uapi/asm/jsflash.h
diff --git a/arch/sparc/include/asm/kvm_para.h b/arch/sparc/include/uapi/asm/kvm_para.h
index 14fab8f0b957..14fab8f0b957 100644
--- a/arch/sparc/include/asm/kvm_para.h
+++ b/arch/sparc/include/uapi/asm/kvm_para.h
diff --git a/arch/sparc/include/uapi/asm/mman.h b/arch/sparc/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..0b14df33cffa
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/mman.h
@@ -0,0 +1,27 @@
+#ifndef _UAPI__SPARC_MMAN_H__
+#define _UAPI__SPARC_MMAN_H__
+
+#include <asm-generic/mman-common.h>
+
+/* SunOS'ified... */
+
+#define MAP_RENAME      MAP_ANONYMOUS   /* In SunOS terminology */
+#define MAP_NORESERVE   0x40            /* don't reserve swap pages */
+#define MAP_INHERIT     0x80            /* SunOS doesn't do this, but... */
+#define MAP_LOCKED      0x100           /* lock the mapping */
+#define _MAP_NEW        0x80000000      /* Binary compatibility is fun... */
+
+#define MAP_GROWSDOWN   0x0200          /* stack-like segment */
+#define MAP_DENYWRITE   0x0800          /* ETXTBSY */
+#define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
+
+#define MCL_CURRENT     0x2000          /* lock all currently mapped pages */
+#define MCL_FUTURE      0x4000          /* lock all additions to address space */
+
+#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
+#define MAP_NONBLOCK    0x10000         /* do not block on IO */
+#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
+#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
+
+
+#endif /* _UAPI__SPARC_MMAN_H__ */
diff --git a/arch/sparc/include/asm/msgbuf.h b/arch/sparc/include/uapi/asm/msgbuf.h
index efc7cbe9788f..efc7cbe9788f 100644
--- a/arch/sparc/include/asm/msgbuf.h
+++ b/arch/sparc/include/uapi/asm/msgbuf.h
diff --git a/arch/sparc/include/asm/openpromio.h b/arch/sparc/include/uapi/asm/openpromio.h
index 917fb8e9c633..917fb8e9c633 100644
--- a/arch/sparc/include/asm/openpromio.h
+++ b/arch/sparc/include/uapi/asm/openpromio.h
diff --git a/arch/sparc/include/asm/param.h b/arch/sparc/include/uapi/asm/param.h
index 0bc356bf8c50..0bc356bf8c50 100644
--- a/arch/sparc/include/asm/param.h
+++ b/arch/sparc/include/uapi/asm/param.h
diff --git a/arch/sparc/include/asm/perfctr.h b/arch/sparc/include/uapi/asm/perfctr.h
index 214feefa577c..214feefa577c 100644
--- a/arch/sparc/include/asm/perfctr.h
+++ b/arch/sparc/include/uapi/asm/perfctr.h
diff --git a/arch/sparc/include/asm/poll.h b/arch/sparc/include/uapi/asm/poll.h
index 091d3ad2e830..091d3ad2e830 100644
--- a/arch/sparc/include/asm/poll.h
+++ b/arch/sparc/include/uapi/asm/poll.h
diff --git a/arch/sparc/include/asm/posix_types.h b/arch/sparc/include/uapi/asm/posix_types.h
index 156220ed99eb..156220ed99eb 100644
--- a/arch/sparc/include/asm/posix_types.h
+++ b/arch/sparc/include/uapi/asm/posix_types.h
diff --git a/arch/sparc/include/uapi/asm/psr.h b/arch/sparc/include/uapi/asm/psr.h
new file mode 100644
index 000000000000..2f0ed856530b
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/psr.h
@@ -0,0 +1,47 @@
+/*
+ * psr.h: This file holds the macros for masking off various parts of
+ *        the processor status register on the Sparc. This is valid
+ *        for Version 8. On the V9 this is renamed to the PSTATE
+ *        register and its members are accessed as fields like
+ *        PSTATE.PRIV for the current CPU privilege level.
+ *
+ * Copyright (C) 1994 David S. Miller (davem@caip.rutgers.edu)
+ */
+
+#ifndef _UAPI__LINUX_SPARC_PSR_H
+#define _UAPI__LINUX_SPARC_PSR_H
+
+/* The Sparc PSR fields are laid out as the following:
+ *
+ *  ------------------------------------------------------------------------
+ *  | impl  | vers  | icc   | resv  | EC | EF | PIL  | S | PS | ET |  CWP  |
+ *  | 31-28 | 27-24 | 23-20 | 19-14 | 13 | 12 | 11-8 | 7 | 6  | 5  |  4-0  |
+ *  ------------------------------------------------------------------------
+ */
+#define PSR_CWP     0x0000001f         /* current window pointer     */
+#define PSR_ET      0x00000020         /* enable traps field         */
+#define PSR_PS      0x00000040         /* previous privilege level   */
+#define PSR_S       0x00000080         /* current privilege level    */
+#define PSR_PIL     0x00000f00         /* processor interrupt level  */
+#define PSR_EF      0x00001000         /* enable floating point      */
+#define PSR_EC      0x00002000         /* enable co-processor        */
+#define PSR_SYSCALL 0x00004000         /* inside of a syscall        */
+#define PSR_LE      0x00008000         /* SuperSparcII little-endian */
+#define PSR_ICC     0x00f00000         /* integer condition codes    */
+#define PSR_C       0x00100000         /* carry bit                  */
+#define PSR_V       0x00200000         /* overflow bit               */
+#define PSR_Z       0x00400000         /* zero bit                   */
+#define PSR_N       0x00800000         /* negative bit               */
+#define PSR_VERS    0x0f000000         /* cpu-version field          */
+#define PSR_IMPL    0xf0000000         /* cpu-implementation field   */
+
+#define PSR_VERS_SHIFT          24
+#define PSR_IMPL_SHIFT          28
+#define PSR_VERS_SHIFTED_MASK   0xf
+#define PSR_IMPL_SHIFTED_MASK   0xf
+
+#define PSR_IMPL_TI             0x4
+#define PSR_IMPL_LEON           0xf
+
+
+#endif /* _UAPI__LINUX_SPARC_PSR_H */
diff --git a/arch/sparc/include/asm/psrcompat.h b/arch/sparc/include/uapi/asm/psrcompat.h
index 44b6327dbbf5..44b6327dbbf5 100644
--- a/arch/sparc/include/asm/psrcompat.h
+++ b/arch/sparc/include/uapi/asm/psrcompat.h
diff --git a/arch/sparc/include/asm/pstate.h b/arch/sparc/include/uapi/asm/pstate.h
index 4b6b998afd99..4b6b998afd99 100644
--- a/arch/sparc/include/asm/pstate.h
+++ b/arch/sparc/include/uapi/asm/pstate.h
diff --git a/arch/sparc/include/uapi/asm/ptrace.h b/arch/sparc/include/uapi/asm/ptrace.h
new file mode 100644
index 000000000000..56fe4ea73feb
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/ptrace.h
@@ -0,0 +1,352 @@
+#ifndef _UAPI__SPARC_PTRACE_H
+#define _UAPI__SPARC_PTRACE_H
+
+#if defined(__sparc__) && defined(__arch64__)
+/* 64 bit sparc */
+#include <asm/pstate.h>
+
+/* This struct defines the way the registers are stored on the
+ * stack during a system call and basically all traps.
+ */
+
+/* This magic value must have the low 9 bits clear,
+ * as that is where we encode the %tt value, see below.
+ */
+#define PT_REGS_MAGIC 0x57ac6c00
+
+#ifndef __ASSEMBLY__
+
+#include <linux/types.h>
+
+struct pt_regs {
+        unsigned long u_regs[16]; /* globals and ins */
+        unsigned long tstate;
+        unsigned long tpc;
+        unsigned long tnpc;
+        unsigned int y;
+
+        /* We encode a magic number, PT_REGS_MAGIC, along
+         * with the %tt (trap type) register value at trap
+         * entry time.  The magic number allows us to identify
+         * accurately a trap stack frame in the stack
+         * unwinder, and the %tt value allows us to test
+         * things like "in a system call" etc. for an arbitray
+         * process.
+         *
+         * The PT_REGS_MAGIC is chosen such that it can be
+         * loaded completely using just a sethi instruction.
+         */
+        unsigned int magic;
+};
+
+struct pt_regs32 {
+        unsigned int psr;
+        unsigned int pc;
+        unsigned int npc;
+        unsigned int y;
+        unsigned int u_regs[16]; /* globals and ins */
+};
+
+/* A V9 register window */
+struct reg_window {
+        unsigned long locals[8];
+        unsigned long ins[8];
+};
+
+/* A 32-bit register window. */
+struct reg_window32 {
+        unsigned int locals[8];
+        unsigned int ins[8];
+};
+
+/* A V9 Sparc stack frame */
+struct sparc_stackf {
+        unsigned long locals[8];
+        unsigned long ins[6];
+        struct sparc_stackf *fp;
+        unsigned long callers_pc;
+        char *structptr;
+        unsigned long xargs[6];
+        unsigned long xxargs[1];
+};
+
+/* A 32-bit Sparc stack frame */
+struct sparc_stackf32 {
+        unsigned int locals[8];
+        unsigned int ins[6];
+        unsigned int fp;
+        unsigned int callers_pc;
+        unsigned int structptr;
+        unsigned int xargs[6];
+        unsigned int xxargs[1];
+};
+
+struct sparc_trapf {
+        unsigned long locals[8];
+        unsigned long ins[8];
+        unsigned long _unused;
+        struct pt_regs *regs;
+};
+#endif /* (!__ASSEMBLY__) */
+#else
+/* 32 bit sparc */
+
+#include <asm/psr.h>
+
+/* This struct defines the way the registers are stored on the
+ * stack during a system call and basically all traps.
+ */
+#ifndef __ASSEMBLY__
+
+#include <linux/types.h>
+
+struct pt_regs {
+        unsigned long psr;
+        unsigned long pc;
+        unsigned long npc;
+        unsigned long y;
+        unsigned long u_regs[16]; /* globals and ins */
+};
+
+/* A 32-bit register window. */
+struct reg_window32 {
+        unsigned long locals[8];
+        unsigned long ins[8];
+};
+
+/* A Sparc stack frame */
+struct sparc_stackf {
+        unsigned long locals[8];
+        unsigned long ins[6];
+        struct sparc_stackf *fp;
+        unsigned long callers_pc;
+        char *structptr;
+        unsigned long xargs[6];
+        unsigned long xxargs[1];
+};
+#endif /* (!__ASSEMBLY__) */
+
+#endif /* (defined(__sparc__) && defined(__arch64__))*/
+
+#ifndef __ASSEMBLY__
+
+#define TRACEREG_SZ     sizeof(struct pt_regs)
+#define STACKFRAME_SZ   sizeof(struct sparc_stackf)
+
+#define TRACEREG32_SZ   sizeof(struct pt_regs32)
+#define STACKFRAME32_SZ sizeof(struct sparc_stackf32)
+
+#endif /* (!__ASSEMBLY__) */
+
+#define UREG_G0        0
+#define UREG_G1        1
+#define UREG_G2        2
+#define UREG_G3        3
+#define UREG_G4        4
+#define UREG_G5        5
+#define UREG_G6        6
+#define UREG_G7        7
+#define UREG_I0        8
+#define UREG_I1        9
+#define UREG_I2        10
+#define UREG_I3        11
+#define UREG_I4        12
+#define UREG_I5        13
+#define UREG_I6        14
+#define UREG_I7        15
+#define UREG_FP        UREG_I6
+#define UREG_RETPC     UREG_I7
+
+#if defined(__sparc__) && defined(__arch64__)
+/* 64 bit sparc */
+
+#ifndef __ASSEMBLY__
+
+
+#else /* __ASSEMBLY__ */
+/* For assembly code. */
+#define TRACEREG_SZ             0xa0
+#define STACKFRAME_SZ           0xc0
+
+#define TRACEREG32_SZ           0x50
+#define STACKFRAME32_SZ         0x60
+#endif /* __ASSEMBLY__ */
+
+#else /* (defined(__sparc__) && defined(__arch64__)) */
+
+/* 32 bit sparc */
+
+#ifndef __ASSEMBLY__
+
+
+#else /* (!__ASSEMBLY__) */
+/* For assembly code. */
+#define TRACEREG_SZ       0x50
+#define STACKFRAME_SZ     0x60
+#endif /* (!__ASSEMBLY__) */
+
+#endif /* (defined(__sparc__) && defined(__arch64__)) */
+
+
+/* These are for pt_regs. */
+#define PT_V9_G0     0x00
+#define PT_V9_G1     0x08
+#define PT_V9_G2     0x10
+#define PT_V9_G3     0x18
+#define PT_V9_G4     0x20
+#define PT_V9_G5     0x28
+#define PT_V9_G6     0x30
+#define PT_V9_G7     0x38
+#define PT_V9_I0     0x40
+#define PT_V9_I1     0x48
+#define PT_V9_I2     0x50
+#define PT_V9_I3     0x58
+#define PT_V9_I4     0x60
+#define PT_V9_I5     0x68
+#define PT_V9_I6     0x70
+#define PT_V9_FP     PT_V9_I6
+#define PT_V9_I7     0x78
+#define PT_V9_TSTATE 0x80
+#define PT_V9_TPC    0x88
+#define PT_V9_TNPC   0x90
+#define PT_V9_Y      0x98
+#define PT_V9_MAGIC  0x9c
+#define PT_TSTATE       PT_V9_TSTATE
+#define PT_TPC          PT_V9_TPC
+#define PT_TNPC         PT_V9_TNPC
+
+/* These for pt_regs32. */
+#define PT_PSR    0x0
+#define PT_PC     0x4
+#define PT_NPC    0x8
+#define PT_Y      0xc
+#define PT_G0     0x10
+#define PT_WIM    PT_G0
+#define PT_G1     0x14
+#define PT_G2     0x18
+#define PT_G3     0x1c
+#define PT_G4     0x20
+#define PT_G5     0x24
+#define PT_G6     0x28
+#define PT_G7     0x2c
+#define PT_I0     0x30
+#define PT_I1     0x34
+#define PT_I2     0x38
+#define PT_I3     0x3c
+#define PT_I4     0x40
+#define PT_I5     0x44
+#define PT_I6     0x48
+#define PT_FP     PT_I6
+#define PT_I7     0x4c
+
+/* Reg_window offsets */
+#define RW_V9_L0     0x00
+#define RW_V9_L1     0x08
+#define RW_V9_L2     0x10
+#define RW_V9_L3     0x18
+#define RW_V9_L4     0x20
+#define RW_V9_L5     0x28
+#define RW_V9_L6     0x30
+#define RW_V9_L7     0x38
+#define RW_V9_I0     0x40
+#define RW_V9_I1     0x48
+#define RW_V9_I2     0x50
+#define RW_V9_I3     0x58
+#define RW_V9_I4     0x60
+#define RW_V9_I5     0x68
+#define RW_V9_I6     0x70
+#define RW_V9_I7     0x78
+
+#define RW_L0     0x00
+#define RW_L1     0x04
+#define RW_L2     0x08
+#define RW_L3     0x0c
+#define RW_L4     0x10
+#define RW_L5     0x14
+#define RW_L6     0x18
+#define RW_L7     0x1c
+#define RW_I0     0x20
+#define RW_I1     0x24
+#define RW_I2     0x28
+#define RW_I3     0x2c
+#define RW_I4     0x30
+#define RW_I5     0x34
+#define RW_I6     0x38
+#define RW_I7     0x3c
+
+/* Stack_frame offsets */
+#define SF_V9_L0     0x00
+#define SF_V9_L1     0x08
+#define SF_V9_L2     0x10
+#define SF_V9_L3     0x18
+#define SF_V9_L4     0x20
+#define SF_V9_L5     0x28
+#define SF_V9_L6     0x30
+#define SF_V9_L7     0x38
+#define SF_V9_I0     0x40
+#define SF_V9_I1     0x48
+#define SF_V9_I2     0x50
+#define SF_V9_I3     0x58
+#define SF_V9_I4     0x60
+#define SF_V9_I5     0x68
+#define SF_V9_FP     0x70
+#define SF_V9_PC     0x78
+#define SF_V9_RETP   0x80
+#define SF_V9_XARG0  0x88
+#define SF_V9_XARG1  0x90
+#define SF_V9_XARG2  0x98
+#define SF_V9_XARG3  0xa0
+#define SF_V9_XARG4  0xa8
+#define SF_V9_XARG5  0xb0
+#define SF_V9_XXARG  0xb8
+
+#define SF_L0     0x00
+#define SF_L1     0x04
+#define SF_L2     0x08
+#define SF_L3     0x0c
+#define SF_L4     0x10
+#define SF_L5     0x14
+#define SF_L6     0x18
+#define SF_L7     0x1c
+#define SF_I0     0x20
+#define SF_I1     0x24
+#define SF_I2     0x28
+#define SF_I3     0x2c
+#define SF_I4     0x30
+#define SF_I5     0x34
+#define SF_FP     0x38
+#define SF_PC     0x3c
+#define SF_RETP   0x40
+#define SF_XARG0  0x44
+#define SF_XARG1  0x48
+#define SF_XARG2  0x4c
+#define SF_XARG3  0x50
+#define SF_XARG4  0x54
+#define SF_XARG5  0x58
+#define SF_XXARG  0x5c
+
+
+/* Stuff for the ptrace system call */
+#define PTRACE_SPARC_DETACH       11
+#define PTRACE_GETREGS            12
+#define PTRACE_SETREGS            13
+#define PTRACE_GETFPREGS          14
+#define PTRACE_SETFPREGS          15
+#define PTRACE_READDATA           16
+#define PTRACE_WRITEDATA          17
+#define PTRACE_READTEXT           18
+#define PTRACE_WRITETEXT          19
+#define PTRACE_GETFPAREGS         20
+#define PTRACE_SETFPAREGS         21
+
+/* There are for debugging 64-bit processes, either from a 32 or 64 bit
+ * parent.  Thus their complements are for debugging 32-bit processes only.
+ */
+
+#define PTRACE_GETREGS64          22
+#define PTRACE_SETREGS64          23
+/* PTRACE_SYSCALL is 24 */
+#define PTRACE_GETFPREGS64        25
+#define PTRACE_SETFPREGS64        26
+
+#endif /* _UAPI__SPARC_PTRACE_H */
diff --git a/arch/sparc/include/asm/resource.h b/arch/sparc/include/uapi/asm/resource.h
index fe163cafb4c7..fe163cafb4c7 100644
--- a/arch/sparc/include/asm/resource.h
+++ b/arch/sparc/include/uapi/asm/resource.h
diff --git a/arch/sparc/include/asm/sembuf.h b/arch/sparc/include/uapi/asm/sembuf.h
index faee1be08d67..faee1be08d67 100644
--- a/arch/sparc/include/asm/sembuf.h
+++ b/arch/sparc/include/uapi/asm/sembuf.h
diff --git a/arch/sparc/include/uapi/asm/setup.h b/arch/sparc/include/uapi/asm/setup.h
new file mode 100644
index 000000000000..533768450872
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/setup.h
@@ -0,0 +1,15 @@
+/*
+ *      Just a place holder. 
+ */
+
+#ifndef _UAPI_SPARC_SETUP_H
+#define _UAPI_SPARC_SETUP_H
+
+#if defined(__sparc__) && defined(__arch64__)
+# define COMMAND_LINE_SIZE 2048
+#else
+# define COMMAND_LINE_SIZE 256
+#endif
+
+
+#endif /* _UAPI_SPARC_SETUP_H */
diff --git a/arch/sparc/include/asm/shmbuf.h b/arch/sparc/include/uapi/asm/shmbuf.h
index 83a16055363f..83a16055363f 100644
--- a/arch/sparc/include/asm/shmbuf.h
+++ b/arch/sparc/include/uapi/asm/shmbuf.h
diff --git a/arch/sparc/include/uapi/asm/sigcontext.h b/arch/sparc/include/uapi/asm/sigcontext.h
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/sigcontext.h
diff --git a/arch/sparc/include/uapi/asm/siginfo.h b/arch/sparc/include/uapi/asm/siginfo.h
new file mode 100644
index 000000000000..2d9b79ccaa50
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/siginfo.h
@@ -0,0 +1,25 @@
+#ifndef _UAPI__SPARC_SIGINFO_H
+#define _UAPI__SPARC_SIGINFO_H
+
+#if defined(__sparc__) && defined(__arch64__)
+
+#define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int))
+#define __ARCH_SI_BAND_T int
+
+#endif /* defined(__sparc__) && defined(__arch64__) */
+
+
+#define __ARCH_SI_TRAPNO
+
+#include <asm-generic/siginfo.h>
+
+
+#define SI_NOINFO       32767           /* no information in siginfo_t */
+
+/*
+ * SIGEMT si_codes
+ */
+#define EMT_TAGOVF      (__SI_FAULT|1)  /* tag overflow */
+#define NSIGEMT         1
+
+#endif /* _UAPI__SPARC_SIGINFO_H */
diff --git a/arch/sparc/include/uapi/asm/signal.h b/arch/sparc/include/uapi/asm/signal.h
new file mode 100644
index 000000000000..1a041892538f
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/signal.h
@@ -0,0 +1,185 @@
+#ifndef _UAPI__SPARC_SIGNAL_H
+#define _UAPI__SPARC_SIGNAL_H
+
+#include <asm/sigcontext.h>
+#include <linux/compiler.h>
+
+
+/* On the Sparc the signal handlers get passed a 'sub-signal' code
+ * for certain signal types, which we document here.
+ */
+#define SIGHUP           1
+#define SIGINT           2
+#define SIGQUIT          3
+#define SIGILL           4
+#define    SUBSIG_STACK       0
+#define    SUBSIG_ILLINST     2
+#define    SUBSIG_PRIVINST    3
+#define    SUBSIG_BADTRAP(t)  (0x80 + (t))
+
+#define SIGTRAP          5
+#define SIGABRT          6
+#define SIGIOT           6
+
+#define SIGEMT           7
+#define    SUBSIG_TAG    10
+
+#define SIGFPE           8
+#define    SUBSIG_FPDISABLED     0x400
+#define    SUBSIG_FPERROR        0x404
+#define    SUBSIG_FPINTOVFL      0x001
+#define    SUBSIG_FPSTSIG        0x002
+#define    SUBSIG_IDIVZERO       0x014
+#define    SUBSIG_FPINEXACT      0x0c4
+#define    SUBSIG_FPDIVZERO      0x0c8
+#define    SUBSIG_FPUNFLOW       0x0cc
+#define    SUBSIG_FPOPERROR      0x0d0
+#define    SUBSIG_FPOVFLOW       0x0d4
+
+#define SIGKILL          9
+#define SIGBUS          10
+#define    SUBSIG_BUSTIMEOUT    1
+#define    SUBSIG_ALIGNMENT     2
+#define    SUBSIG_MISCERROR     5
+
+#define SIGSEGV         11
+#define    SUBSIG_NOMAPPING     3
+#define    SUBSIG_PROTECTION    4
+#define    SUBSIG_SEGERROR      5
+
+#define SIGSYS          12
+
+#define SIGPIPE         13
+#define SIGALRM         14
+#define SIGTERM         15
+#define SIGURG          16
+
+/* SunOS values which deviate from the Linux/i386 ones */
+#define SIGSTOP         17
+#define SIGTSTP         18
+#define SIGCONT         19
+#define SIGCHLD         20
+#define SIGTTIN         21
+#define SIGTTOU         22
+#define SIGIO           23
+#define SIGPOLL         SIGIO   /* SysV name for SIGIO */
+#define SIGXCPU         24
+#define SIGXFSZ         25
+#define SIGVTALRM       26
+#define SIGPROF         27
+#define SIGWINCH        28
+#define SIGLOST         29
+#define SIGPWR          SIGLOST
+#define SIGUSR1         30
+#define SIGUSR2         31
+
+/* Most things should be clean enough to redefine this at will, if care
+   is taken to make libc match.  */
+
+#define __OLD_NSIG      32
+#define __NEW_NSIG      64
+#ifdef __arch64__
+#define _NSIG_BPW       64
+#else
+#define _NSIG_BPW       32
+#endif
+#define _NSIG_WORDS     (__NEW_NSIG / _NSIG_BPW)
+
+#define SIGRTMIN       32
+#define SIGRTMAX       __NEW_NSIG
+
+#if defined(__KERNEL__) || defined(__WANT_POSIX1B_SIGNALS__)
+#define _NSIG                   __NEW_NSIG
+#define __new_sigset_t          sigset_t
+#define __new_sigaction         sigaction
+#define __new_sigaction32       sigaction32
+#define __old_sigset_t          old_sigset_t
+#define __old_sigaction         old_sigaction
+#define __old_sigaction32       old_sigaction32
+#else
+#define _NSIG                   __OLD_NSIG
+#define NSIG                    _NSIG
+#define __old_sigset_t          sigset_t
+#define __old_sigaction         sigaction
+#define __old_sigaction32       sigaction32
+#endif
+
+#ifndef __ASSEMBLY__
+
+typedef unsigned long __old_sigset_t;            /* at least 32 bits */
+
+typedef struct {
+       unsigned long sig[_NSIG_WORDS];
+} __new_sigset_t;
+
+/* A SunOS sigstack */
+struct sigstack {
+        /* XXX 32-bit pointers pinhead XXX */
+        char *the_stack;
+        int   cur_status;
+};
+
+/* Sigvec flags */
+#define _SV_SSTACK    1u    /* This signal handler should use sig-stack */
+#define _SV_INTR      2u    /* Sig return should not restart system call */
+#define _SV_RESET     4u    /* Set handler to SIG_DFL upon taken signal */
+#define _SV_IGNCHILD  8u    /* Do not send SIGCHLD */
+
+/*
+ * sa_flags values: SA_STACK is not currently supported, but will allow the
+ * usage of signal stacks by using the (now obsolete) sa_restorer field in
+ * the sigaction structure as a stack pointer. This is now possible due to
+ * the changes in signal handling. LBT 010493.
+ * SA_RESTART flag to get restarting signals (which were the default long ago)
+ */
+#define SA_NOCLDSTOP    _SV_IGNCHILD
+#define SA_STACK        _SV_SSTACK
+#define SA_ONSTACK      _SV_SSTACK
+#define SA_RESTART      _SV_INTR
+#define SA_ONESHOT      _SV_RESET
+#define SA_NODEFER      0x20u
+#define SA_NOCLDWAIT    0x100u
+#define SA_SIGINFO      0x200u
+
+#define SA_NOMASK       SA_NODEFER
+
+#define SIG_BLOCK          0x01 /* for blocking signals */
+#define SIG_UNBLOCK        0x02 /* for unblocking signals */
+#define SIG_SETMASK        0x04 /* for setting the signal mask */
+
+/*
+ * sigaltstack controls
+ */
+#define SS_ONSTACK      1
+#define SS_DISABLE      2
+
+#define MINSIGSTKSZ     4096
+#define SIGSTKSZ        16384
+
+
+#include <asm-generic/signal-defs.h>
+
+struct __new_sigaction {
+        __sighandler_t          sa_handler;
+        unsigned long           sa_flags;
+        __sigrestore_t          sa_restorer;  /* not used by Linux/SPARC yet */
+        __new_sigset_t          sa_mask;
+};
+
+struct __old_sigaction {
+        __sighandler_t          sa_handler;
+        __old_sigset_t          sa_mask;
+        unsigned long           sa_flags;
+        void                    (*sa_restorer)(void);  /* not used by Linux/SPARC yet */
+};
+
+typedef struct sigaltstack {
+        void                    __user *ss_sp;
+        int                     ss_flags;
+        size_t                  ss_size;
+} stack_t;
+
+
+#endif /* !(__ASSEMBLY__) */
+
+#endif /* _UAPI__SPARC_SIGNAL_H */
diff --git a/arch/sparc/include/asm/socket.h b/arch/sparc/include/uapi/asm/socket.h
index bea1568ae4af..bea1568ae4af 100644
--- a/arch/sparc/include/asm/socket.h
+++ b/arch/sparc/include/uapi/asm/socket.h
diff --git a/arch/sparc/include/asm/sockios.h b/arch/sparc/include/uapi/asm/sockios.h
index 990ea746486b..990ea746486b 100644
--- a/arch/sparc/include/asm/sockios.h
+++ b/arch/sparc/include/uapi/asm/sockios.h
diff --git a/arch/sparc/include/asm/stat.h b/arch/sparc/include/uapi/asm/stat.h
index a232e9e1f4e5..a232e9e1f4e5 100644
--- a/arch/sparc/include/asm/stat.h
+++ b/arch/sparc/include/uapi/asm/stat.h
diff --git a/arch/sparc/include/asm/statfs.h b/arch/sparc/include/uapi/asm/statfs.h
index 55e607ad461d..55e607ad461d 100644
--- a/arch/sparc/include/asm/statfs.h
+++ b/arch/sparc/include/uapi/asm/statfs.h
diff --git a/arch/sparc/include/asm/swab.h b/arch/sparc/include/uapi/asm/swab.h
index a34ad079487e..a34ad079487e 100644
--- a/arch/sparc/include/asm/swab.h
+++ b/arch/sparc/include/uapi/asm/swab.h
diff --git a/arch/sparc/include/uapi/asm/termbits.h b/arch/sparc/include/uapi/asm/termbits.h
new file mode 100644
index 000000000000..dd91642fcca7
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/termbits.h
@@ -0,0 +1,263 @@
+#ifndef _UAPI_SPARC_TERMBITS_H
+#define _UAPI_SPARC_TERMBITS_H
+
+#include <linux/posix_types.h>
+
+typedef unsigned char   cc_t;
+typedef unsigned int    speed_t;
+
+#if defined(__sparc__) && defined(__arch64__)
+typedef unsigned int    tcflag_t;
+#else
+typedef unsigned long   tcflag_t;
+#endif
+
+#define NCC 8
+struct termio {
+        unsigned short c_iflag;         /* input mode flags */
+        unsigned short c_oflag;         /* output mode flags */
+        unsigned short c_cflag;         /* control mode flags */
+        unsigned short c_lflag;         /* local mode flags */
+        unsigned char c_line;           /* line discipline */
+        unsigned char c_cc[NCC];        /* control characters */
+};
+
+#define NCCS 17
+struct termios {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+#ifndef __KERNEL__
+        cc_t c_cc[NCCS];                /* control characters */
+#else
+        cc_t c_cc[NCCS+2];      /* kernel needs 2 more to hold vmin/vtime */
+#define SIZEOF_USER_TERMIOS sizeof (struct termios) - (2*sizeof (cc_t))
+#endif
+};
+
+struct termios2 {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+        cc_t c_cc[NCCS+2];              /* control characters */
+        speed_t c_ispeed;               /* input speed */
+        speed_t c_ospeed;               /* output speed */
+};
+
+struct ktermios {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+        cc_t c_cc[NCCS+2];              /* control characters */
+        speed_t c_ispeed;               /* input speed */
+        speed_t c_ospeed;               /* output speed */
+};
+
+/* c_cc characters */
+#define VINTR    0
+#define VQUIT    1
+#define VERASE   2
+#define VKILL    3
+#define VEOF     4
+#define VEOL     5
+#define VEOL2    6
+#define VSWTC    7
+#define VSTART   8
+#define VSTOP    9
+
+
+
+#define VSUSP    10
+#define VDSUSP   11  /* SunOS POSIX nicety I do believe... */
+#define VREPRINT 12
+#define VDISCARD 13
+#define VWERASE  14
+#define VLNEXT   15
+
+/* Kernel keeps vmin/vtime separated, user apps assume vmin/vtime is
+ * shared with eof/eol
+ */
+#ifndef __KERNEL__
+#define VMIN     VEOF
+#define VTIME    VEOL
+#endif
+
+/* c_iflag bits */
+#define IGNBRK  0x00000001
+#define BRKINT  0x00000002
+#define IGNPAR  0x00000004
+#define PARMRK  0x00000008
+#define INPCK   0x00000010
+#define ISTRIP  0x00000020
+#define INLCR   0x00000040
+#define IGNCR   0x00000080
+#define ICRNL   0x00000100
+#define IUCLC   0x00000200
+#define IXON    0x00000400
+#define IXANY   0x00000800
+#define IXOFF   0x00001000
+#define IMAXBEL 0x00002000
+#define IUTF8   0x00004000
+
+/* c_oflag bits */
+#define OPOST   0x00000001
+#define OLCUC   0x00000002
+#define ONLCR   0x00000004
+#define OCRNL   0x00000008
+#define ONOCR   0x00000010
+#define ONLRET  0x00000020
+#define OFILL   0x00000040
+#define OFDEL   0x00000080
+#define NLDLY   0x00000100
+#define   NL0   0x00000000
+#define   NL1   0x00000100
+#define CRDLY   0x00000600
+#define   CR0   0x00000000
+#define   CR1   0x00000200
+#define   CR2   0x00000400
+#define   CR3   0x00000600
+#define TABDLY  0x00001800
+#define   TAB0  0x00000000
+#define   TAB1  0x00000800
+#define   TAB2  0x00001000
+#define   TAB3  0x00001800
+#define   XTABS 0x00001800
+#define BSDLY   0x00002000
+#define   BS0   0x00000000
+#define   BS1   0x00002000
+#define VTDLY   0x00004000
+#define   VT0   0x00000000
+#define   VT1   0x00004000
+#define FFDLY   0x00008000
+#define   FF0   0x00000000
+#define   FF1   0x00008000
+#define PAGEOUT 0x00010000  /* SUNOS specific */
+#define WRAP    0x00020000  /* SUNOS specific */
+
+/* c_cflag bit meaning */
+#define CBAUD     0x0000100f
+#define  B0       0x00000000   /* hang up */
+#define  B50      0x00000001
+#define  B75      0x00000002
+#define  B110     0x00000003
+#define  B134     0x00000004
+#define  B150     0x00000005
+#define  B200     0x00000006
+#define  B300     0x00000007
+#define  B600     0x00000008
+#define  B1200    0x00000009
+#define  B1800    0x0000000a
+#define  B2400    0x0000000b
+#define  B4800    0x0000000c
+#define  B9600    0x0000000d
+#define  B19200   0x0000000e
+#define  B38400   0x0000000f
+#define EXTA      B19200
+#define EXTB      B38400
+#define  CSIZE    0x00000030
+#define   CS5     0x00000000
+#define   CS6     0x00000010
+#define   CS7     0x00000020
+#define   CS8     0x00000030
+#define CSTOPB    0x00000040
+#define CREAD     0x00000080
+#define PARENB    0x00000100
+#define PARODD    0x00000200
+#define HUPCL     0x00000400
+#define CLOCAL    0x00000800
+#define CBAUDEX   0x00001000
+/* We'll never see these speeds with the Zilogs, but for completeness... */
+#define  BOTHER   0x00001000
+#define  B57600   0x00001001
+#define  B115200  0x00001002
+#define  B230400  0x00001003
+#define  B460800  0x00001004
+/* This is what we can do with the Zilogs. */
+#define  B76800   0x00001005
+/* This is what we can do with the SAB82532. */
+#define  B153600  0x00001006
+#define  B307200  0x00001007
+#define  B614400  0x00001008
+#define  B921600  0x00001009
+/* And these are the rest... */
+#define  B500000  0x0000100a
+#define  B576000  0x0000100b
+#define B1000000  0x0000100c
+#define B1152000  0x0000100d
+#define B1500000  0x0000100e
+#define B2000000  0x0000100f
+/* These have totally bogus values and nobody uses them
+   so far. Later on we'd have to use say 0x10000x and
+   adjust CBAUD constant and drivers accordingly.
+#define B2500000  0x00001010
+#define B3000000  0x00001011
+#define B3500000  0x00001012
+#define B4000000  0x00001013  */
+#define CIBAUD    0x100f0000  /* input baud rate (not used) */
+#define CMSPAR    0x40000000  /* mark or space (stick) parity */
+#define CRTSCTS   0x80000000  /* flow control */
+
+#define IBSHIFT   16            /* Shift from CBAUD to CIBAUD */
+
+/* c_lflag bits */
+#define ISIG    0x00000001
+#define ICANON  0x00000002
+#define XCASE   0x00000004
+#define ECHO    0x00000008
+#define ECHOE   0x00000010
+#define ECHOK   0x00000020
+#define ECHONL  0x00000040
+#define NOFLSH  0x00000080
+#define TOSTOP  0x00000100
+#define ECHOCTL 0x00000200
+#define ECHOPRT 0x00000400
+#define ECHOKE  0x00000800
+#define DEFECHO 0x00001000  /* SUNOS thing, what is it? */
+#define FLUSHO  0x00002000
+#define PENDIN  0x00004000
+#define IEXTEN  0x00008000
+#define EXTPROC 0x00010000
+
+/* modem lines */
+#define TIOCM_LE        0x001
+#define TIOCM_DTR       0x002
+#define TIOCM_RTS       0x004
+#define TIOCM_ST        0x008
+#define TIOCM_SR        0x010
+#define TIOCM_CTS       0x020
+#define TIOCM_CAR       0x040
+#define TIOCM_RNG       0x080
+#define TIOCM_DSR       0x100
+#define TIOCM_CD        TIOCM_CAR
+#define TIOCM_RI        TIOCM_RNG
+#define TIOCM_OUT1      0x2000
+#define TIOCM_OUT2      0x4000
+#define TIOCM_LOOP      0x8000
+
+/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
+#define TIOCSER_TEMT    0x01    /* Transmitter physically empty */
+
+
+/* tcflow() and TCXONC use these */
+#define TCOOFF          0
+#define TCOON           1
+#define TCIOFF          2
+#define TCION           3
+
+/* tcflush() and TCFLSH use these */
+#define TCIFLUSH        0
+#define TCOFLUSH        1
+#define TCIOFLUSH       2
+
+/* tcsetattr uses these */
+#define TCSANOW         0
+#define TCSADRAIN       1
+#define TCSAFLUSH       2
+
+#endif /* _UAPI_SPARC_TERMBITS_H */
diff --git a/arch/sparc/include/uapi/asm/termios.h b/arch/sparc/include/uapi/asm/termios.h
new file mode 100644
index 000000000000..ea6f09e51e53
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/termios.h
@@ -0,0 +1,43 @@
+#ifndef _UAPI_SPARC_TERMIOS_H
+#define _UAPI_SPARC_TERMIOS_H
+
+#include <asm/ioctls.h>
+#include <asm/termbits.h>
+
+#if defined(__KERNEL__) || defined(__DEFINE_BSD_TERMIOS)
+struct sgttyb {
+        char    sg_ispeed;
+        char    sg_ospeed;
+        char    sg_erase;
+        char    sg_kill;
+        short   sg_flags;
+};
+
+struct tchars {
+        char    t_intrc;
+        char    t_quitc;
+        char    t_startc;
+        char    t_stopc;
+        char    t_eofc;
+        char    t_brkc;
+};
+
+struct ltchars {
+        char    t_suspc;
+        char    t_dsuspc;
+        char    t_rprntc;
+        char    t_flushc;
+        char    t_werasc;
+        char    t_lnextc;
+};
+#endif /* __KERNEL__ */
+
+struct winsize {
+        unsigned short ws_row;
+        unsigned short ws_col;
+        unsigned short ws_xpixel;
+        unsigned short ws_ypixel;
+};
+
+
+#endif /* _UAPI_SPARC_TERMIOS_H */
diff --git a/arch/sparc/include/uapi/asm/traps.h b/arch/sparc/include/uapi/asm/traps.h
new file mode 100644
index 000000000000..a4eceace6ccf
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/traps.h
@@ -0,0 +1,120 @@
+/*
+ * traps.h:  Format of entries for the Sparc trap table.
+ *
+ * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
+ */
+
+#ifndef _UAPI_SPARC_TRAPS_H
+#define _UAPI_SPARC_TRAPS_H
+
+#define NUM_SPARC_TRAPS  255
+
+#ifndef __ASSEMBLY__
+#endif /* !(__ASSEMBLY__) */
+
+/* For patching the trap table at boot time, we need to know how to
+ * form various common Sparc instructions.  Thus these macros...
+ */
+
+#define SPARC_MOV_CONST_L3(const) (0xa6102000 | (const&0xfff))
+
+/* The following assumes that the branch lies before the place we
+ * are branching to.  This is the case for a trap vector...
+ * You have been warned.
+ */
+#define SPARC_BRANCH(dest_addr, inst_addr) \
+          (0x10800000 | (((dest_addr-inst_addr)>>2)&0x3fffff))
+
+#define SPARC_RD_PSR_L0  (0xa1480000)
+#define SPARC_RD_WIM_L3  (0xa7500000)
+#define SPARC_NOP (0x01000000)
+
+/* Various interesting trap levels. */
+/* First, hardware traps. */
+#define SP_TRAP_TFLT    0x1          /* Text fault */
+#define SP_TRAP_II      0x2          /* Illegal Instruction */
+#define SP_TRAP_PI      0x3          /* Privileged Instruction */
+#define SP_TRAP_FPD     0x4          /* Floating Point Disabled */
+#define SP_TRAP_WOVF    0x5          /* Window Overflow */
+#define SP_TRAP_WUNF    0x6          /* Window Underflow */
+#define SP_TRAP_MNA     0x7          /* Memory Address Unaligned */
+#define SP_TRAP_FPE     0x8          /* Floating Point Exception */
+#define SP_TRAP_DFLT    0x9          /* Data Fault */
+#define SP_TRAP_TOF     0xa          /* Tag Overflow */
+#define SP_TRAP_WDOG    0xb          /* Watchpoint Detected */
+#define SP_TRAP_IRQ1    0x11         /* IRQ level 1 */
+#define SP_TRAP_IRQ2    0x12         /* IRQ level 2 */
+#define SP_TRAP_IRQ3    0x13         /* IRQ level 3 */
+#define SP_TRAP_IRQ4    0x14         /* IRQ level 4 */
+#define SP_TRAP_IRQ5    0x15         /* IRQ level 5 */
+#define SP_TRAP_IRQ6    0x16         /* IRQ level 6 */
+#define SP_TRAP_IRQ7    0x17         /* IRQ level 7 */
+#define SP_TRAP_IRQ8    0x18         /* IRQ level 8 */
+#define SP_TRAP_IRQ9    0x19         /* IRQ level 9 */
+#define SP_TRAP_IRQ10   0x1a         /* IRQ level 10 */
+#define SP_TRAP_IRQ11   0x1b         /* IRQ level 11 */
+#define SP_TRAP_IRQ12   0x1c         /* IRQ level 12 */
+#define SP_TRAP_IRQ13   0x1d         /* IRQ level 13 */
+#define SP_TRAP_IRQ14   0x1e         /* IRQ level 14 */
+#define SP_TRAP_IRQ15   0x1f         /* IRQ level 15 Non-maskable */
+#define SP_TRAP_RACC    0x20         /* Register Access Error ??? */
+#define SP_TRAP_IACC    0x21         /* Instruction Access Error */
+#define SP_TRAP_CPDIS   0x24         /* Co-Processor Disabled */
+#define SP_TRAP_BADFL   0x25         /* Unimplemented Flush Instruction */
+#define SP_TRAP_CPEXP   0x28         /* Co-Processor Exception */
+#define SP_TRAP_DACC    0x29         /* Data Access Error */
+#define SP_TRAP_DIVZ    0x2a         /* Divide By Zero */
+#define SP_TRAP_DSTORE  0x2b         /* Data Store Error ??? */
+#define SP_TRAP_DMM     0x2c         /* Data Access MMU Miss ??? */
+#define SP_TRAP_IMM     0x3c         /* Instruction Access MMU Miss ??? */
+
+/* Now the Software Traps... */
+#define SP_TRAP_SUNOS   0x80         /* SunOS System Call */
+#define SP_TRAP_SBPT    0x81         /* Software Breakpoint */
+#define SP_TRAP_SDIVZ   0x82         /* Software Divide-by-Zero trap */
+#define SP_TRAP_FWIN    0x83         /* Flush Windows */
+#define SP_TRAP_CWIN    0x84         /* Clean Windows */
+#define SP_TRAP_RCHK    0x85         /* Range Check */
+#define SP_TRAP_FUNA    0x86         /* Fix Unaligned Access */
+#define SP_TRAP_IOWFL   0x87         /* Integer Overflow */
+#define SP_TRAP_SOLARIS 0x88         /* Solaris System Call */
+#define SP_TRAP_NETBSD  0x89         /* NetBSD System Call */
+#define SP_TRAP_LINUX   0x90         /* Linux System Call */
+
+/* Names used for compatibility with SunOS */
+#define ST_SYSCALL              0x00
+#define ST_BREAKPOINT           0x01
+#define ST_DIV0                 0x02
+#define ST_FLUSH_WINDOWS        0x03
+#define ST_CLEAN_WINDOWS        0x04
+#define ST_RANGE_CHECK          0x05
+#define ST_FIX_ALIGN            0x06
+#define ST_INT_OVERFLOW         0x07
+
+/* Special traps... */
+#define SP_TRAP_KBPT1   0xfe         /* KADB/PROM Breakpoint one */
+#define SP_TRAP_KBPT2   0xff         /* KADB/PROM Breakpoint two */
+
+/* Handy Macros */
+/* Is this a trap we never expect to get? */
+#define BAD_TRAP_P(level) \
+        ((level > SP_TRAP_WDOG && level < SP_TRAP_IRQ1) || \
+         (level > SP_TRAP_IACC && level < SP_TRAP_CPDIS) || \
+         (level > SP_TRAP_BADFL && level < SP_TRAP_CPEXP) || \
+         (level > SP_TRAP_DMM && level < SP_TRAP_IMM) || \
+         (level > SP_TRAP_IMM && level < SP_TRAP_SUNOS) || \
+         (level > SP_TRAP_LINUX && level < SP_TRAP_KBPT1))
+
+/* Is this a Hardware trap? */
+#define HW_TRAP_P(level) ((level > 0) && (level < SP_TRAP_SUNOS))
+
+/* Is this a Software trap? */
+#define SW_TRAP_P(level) ((level >= SP_TRAP_SUNOS) && (level <= SP_TRAP_KBPT2))
+
+/* Is this a system call for some OS we know about? */
+#define SCALL_TRAP_P(level) ((level == SP_TRAP_SUNOS) || \
+                             (level == SP_TRAP_SOLARIS) || \
+                             (level == SP_TRAP_NETBSD) || \
+                             (level == SP_TRAP_LINUX))
+
+#endif /* _UAPI_SPARC_TRAPS_H */
diff --git a/arch/sparc/include/asm/types.h b/arch/sparc/include/uapi/asm/types.h
index 383d156cde9c..383d156cde9c 100644
--- a/arch/sparc/include/asm/types.h
+++ b/arch/sparc/include/uapi/asm/types.h
diff --git a/arch/sparc/include/asm/uctx.h b/arch/sparc/include/uapi/asm/uctx.h
index dc937c75ffdd..dc937c75ffdd 100644
--- a/arch/sparc/include/asm/uctx.h
+++ b/arch/sparc/include/uapi/asm/uctx.h
diff --git a/arch/sparc/include/uapi/asm/unistd.h b/arch/sparc/include/uapi/asm/unistd.h
new file mode 100644
index 000000000000..8974ef7ae920
--- /dev/null
+++ b/arch/sparc/include/uapi/asm/unistd.h
@@ -0,0 +1,422 @@
+/*
+ * System calls under the Sparc.
+ *
+ * Don't be scared by the ugly clobbers, it is the only way I can
+ * think of right now to force the arguments into fixed registers
+ * before the trap into the system call with gcc 'asm' statements.
+ *
+ * Copyright (C) 1995, 2007 David S. Miller (davem@davemloft.net)
+ *
+ * SunOS compatibility based upon preliminary work which is:
+ *
+ * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)
+ */
+#ifndef _UAPI_SPARC_UNISTD_H
+#define _UAPI_SPARC_UNISTD_H
+
+#ifndef __32bit_syscall_numbers__
+#ifndef __arch64__
+#define __32bit_syscall_numbers__
+#endif
+#endif
+
+#define __NR_restart_syscall      0 /* Linux Specific                              */
+#define __NR_exit                 1 /* Common                                      */
+#define __NR_fork                 2 /* Common                                      */
+#define __NR_read                 3 /* Common                                      */
+#define __NR_write                4 /* Common                                      */
+#define __NR_open                 5 /* Common                                      */
+#define __NR_close                6 /* Common                                      */
+#define __NR_wait4                7 /* Common                                      */
+#define __NR_creat                8 /* Common                                      */
+#define __NR_link                 9 /* Common                                      */
+#define __NR_unlink              10 /* Common                                      */
+#define __NR_execv               11 /* SunOS Specific                              */
+#define __NR_chdir               12 /* Common                                      */
+#define __NR_chown               13 /* Common                                      */
+#define __NR_mknod               14 /* Common                                      */
+#define __NR_chmod               15 /* Common                                      */
+#define __NR_lchown              16 /* Common                                      */
+#define __NR_brk                 17 /* Common                                      */
+#define __NR_perfctr             18 /* Performance counter operations              */
+#define __NR_lseek               19 /* Common                                      */
+#define __NR_getpid              20 /* Common                                      */
+#define __NR_capget              21 /* Linux Specific                              */
+#define __NR_capset              22 /* Linux Specific                              */
+#define __NR_setuid              23 /* Implemented via setreuid in SunOS           */
+#define __NR_getuid              24 /* Common                                      */
+#define __NR_vmsplice            25 /* ENOSYS under SunOS                          */
+#define __NR_ptrace              26 /* Common                                      */
+#define __NR_alarm               27 /* Implemented via setitimer in SunOS          */
+#define __NR_sigaltstack         28 /* Common                                      */
+#define __NR_pause               29 /* Is sigblock(0)->sigpause() in SunOS         */
+#define __NR_utime               30 /* Implemented via utimes() under SunOS        */
+#ifdef __32bit_syscall_numbers__
+#define __NR_lchown32            31 /* Linux sparc32 specific                      */
+#define __NR_fchown32            32 /* Linux sparc32 specific                      */
+#endif
+#define __NR_access              33 /* Common                                      */
+#define __NR_nice                34 /* Implemented via get/setpriority() in SunOS  */
+#ifdef __32bit_syscall_numbers__
+#define __NR_chown32             35 /* Linux sparc32 specific                      */
+#endif
+#define __NR_sync                36 /* Common                                      */
+#define __NR_kill                37 /* Common                                      */
+#define __NR_stat                38 /* Common                                      */
+#define __NR_sendfile            39 /* Linux Specific                              */
+#define __NR_lstat               40 /* Common                                      */
+#define __NR_dup                 41 /* Common                                      */
+#define __NR_pipe                42 /* Common                                      */
+#define __NR_times               43 /* Implemented via getrusage() in SunOS        */
+#ifdef __32bit_syscall_numbers__
+#define __NR_getuid32            44 /* Linux sparc32 specific                      */
+#endif
+#define __NR_umount2             45 /* Linux Specific                              */
+#define __NR_setgid              46 /* Implemented via setregid() in SunOS         */
+#define __NR_getgid              47 /* Common                                      */
+#define __NR_signal              48 /* Implemented via sigvec() in SunOS           */
+#define __NR_geteuid             49 /* SunOS calls getuid()                        */
+#define __NR_getegid             50 /* SunOS calls getgid()                        */
+#define __NR_acct                51 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_getgid32            53 /* Linux sparc32 specific                      */
+#else
+#define __NR_memory_ordering     52 /* Linux Specific                              */
+#endif
+#define __NR_ioctl               54 /* Common                                      */
+#define __NR_reboot              55 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_mmap2               56 /* Linux sparc32 Specific                      */
+#endif
+#define __NR_symlink             57 /* Common                                      */
+#define __NR_readlink            58 /* Common                                      */
+#define __NR_execve              59 /* Common                                      */
+#define __NR_umask               60 /* Common                                      */
+#define __NR_chroot              61 /* Common                                      */
+#define __NR_fstat               62 /* Common                                      */
+#define __NR_fstat64             63 /* Linux Specific                              */
+#define __NR_getpagesize         64 /* Common                                      */
+#define __NR_msync               65 /* Common in newer 1.3.x revs...               */
+#define __NR_vfork               66 /* Common                                      */
+#define __NR_pread64             67 /* Linux Specific                              */
+#define __NR_pwrite64            68 /* Linux Specific                              */
+#ifdef __32bit_syscall_numbers__
+#define __NR_geteuid32           69 /* Linux sparc32, sbrk under SunOS             */
+#define __NR_getegid32           70 /* Linux sparc32, sstk under SunOS             */
+#endif
+#define __NR_mmap                71 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setreuid32          72 /* Linux sparc32, vadvise under SunOS          */
+#endif
+#define __NR_munmap              73 /* Common                                      */
+#define __NR_mprotect            74 /* Common                                      */
+#define __NR_madvise             75 /* Common                                      */
+#define __NR_vhangup             76 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_truncate64          77 /* Linux sparc32 Specific                      */
+#endif
+#define __NR_mincore             78 /* Common                                      */
+#define __NR_getgroups           79 /* Common                                      */
+#define __NR_setgroups           80 /* Common                                      */
+#define __NR_getpgrp             81 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setgroups32         82 /* Linux sparc32, setpgrp under SunOS          */
+#endif
+#define __NR_setitimer           83 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_ftruncate64         84 /* Linux sparc32 Specific                      */
+#endif
+#define __NR_swapon              85 /* Common                                      */
+#define __NR_getitimer           86 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setuid32            87 /* Linux sparc32, gethostname under SunOS      */
+#endif
+#define __NR_sethostname         88 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setgid32            89 /* Linux sparc32, getdtablesize under SunOS    */
+#endif
+#define __NR_dup2                90 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setfsuid32          91 /* Linux sparc32, getdopt under SunOS          */
+#endif
+#define __NR_fcntl               92 /* Common                                      */
+#define __NR_select              93 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setfsgid32          94 /* Linux sparc32, setdopt under SunOS          */
+#endif
+#define __NR_fsync               95 /* Common                                      */
+#define __NR_setpriority         96 /* Common                                      */
+#define __NR_socket              97 /* Common                                      */
+#define __NR_connect             98 /* Common                                      */
+#define __NR_accept              99 /* Common                                      */
+#define __NR_getpriority        100 /* Common                                      */
+#define __NR_rt_sigreturn       101 /* Linux Specific                              */
+#define __NR_rt_sigaction       102 /* Linux Specific                              */
+#define __NR_rt_sigprocmask     103 /* Linux Specific                              */
+#define __NR_rt_sigpending      104 /* Linux Specific                              */
+#define __NR_rt_sigtimedwait    105 /* Linux Specific                              */
+#define __NR_rt_sigqueueinfo    106 /* Linux Specific                              */
+#define __NR_rt_sigsuspend      107 /* Linux Specific                              */
+#ifdef __32bit_syscall_numbers__
+#define __NR_setresuid32        108 /* Linux Specific, sigvec under SunOS          */
+#define __NR_getresuid32        109 /* Linux Specific, sigblock under SunOS        */
+#define __NR_setresgid32        110 /* Linux Specific, sigsetmask under SunOS      */
+#define __NR_getresgid32        111 /* Linux Specific, sigpause under SunOS        */
+#define __NR_setregid32         112 /* Linux sparc32, sigstack under SunOS         */
+#else
+#define __NR_setresuid          108 /* Linux Specific, sigvec under SunOS          */
+#define __NR_getresuid          109 /* Linux Specific, sigblock under SunOS        */
+#define __NR_setresgid          110 /* Linux Specific, sigsetmask under SunOS      */
+#define __NR_getresgid          111 /* Linux Specific, sigpause under SunOS        */
+#endif
+#define __NR_recvmsg            113 /* Common                                      */
+#define __NR_sendmsg            114 /* Common                                      */
+#ifdef __32bit_syscall_numbers__
+#define __NR_getgroups32        115 /* Linux sparc32, vtrace under SunOS           */
+#endif
+#define __NR_gettimeofday       116 /* Common                                      */
+#define __NR_getrusage          117 /* Common                                      */
+#define __NR_getsockopt         118 /* Common                                      */
+#define __NR_getcwd             119 /* Linux Specific                              */
+#define __NR_readv              120 /* Common                                      */
+#define __NR_writev             121 /* Common                                      */
+#define __NR_settimeofday       122 /* Common                                      */
+#define __NR_fchown             123 /* Common                                      */
+#define __NR_fchmod             124 /* Common                                      */
+#define __NR_recvfrom           125 /* Common                                      */
+#define __NR_setreuid           126 /* Common                                      */
+#define __NR_setregid           127 /* Common                                      */
+#define __NR_rename             128 /* Common                                      */
+#define __NR_truncate           129 /* Common                                      */
+#define __NR_ftruncate          130 /* Common                                      */
+#define __NR_flock              131 /* Common                                      */
+#define __NR_lstat64            132 /* Linux Specific                              */
+#define __NR_sendto             133 /* Common                                      */
+#define __NR_shutdown           134 /* Common                                      */
+#define __NR_socketpair         135 /* Common                                      */
+#define __NR_mkdir              136 /* Common                                      */
+#define __NR_rmdir              137 /* Common                                      */
+#define __NR_utimes             138 /* SunOS Specific                              */
+#define __NR_stat64             139 /* Linux Specific                              */
+#define __NR_sendfile64         140 /* adjtime under SunOS                         */
+#define __NR_getpeername        141 /* Common                                      */
+#define __NR_futex              142 /* gethostid under SunOS                       */
+#define __NR_gettid             143 /* ENOSYS under SunOS                          */
+#define __NR_getrlimit          144 /* Common                                      */
+#define __NR_setrlimit          145 /* Common                                      */
+#define __NR_pivot_root         146 /* Linux Specific, killpg under SunOS          */
+#define __NR_prctl              147 /* ENOSYS under SunOS                          */
+#define __NR_pciconfig_read     148 /* ENOSYS under SunOS                          */
+#define __NR_pciconfig_write    149 /* ENOSYS under SunOS                          */
+#define __NR_getsockname        150 /* Common                                      */
+#define __NR_inotify_init       151 /* Linux specific                              */
+#define __NR_inotify_add_watch  152 /* Linux specific                              */
+#define __NR_poll               153 /* Common                                      */
+#define __NR_getdents64         154 /* Linux specific                              */
+#ifdef __32bit_syscall_numbers__
+#define __NR_fcntl64            155 /* Linux sparc32 Specific                      */
+#endif
+#define __NR_inotify_rm_watch   156 /* Linux specific                              */
+#define __NR_statfs             157 /* Common                                      */
+#define __NR_fstatfs            158 /* Common                                      */
+#define __NR_umount             159 /* Common                                      */
+#define __NR_sched_set_affinity 160 /* Linux specific, async_daemon under SunOS    */
+#define __NR_sched_get_affinity 161 /* Linux specific, getfh under SunOS           */
+#define __NR_getdomainname      162 /* SunOS Specific                              */
+#define __NR_setdomainname      163 /* Common                                      */
+#ifndef __32bit_syscall_numbers__
+#define __NR_utrap_install      164 /* SYSV ABI/v9 required                        */
+#endif
+#define __NR_quotactl           165 /* Common                                      */
+#define __NR_set_tid_address    166 /* Linux specific, exportfs under SunOS        */
+#define __NR_mount              167 /* Common                                      */
+#define __NR_ustat              168 /* Common                                      */
+#define __NR_setxattr           169 /* SunOS: semsys                               */
+#define __NR_lsetxattr          170 /* SunOS: msgsys                               */
+#define __NR_fsetxattr          171 /* SunOS: shmsys                               */
+#define __NR_getxattr           172 /* SunOS: auditsys                             */
+#define __NR_lgetxattr          173 /* SunOS: rfssys                               */
+#define __NR_getdents           174 /* Common                                      */
+#define __NR_setsid             175 /* Common                                      */
+#define __NR_fchdir             176 /* Common                                      */
+#define __NR_fgetxattr          177 /* SunOS: fchroot                              */
+#define __NR_listxattr          178 /* SunOS: vpixsys                              */
+#define __NR_llistxattr         179 /* SunOS: aioread                              */
+#define __NR_flistxattr         180 /* SunOS: aiowrite                             */
+#define __NR_removexattr        181 /* SunOS: aiowait                              */
+#define __NR_lremovexattr       182 /* SunOS: aiocancel                            */
+#define __NR_sigpending         183 /* Common                                      */
+#define __NR_query_module       184 /* Linux Specific                              */
+#define __NR_setpgid            185 /* Common                                      */
+#define __NR_fremovexattr       186 /* SunOS: pathconf                             */
+#define __NR_tkill              187 /* SunOS: fpathconf                            */
+#define __NR_exit_group         188 /* Linux specific, sysconf undef SunOS         */
+#define __NR_uname              189 /* Linux Specific                              */
+#define __NR_init_module        190 /* Linux Specific                              */
+#define __NR_personality        191 /* Linux Specific                              */
+#define __NR_remap_file_pages   192 /* Linux Specific                              */
+#define __NR_epoll_create       193 /* Linux Specific                              */
+#define __NR_epoll_ctl          194 /* Linux Specific                              */
+#define __NR_epoll_wait         195 /* Linux Specific                              */
+#define __NR_ioprio_set         196 /* Linux Specific                              */
+#define __NR_getppid            197 /* Linux Specific                              */
+#define __NR_sigaction          198 /* Linux Specific                              */
+#define __NR_sgetmask           199 /* Linux Specific                              */
+#define __NR_ssetmask           200 /* Linux Specific                              */
+#define __NR_sigsuspend         201 /* Linux Specific                              */
+#define __NR_oldlstat           202 /* Linux Specific                              */
+#define __NR_uselib             203 /* Linux Specific                              */
+#define __NR_readdir            204 /* Linux Specific                              */
+#define __NR_readahead          205 /* Linux Specific                              */
+#define __NR_socketcall         206 /* Linux Specific                              */
+#define __NR_syslog             207 /* Linux Specific                              */
+#define __NR_lookup_dcookie     208 /* Linux Specific                              */
+#define __NR_fadvise64          209 /* Linux Specific                              */
+#define __NR_fadvise64_64       210 /* Linux Specific                              */
+#define __NR_tgkill             211 /* Linux Specific                              */
+#define __NR_waitpid            212 /* Linux Specific                              */
+#define __NR_swapoff            213 /* Linux Specific                              */
+#define __NR_sysinfo            214 /* Linux Specific                              */
+#define __NR_ipc                215 /* Linux Specific                              */
+#define __NR_sigreturn          216 /* Linux Specific                              */
+#define __NR_clone              217 /* Linux Specific                              */
+#define __NR_ioprio_get         218 /* Linux Specific                              */
+#define __NR_adjtimex           219 /* Linux Specific                              */
+#define __NR_sigprocmask        220 /* Linux Specific                              */
+#define __NR_create_module      221 /* Linux Specific                              */
+#define __NR_delete_module      222 /* Linux Specific                              */
+#define __NR_get_kernel_syms    223 /* Linux Specific                              */
+#define __NR_getpgid            224 /* Linux Specific                              */
+#define __NR_bdflush            225 /* Linux Specific                              */
+#define __NR_sysfs              226 /* Linux Specific                              */
+#define __NR_afs_syscall        227 /* Linux Specific                              */
+#define __NR_setfsuid           228 /* Linux Specific                              */
+#define __NR_setfsgid           229 /* Linux Specific                              */
+#define __NR__newselect         230 /* Linux Specific                              */
+#ifdef __32bit_syscall_numbers__
+#define __NR_time               231 /* Linux Specific                              */
+#else
+#endif
+#define __NR_splice             232 /* Linux Specific                              */
+#define __NR_stime              233 /* Linux Specific                              */
+#define __NR_statfs64           234 /* Linux Specific                              */
+#define __NR_fstatfs64          235 /* Linux Specific                              */
+#define __NR__llseek            236 /* Linux Specific                              */
+#define __NR_mlock              237
+#define __NR_munlock            238
+#define __NR_mlockall           239
+#define __NR_munlockall         240
+#define __NR_sched_setparam     241
+#define __NR_sched_getparam     242
+#define __NR_sched_setscheduler 243
+#define __NR_sched_getscheduler 244
+#define __NR_sched_yield        245
+#define __NR_sched_get_priority_max 246
+#define __NR_sched_get_priority_min 247
+#define __NR_sched_rr_get_interval  248
+#define __NR_nanosleep          249
+#define __NR_mremap             250
+#define __NR__sysctl            251
+#define __NR_getsid             252
+#define __NR_fdatasync          253
+#define __NR_nfsservctl         254
+#define __NR_sync_file_range    255
+#define __NR_clock_settime      256
+#define __NR_clock_gettime      257
+#define __NR_clock_getres       258
+#define __NR_clock_nanosleep    259
+#define __NR_sched_getaffinity  260
+#define __NR_sched_setaffinity  261
+#define __NR_timer_settime      262
+#define __NR_timer_gettime      263
+#define __NR_timer_getoverrun   264
+#define __NR_timer_delete       265
+#define __NR_timer_create       266
+/* #define __NR_vserver         267 Reserved for VSERVER */
+#define __NR_io_setup           268
+#define __NR_io_destroy         269
+#define __NR_io_submit          270
+#define __NR_io_cancel          271
+#define __NR_io_getevents       272
+#define __NR_mq_open            273
+#define __NR_mq_unlink          274
+#define __NR_mq_timedsend       275
+#define __NR_mq_timedreceive    276
+#define __NR_mq_notify          277
+#define __NR_mq_getsetattr      278
+#define __NR_waitid             279
+#define __NR_tee                280
+#define __NR_add_key            281
+#define __NR_request_key        282
+#define __NR_keyctl             283
+#define __NR_openat             284
+#define __NR_mkdirat            285
+#define __NR_mknodat            286
+#define __NR_fchownat           287
+#define __NR_futimesat          288
+#define __NR_fstatat64          289
+#define __NR_unlinkat           290
+#define __NR_renameat           291
+#define __NR_linkat             292
+#define __NR_symlinkat          293
+#define __NR_readlinkat         294
+#define __NR_fchmodat           295
+#define __NR_faccessat          296
+#define __NR_pselect6           297
+#define __NR_ppoll              298
+#define __NR_unshare            299
+#define __NR_set_robust_list    300
+#define __NR_get_robust_list    301
+#define __NR_migrate_pages      302
+#define __NR_mbind              303
+#define __NR_get_mempolicy      304
+#define __NR_set_mempolicy      305
+#define __NR_kexec_load         306
+#define __NR_move_pages         307
+#define __NR_getcpu             308
+#define __NR_epoll_pwait        309
+#define __NR_utimensat          310
+#define __NR_signalfd           311
+#define __NR_timerfd_create     312
+#define __NR_eventfd            313
+#define __NR_fallocate          314
+#define __NR_timerfd_settime    315
+#define __NR_timerfd_gettime    316
+#define __NR_signalfd4          317
+#define __NR_eventfd2           318
+#define __NR_epoll_create1      319
+#define __NR_dup3               320
+#define __NR_pipe2              321
+#define __NR_inotify_init1      322
+#define __NR_accept4            323
+#define __NR_preadv             324
+#define __NR_pwritev            325
+#define __NR_rt_tgsigqueueinfo  326
+#define __NR_perf_event_open    327
+#define __NR_recvmmsg           328
+#define __NR_fanotify_init      329
+#define __NR_fanotify_mark      330
+#define __NR_prlimit64          331
+#define __NR_name_to_handle_at  332
+#define __NR_open_by_handle_at  333
+#define __NR_clock_adjtime      334
+#define __NR_syncfs             335
+#define __NR_sendmmsg           336
+#define __NR_setns              337
+#define __NR_process_vm_readv   338
+#define __NR_process_vm_writev  339
+
+#define NR_syscalls             340
+
+#ifdef __32bit_syscall_numbers__
+/* Sparc 32-bit only has the "setresuid32", "getresuid32" variants,
+ * it never had the plain ones and there is no value to adding those
+ * old versions into the syscall table.
+ */
+#define __IGNORE_setresuid
+#define __IGNORE_getresuid
+#define __IGNORE_setresgid
+#define __IGNORE_getresgid
+#endif
+
+#endif /* _UAPI_SPARC_UNISTD_H */
diff --git a/arch/sparc/include/asm/utrap.h b/arch/sparc/include/uapi/asm/utrap.h
index b10e527c22d9..b10e527c22d9 100644
--- a/arch/sparc/include/asm/utrap.h
+++ b/arch/sparc/include/uapi/asm/utrap.h
diff --git a/arch/sparc/include/asm/watchdog.h b/arch/sparc/include/uapi/asm/watchdog.h
index 5baf2d3919cf..5baf2d3919cf 100644
--- a/arch/sparc/include/asm/watchdog.h
+++ b/arch/sparc/include/uapi/asm/watchdog.h
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index d06ea2950dd9..677cd6e4e1a1 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -208,6 +208,16 @@ config SIRF_DMA
         help
           Enable support for the CSR SiRFprimaII DMA engine.
 
+config TI_EDMA
+        tristate "TI EDMA support"
+        depends on ARCH_DAVINCI
+        select DMA_ENGINE
+        select DMA_VIRTUAL_CHANNELS
+        default n
+        help
+          Enable support for the TI EDMA controller. This DMA
+          engine is found on TI DaVinci and AM33xx parts.
+
 config ARCH_HAS_ASYNC_TX_FIND_CHANNEL
         bool
 
@@ -292,6 +302,13 @@ config DMA_OMAP
         select DMA_ENGINE
         select DMA_VIRTUAL_CHANNELS
 
+config MMP_PDMA
+        bool "MMP PDMA support"
+        depends on (ARCH_MMP || ARCH_PXA)
+        select DMA_ENGINE
+        help
+          Support the MMP PDMA engine for PXA and MMP platfrom.
+
 config DMA_ENGINE
         bool
 
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 4cf6b128ab9a..7428feaa8705 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_IMX_DMA) += imx-dma.o
 obj-$(CONFIG_MXS_DMA) += mxs-dma.o
 obj-$(CONFIG_TIMB_DMA) += timb_dma.o
 obj-$(CONFIG_SIRF_DMA) += sirf-dma.o
+obj-$(CONFIG_TI_EDMA) += edma.o
 obj-$(CONFIG_STE_DMA40) += ste_dma40.o ste_dma40_ll.o
 obj-$(CONFIG_TEGRA20_APB_DMA) += tegra20-apb-dma.o
 obj-$(CONFIG_PL330_DMA) += pl330.o
@@ -32,3 +33,4 @@ obj-$(CONFIG_EP93XX_DMA) += ep93xx_dma.o
 obj-$(CONFIG_DMA_SA11X0) += sa11x0-dma.o
 obj-$(CONFIG_MMP_TDMA) += mmp_tdma.o
 obj-$(CONFIG_DMA_OMAP) += omap-dma.o
+obj-$(CONFIG_MMP_PDMA) += mmp_pdma.o
diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index 6fbeebb9486f..d1cc5791476b 100644
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -1892,6 +1892,7 @@ static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
         pl08x->pd = dev_get_platdata(&adev->dev);
         if (!pl08x->pd) {
                 dev_err(&adev->dev, "no platform data supplied\n");
+                ret = -EINVAL;
                 goto out_no_platdata;
         }
 
@@ -1943,6 +1944,7 @@ static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
                 dev_err(&adev->dev, "%s failed to allocate "
                         "physical channel holders\n",
                         __func__);
+                ret = -ENOMEM;
                 goto out_no_phychans;
         }
 
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index d3c5a5a88f1e..c4b0eb3cde81 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -36,12 +36,22 @@
  * which does not support descriptor writeback.
  */
 
+static inline unsigned int dwc_get_dms(struct dw_dma_slave *slave)
+{
+        return slave ? slave->dst_master : 0;
+}
+
+static inline unsigned int dwc_get_sms(struct dw_dma_slave *slave)
+{
+        return slave ? slave->src_master : 1;
+}
+
 #define DWC_DEFAULT_CTLLO(_chan) ({                             \
                 struct dw_dma_slave *__slave = (_chan->private);        \
                 struct dw_dma_chan *_dwc = to_dw_dma_chan(_chan);       \
                 struct dma_slave_config *_sconfig = &_dwc->dma_sconfig; \
-                int _dms = __slave ? __slave->dst_master : 0;   \
-                int _sms = __slave ? __slave->src_master : 1;   \
+                int _dms = dwc_get_dms(__slave);                \
+                int _sms = dwc_get_sms(__slave);                \
                 u8 _smsize = __slave ? _sconfig->src_maxburst : \
                         DW_DMA_MSIZE_16;                        \
                 u8 _dmsize = __slave ? _sconfig->dst_maxburst : \
@@ -56,16 +66,6 @@
         })
 
 /*
- * This is configuration-dependent and usually a funny size like 4095.
- *
- * Note that this is a transfer count, i.e. if we transfer 32-bit
- * words, we can do 16380 bytes per descriptor.
- *
- * This parameter is also system-specific.
- */
-#define DWC_MAX_COUNT   4095U
-
-/*
  * Number of descriptors to allocate for each channel. This should be
  * made configurable somehow; preferably, the clients (at least the
  * ones using slave transfers) should be able to give us a hint.
@@ -177,6 +177,11 @@ static void dwc_initialize(struct dw_dma_chan *dwc)
 
                 cfghi = dws->cfg_hi;
                 cfglo |= dws->cfg_lo & ~DWC_CFGL_CH_PRIOR_MASK;
+        } else {
+                if (dwc->dma_sconfig.direction == DMA_MEM_TO_DEV)
+                        cfghi = DWC_CFGH_DST_PER(dwc->dma_sconfig.slave_id);
+                else if (dwc->dma_sconfig.direction == DMA_DEV_TO_MEM)
+                        cfghi = DWC_CFGH_SRC_PER(dwc->dma_sconfig.slave_id);
         }
 
         channel_writel(dwc, CFG_LO, cfglo);
@@ -206,7 +211,7 @@ static inline unsigned int dwc_fast_fls(unsigned long long v)
         return 0;
 }
 
-static void dwc_dump_chan_regs(struct dw_dma_chan *dwc)
+static inline void dwc_dump_chan_regs(struct dw_dma_chan *dwc)
 {
         dev_err(chan2dev(&dwc->chan),
                 "  SAR: 0x%x DAR: 0x%x LLP: 0x%x CTL: 0x%x:%08x\n",
@@ -227,10 +232,29 @@ static inline void dwc_chan_disable(struct dw_dma *dw, struct dw_dma_chan *dwc)
 
 /*----------------------------------------------------------------------*/
 
+/* Perform single block transfer */
+static inline void dwc_do_single_block(struct dw_dma_chan *dwc,
+                                       struct dw_desc *desc)
+{
+        struct dw_dma   *dw = to_dw_dma(dwc->chan.device);
+        u32             ctllo;
+
+        /* Software emulation of LLP mode relies on interrupts to continue
+         * multi block transfer. */
+        ctllo = desc->lli.ctllo | DWC_CTLL_INT_EN;
+
+        channel_writel(dwc, SAR, desc->lli.sar);
+        channel_writel(dwc, DAR, desc->lli.dar);
+        channel_writel(dwc, CTL_LO, ctllo);
+        channel_writel(dwc, CTL_HI, desc->lli.ctlhi);
+        channel_set_bit(dw, CH_EN, dwc->mask);
+}
+
 /* Called with dwc->lock held and bh disabled */
 static void dwc_dostart(struct dw_dma_chan *dwc, struct dw_desc *first)
 {
         struct dw_dma   *dw = to_dw_dma(dwc->chan.device);
+        unsigned long   was_soft_llp;
 
         /* ASSERT:  channel is idle */
         if (dma_readl(dw, CH_EN) & dwc->mask) {
@@ -242,6 +266,26 @@ static void dwc_dostart(struct dw_dma_chan *dwc, struct dw_desc *first)
                 return;
         }
 
+        if (dwc->nollp) {
+                was_soft_llp = test_and_set_bit(DW_DMA_IS_SOFT_LLP,
+                                                &dwc->flags);
+                if (was_soft_llp) {
+                        dev_err(chan2dev(&dwc->chan),
+                                "BUG: Attempted to start new LLP transfer "
+                                "inside ongoing one\n");
+                        return;
+                }
+
+                dwc_initialize(dwc);
+
+                dwc->tx_list = &first->tx_list;
+                dwc->tx_node_active = first->tx_list.next;
+
+                dwc_do_single_block(dwc, first);
+
+                return;
+        }
+
         dwc_initialize(dwc);
 
         channel_writel(dwc, LLP, first->txd.phys);
@@ -553,8 +597,36 @@ static void dw_dma_tasklet(unsigned long data)
                         dwc_handle_cyclic(dw, dwc, status_err, status_xfer);
                 else if (status_err & (1 << i))
                         dwc_handle_error(dw, dwc);
-                else if (status_xfer & (1 << i))
+                else if (status_xfer & (1 << i)) {
+                        unsigned long flags;
+
+                        spin_lock_irqsave(&dwc->lock, flags);
+                        if (test_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags)) {
+                                if (dwc->tx_node_active != dwc->tx_list) {
+                                        struct dw_desc *desc =
+                                                list_entry(dwc->tx_node_active,
+                                                           struct dw_desc,
+                                                           desc_node);
+
+                                        dma_writel(dw, CLEAR.XFER, dwc->mask);
+
+                                        /* move pointer to next descriptor */
+                                        dwc->tx_node_active =
+                                                dwc->tx_node_active->next;
+
+                                        dwc_do_single_block(dwc, desc);
+
+                                        spin_unlock_irqrestore(&dwc->lock, flags);
+                                        continue;
+                                } else {
+                                        /* we are done here */
+                                        clear_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags);
+                                }
+                        }
+                        spin_unlock_irqrestore(&dwc->lock, flags);
+
                         dwc_scan_descriptors(dw, dwc);
+                }
         }
 
         /*
@@ -636,6 +708,7 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
                 size_t len, unsigned long flags)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
+        struct dw_dma_slave     *dws = chan->private;
         struct dw_desc          *desc;
         struct dw_desc          *first;
         struct dw_desc          *prev;
@@ -643,6 +716,7 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         size_t                  offset;
         unsigned int            src_width;
         unsigned int            dst_width;
+        unsigned int            data_width;
         u32                     ctllo;
 
         dev_vdbg(chan2dev(chan),
@@ -655,7 +729,11 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
                 return NULL;
         }
 
-        src_width = dst_width = dwc_fast_fls(src | dest | len);
+        data_width = min_t(unsigned int, dwc->dw->data_width[dwc_get_sms(dws)],
+                                         dwc->dw->data_width[dwc_get_dms(dws)]);
+
+        src_width = dst_width = min_t(unsigned int, data_width,
+                                      dwc_fast_fls(src | dest | len));
 
         ctllo = DWC_DEFAULT_CTLLO(chan)
                         | DWC_CTLL_DST_WIDTH(dst_width)
@@ -667,7 +745,7 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
 
         for (offset = 0; offset < len; offset += xfer_count << src_width) {
                 xfer_count = min_t(size_t, (len - offset) >> src_width,
-                                DWC_MAX_COUNT);
+                                           dwc->block_size);
 
                 desc = dwc_desc_get(dwc);
                 if (!desc)
@@ -725,6 +803,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         dma_addr_t              reg;
         unsigned int            reg_width;
         unsigned int            mem_width;
+        unsigned int            data_width;
         unsigned int            i;
         struct scatterlist      *sg;
         size_t                  total_len = 0;
@@ -748,6 +827,8 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 ctllo |= sconfig->device_fc ? DWC_CTLL_FC(DW_DMA_FC_P_M2P) :
                         DWC_CTLL_FC(DW_DMA_FC_D_M2P);
 
+                data_width = dwc->dw->data_width[dwc_get_sms(dws)];
+
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
                         u32             len, dlen, mem;
@@ -755,7 +836,8 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                         mem = sg_dma_address(sg);
                         len = sg_dma_len(sg);
 
-                        mem_width = dwc_fast_fls(mem | len);
+                        mem_width = min_t(unsigned int,
+                                          data_width, dwc_fast_fls(mem | len));
 
 slave_sg_todev_fill_desc:
                         desc = dwc_desc_get(dwc);
@@ -768,8 +850,8 @@ slave_sg_todev_fill_desc:
                         desc->lli.sar = mem;
                         desc->lli.dar = reg;
                         desc->lli.ctllo = ctllo | DWC_CTLL_SRC_WIDTH(mem_width);
-                        if ((len >> mem_width) > DWC_MAX_COUNT) {
-                                dlen = DWC_MAX_COUNT << mem_width;
+                        if ((len >> mem_width) > dwc->block_size) {
+                                dlen = dwc->block_size << mem_width;
                                 mem += dlen;
                                 len -= dlen;
                         } else {
@@ -808,6 +890,8 @@ slave_sg_todev_fill_desc:
                 ctllo |= sconfig->device_fc ? DWC_CTLL_FC(DW_DMA_FC_P_P2M) :
                         DWC_CTLL_FC(DW_DMA_FC_D_P2M);
 
+                data_width = dwc->dw->data_width[dwc_get_dms(dws)];
+
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
                         u32             len, dlen, mem;
@@ -815,7 +899,8 @@ slave_sg_todev_fill_desc:
                         mem = sg_dma_address(sg);
                         len = sg_dma_len(sg);
 
-                        mem_width = dwc_fast_fls(mem | len);
+                        mem_width = min_t(unsigned int,
+                                          data_width, dwc_fast_fls(mem | len));
 
 slave_sg_fromdev_fill_desc:
                         desc = dwc_desc_get(dwc);
@@ -828,8 +913,8 @@ slave_sg_fromdev_fill_desc:
                         desc->lli.sar = reg;
                         desc->lli.dar = mem;
                         desc->lli.ctllo = ctllo | DWC_CTLL_DST_WIDTH(mem_width);
-                        if ((len >> reg_width) > DWC_MAX_COUNT) {
-                                dlen = DWC_MAX_COUNT << reg_width;
+                        if ((len >> reg_width) > dwc->block_size) {
+                                dlen = dwc->block_size << reg_width;
                                 mem += dlen;
                                 len -= dlen;
                         } else {
@@ -945,6 +1030,8 @@ static int dwc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         } else if (cmd == DMA_TERMINATE_ALL) {
                 spin_lock_irqsave(&dwc->lock, flags);
 
+                clear_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags);
+
                 dwc_chan_disable(dw, dwc);
 
                 dwc->paused = false;
@@ -1187,6 +1274,13 @@ struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
         unsigned long                   flags;
 
         spin_lock_irqsave(&dwc->lock, flags);
+        if (dwc->nollp) {
+                spin_unlock_irqrestore(&dwc->lock, flags);
+                dev_dbg(chan2dev(&dwc->chan),
+                                "channel doesn't support LLP transfers\n");
+                return ERR_PTR(-EINVAL);
+        }
+
         if (!list_empty(&dwc->queue) || !list_empty(&dwc->active_list)) {
                 spin_unlock_irqrestore(&dwc->lock, flags);
                 dev_dbg(chan2dev(&dwc->chan),
@@ -1212,7 +1306,7 @@ struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
         periods = buf_len / period_len;
 
         /* Check for too big/unaligned periods and unaligned DMA buffer. */
-        if (period_len > (DWC_MAX_COUNT << reg_width))
+        if (period_len > (dwc->block_size << reg_width))
                 goto out_err;
         if (unlikely(period_len & ((1 << reg_width) - 1)))
                 goto out_err;
@@ -1374,6 +1468,11 @@ static int __devinit dw_probe(struct platform_device *pdev)
         struct resource         *io;
         struct dw_dma           *dw;
         size_t                  size;
+        void __iomem            *regs;
+        bool                    autocfg;
+        unsigned int            dw_params;
+        unsigned int            nr_channels;
+        unsigned int            max_blk_size = 0;
         int                     irq;
         int                     err;
         int                     i;
@@ -1390,32 +1489,46 @@ static int __devinit dw_probe(struct platform_device *pdev)
         if (irq < 0)
                 return irq;
 
-        size = sizeof(struct dw_dma);
-        size += pdata->nr_channels * sizeof(struct dw_dma_chan);
-        dw = kzalloc(size, GFP_KERNEL);
+        regs = devm_request_and_ioremap(&pdev->dev, io);
+        if (!regs)
+                return -EBUSY;
+
+        dw_params = dma_read_byaddr(regs, DW_PARAMS);
+        autocfg = dw_params >> DW_PARAMS_EN & 0x1;
+
+        if (autocfg)
+                nr_channels = (dw_params >> DW_PARAMS_NR_CHAN & 0x7) + 1;
+        else
+                nr_channels = pdata->nr_channels;
+
+        size = sizeof(struct dw_dma) + nr_channels * sizeof(struct dw_dma_chan);
+        dw = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
         if (!dw)
                 return -ENOMEM;
 
-        if (!request_mem_region(io->start, DW_REGLEN, pdev->dev.driver->name)) {
-                err = -EBUSY;
-                goto err_kfree;
-        }
+        dw->clk = devm_clk_get(&pdev->dev, "hclk");
+        if (IS_ERR(dw->clk))
+                return PTR_ERR(dw->clk);
+        clk_prepare_enable(dw->clk);
 
-        dw->regs = ioremap(io->start, DW_REGLEN);
-        if (!dw->regs) {
-                err = -ENOMEM;
-                goto err_release_r;
-        }
+        dw->regs = regs;
+
+        /* get hardware configuration parameters */
+        if (autocfg) {
+                max_blk_size = dma_readl(dw, MAX_BLK_SIZE);
 
-        dw->clk = clk_get(&pdev->dev, "hclk");
-        if (IS_ERR(dw->clk)) {
-                err = PTR_ERR(dw->clk);
-                goto err_clk;
+                dw->nr_masters = (dw_params >> DW_PARAMS_NR_MASTER & 3) + 1;
+                for (i = 0; i < dw->nr_masters; i++) {
+                        dw->data_width[i] =
+                                (dw_params >> DW_PARAMS_DATA_WIDTH(i) & 3) + 2;
+                }
+        } else {
+                dw->nr_masters = pdata->nr_masters;
+                memcpy(dw->data_width, pdata->data_width, 4);
         }
-        clk_prepare_enable(dw->clk);
 
         /* Calculate all channel mask before DMA setup */
-        dw->all_chan_mask = (1 << pdata->nr_channels) - 1;
+        dw->all_chan_mask = (1 << nr_channels) - 1;
 
         /* force dma off, just in case */
         dw_dma_off(dw);
@@ -1423,17 +1536,19 @@ static int __devinit dw_probe(struct platform_device *pdev)
         /* disable BLOCK interrupts as well */
         channel_clear_bit(dw, MASK.BLOCK, dw->all_chan_mask);
 
-        err = request_irq(irq, dw_dma_interrupt, 0, "dw_dmac", dw);
+        err = devm_request_irq(&pdev->dev, irq, dw_dma_interrupt, 0,
+                               "dw_dmac", dw);
         if (err)
-                goto err_irq;
+                return err;
 
         platform_set_drvdata(pdev, dw);
 
         tasklet_init(&dw->tasklet, dw_dma_tasklet, (unsigned long)dw);
 
         INIT_LIST_HEAD(&dw->dma.channels);
-        for (i = 0; i < pdata->nr_channels; i++) {
+        for (i = 0; i < nr_channels; i++) {
                 struct dw_dma_chan      *dwc = &dw->chan[i];
+                int                     r = nr_channels - i - 1;
 
                 dwc->chan.device = &dw->dma;
                 dma_cookie_init(&dwc->chan);
@@ -1445,7 +1560,7 @@ static int __devinit dw_probe(struct platform_device *pdev)
 
                 /* 7 is highest priority & 0 is lowest. */
                 if (pdata->chan_priority == CHAN_PRIORITY_ASCENDING)
-                        dwc->priority = pdata->nr_channels - i - 1;
+                        dwc->priority = r;
                 else
                         dwc->priority = i;
 
@@ -1458,6 +1573,32 @@ static int __devinit dw_probe(struct platform_device *pdev)
                 INIT_LIST_HEAD(&dwc->free_list);
 
                 channel_clear_bit(dw, CH_EN, dwc->mask);
+
+                dwc->dw = dw;
+
+                /* hardware configuration */
+                if (autocfg) {
+                        unsigned int dwc_params;
+
+                        dwc_params = dma_read_byaddr(regs + r * sizeof(u32),
+                                                     DWC_PARAMS);
+
+                        /* Decode maximum block size for given channel. The
+                         * stored 4 bit value represents blocks from 0x00 for 3
+                         * up to 0x0a for 4095. */
+                        dwc->block_size =
+                                (4 << ((max_blk_size >> 4 * i) & 0xf)) - 1;
+                        dwc->nollp =
+                                (dwc_params >> DWC_PARAMS_MBLK_EN & 0x1) == 0;
+                } else {
+                        dwc->block_size = pdata->block_size;
+
+                        /* Check if channel supports multi block transfer */
+                        channel_writel(dwc, LLP, 0xfffffffc);
+                        dwc->nollp =
+                                (channel_readl(dwc, LLP) & 0xfffffffc) == 0;
+                        channel_writel(dwc, LLP, 0);
+                }
         }
 
         /* Clear all interrupts on all channels. */
@@ -1486,35 +1627,21 @@ static int __devinit dw_probe(struct platform_device *pdev)
         dma_writel(dw, CFG, DW_CFG_DMA_EN);
 
         printk(KERN_INFO "%s: DesignWare DMA Controller, %d channels\n",
-                        dev_name(&pdev->dev), pdata->nr_channels);
+                        dev_name(&pdev->dev), nr_channels);
 
         dma_async_device_register(&dw->dma);
 
         return 0;
-
-err_irq:
-        clk_disable_unprepare(dw->clk);
-        clk_put(dw->clk);
-err_clk:
-        iounmap(dw->regs);
-        dw->regs = NULL;
-err_release_r:
-        release_resource(io);
-err_kfree:
-        kfree(dw);
-        return err;
 }
 
 static int __devexit dw_remove(struct platform_device *pdev)
 {
         struct dw_dma           *dw = platform_get_drvdata(pdev);
         struct dw_dma_chan      *dwc, *_dwc;
-        struct resource         *io;
 
         dw_dma_off(dw);
         dma_async_device_unregister(&dw->dma);
 
-        free_irq(platform_get_irq(pdev, 0), dw);
         tasklet_kill(&dw->tasklet);
 
         list_for_each_entry_safe(dwc, _dwc, &dw->dma.channels,
@@ -1523,17 +1650,6 @@ static int __devexit dw_remove(struct platform_device *pdev)
                 channel_clear_bit(dw, CH_EN, dwc->mask);
         }
 
-        clk_disable_unprepare(dw->clk);
-        clk_put(dw->clk);
-
-        iounmap(dw->regs);
-        dw->regs = NULL;
-
-        io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(io->start, DW_REGLEN);
-
-        kfree(dw);
-
         return 0;
 }
 
diff --git a/drivers/dma/dw_dmac_regs.h b/drivers/dma/dw_dmac_regs.h
index 50830bee087a..ff39fa6cd2bc 100644
--- a/drivers/dma/dw_dmac_regs.h
+++ b/drivers/dma/dw_dmac_regs.h
@@ -82,9 +82,39 @@ struct dw_dma_regs {
         DW_REG(ID);
         DW_REG(TEST);
 
+        /* reserved */
+        DW_REG(__reserved0);
+        DW_REG(__reserved1);
+
         /* optional encoded params, 0x3c8..0x3f7 */
+        u32     __reserved;
+
+        /* per-channel configuration registers */
+        u32     DWC_PARAMS[DW_DMA_MAX_NR_CHANNELS];
+        u32     MULTI_BLK_TYPE;
+        u32     MAX_BLK_SIZE;
+
+        /* top-level parameters */
+        u32     DW_PARAMS;
 };
 
+/* To access the registers in early stage of probe */
+#define dma_read_byaddr(addr, name) \
+        readl((addr) + offsetof(struct dw_dma_regs, name))
+
+/* Bitfields in DW_PARAMS */
+#define DW_PARAMS_NR_CHAN       8               /* number of channels */
+#define DW_PARAMS_NR_MASTER     11              /* number of AHB masters */
+#define DW_PARAMS_DATA_WIDTH(n) (15 + 2 * (n))
+#define DW_PARAMS_DATA_WIDTH1   15              /* master 1 data width */
+#define DW_PARAMS_DATA_WIDTH2   17              /* master 2 data width */
+#define DW_PARAMS_DATA_WIDTH3   19              /* master 3 data width */
+#define DW_PARAMS_DATA_WIDTH4   21              /* master 4 data width */
+#define DW_PARAMS_EN            28              /* encoded parameters */
+
+/* Bitfields in DWC_PARAMS */
+#define DWC_PARAMS_MBLK_EN      11              /* multi block transfer */
+
 /* Bitfields in CTL_LO */
 #define DWC_CTLL_INT_EN         (1 << 0)        /* irqs enabled? */
 #define DWC_CTLL_DST_WIDTH(n)   ((n)<<1)        /* bytes per element */
@@ -140,10 +170,9 @@ struct dw_dma_regs {
 /* Bitfields in CFG */
 #define DW_CFG_DMA_EN           (1 << 0)
 
-#define DW_REGLEN               0x400
-
 enum dw_dmac_flags {
         DW_DMA_IS_CYCLIC = 0,
+        DW_DMA_IS_SOFT_LLP = 1,
 };
 
 struct dw_dma_chan {
@@ -154,6 +183,10 @@ struct dw_dma_chan {
         bool                    paused;
         bool                    initialized;
 
+        /* software emulation of the LLP transfers */
+        struct list_head        *tx_list;
+        struct list_head        *tx_node_active;
+
         spinlock_t              lock;
 
         /* these other elements are all protected by lock */
@@ -165,8 +198,15 @@ struct dw_dma_chan {
 
         unsigned int            descs_allocated;
 
+        /* hardware configuration */
+        unsigned int            block_size;
+        bool                    nollp;
+
         /* configuration passed via DMA_SLAVE_CONFIG */
         struct dma_slave_config dma_sconfig;
+
+        /* backlink to dw_dma */
+        struct dw_dma           *dw;
 };
 
 static inline struct dw_dma_chan_regs __iomem *
@@ -193,6 +233,10 @@ struct dw_dma {
 
         u8                      all_chan_mask;
 
+        /* hardware configuration */
+        unsigned char           nr_masters;
+        unsigned char           data_width[4];
+
         struct dw_dma_chan      chan[0];
 };
 
diff --git a/drivers/dma/edma.c b/drivers/dma/edma.c
new file mode 100644
index 000000000000..05aea3ce8506
--- /dev/null
+++ b/drivers/dma/edma.c
@@ -0,0 +1,671 @@
+/*
+ * TI EDMA DMA engine driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include <mach/edma.h>
+
+#include "dmaengine.h"
+#include "virt-dma.h"
+
+/*
+ * This will go away when the private EDMA API is folded
+ * into this driver and the platform device(s) are
+ * instantiated in the arch code. We can only get away
+ * with this simplification because DA8XX may not be built
+ * in the same kernel image with other DaVinci parts. This
+ * avoids having to sprinkle dmaengine driver platform devices
+ * and data throughout all the existing board files.
+ */
+#ifdef CONFIG_ARCH_DAVINCI_DA8XX
+#define EDMA_CTLRS      2
+#define EDMA_CHANS      32
+#else
+#define EDMA_CTLRS      1
+#define EDMA_CHANS      64
+#endif /* CONFIG_ARCH_DAVINCI_DA8XX */
+
+/* Max of 16 segments per channel to conserve PaRAM slots */
+#define MAX_NR_SG               16
+#define EDMA_MAX_SLOTS          MAX_NR_SG
+#define EDMA_DESCRIPTORS        16
+
+struct edma_desc {
+        struct virt_dma_desc            vdesc;
+        struct list_head                node;
+        int                             absync;
+        int                             pset_nr;
+        struct edmacc_param             pset[0];
+};
+
+struct edma_cc;
+
+struct edma_chan {
+        struct virt_dma_chan            vchan;
+        struct list_head                node;
+        struct edma_desc                *edesc;
+        struct edma_cc                  *ecc;
+        int                             ch_num;
+        bool                            alloced;
+        int                             slot[EDMA_MAX_SLOTS];
+        dma_addr_t                      addr;
+        int                             addr_width;
+        int                             maxburst;
+};
+
+struct edma_cc {
+        int                             ctlr;
+        struct dma_device               dma_slave;
+        struct edma_chan                slave_chans[EDMA_CHANS];
+        int                             num_slave_chans;
+        int                             dummy_slot;
+};
+
+static inline struct edma_cc *to_edma_cc(struct dma_device *d)
+{
+        return container_of(d, struct edma_cc, dma_slave);
+}
+
+static inline struct edma_chan *to_edma_chan(struct dma_chan *c)
+{
+        return container_of(c, struct edma_chan, vchan.chan);
+}
+
+static inline struct edma_desc
+*to_edma_desc(struct dma_async_tx_descriptor *tx)
+{
+        return container_of(tx, struct edma_desc, vdesc.tx);
+}
+
+static void edma_desc_free(struct virt_dma_desc *vdesc)
+{
+        kfree(container_of(vdesc, struct edma_desc, vdesc));
+}
+
+/* Dispatch a queued descriptor to the controller (caller holds lock) */
+static void edma_execute(struct edma_chan *echan)
+{
+        struct virt_dma_desc *vdesc = vchan_next_desc(&echan->vchan);
+        struct edma_desc *edesc;
+        int i;
+
+        if (!vdesc) {
+                echan->edesc = NULL;
+                return;
+        }
+
+        list_del(&vdesc->node);
+
+        echan->edesc = edesc = to_edma_desc(&vdesc->tx);
+
+        /* Write descriptor PaRAM set(s) */
+        for (i = 0; i < edesc->pset_nr; i++) {
+                edma_write_slot(echan->slot[i], &edesc->pset[i]);
+                dev_dbg(echan->vchan.chan.device->dev,
+                        "\n pset[%d]:\n"
+                        "  chnum\t%d\n"
+                        "  slot\t%d\n"
+                        "  opt\t%08x\n"
+                        "  src\t%08x\n"
+                        "  dst\t%08x\n"
+                        "  abcnt\t%08x\n"
+                        "  ccnt\t%08x\n"
+                        "  bidx\t%08x\n"
+                        "  cidx\t%08x\n"
+                        "  lkrld\t%08x\n",
+                        i, echan->ch_num, echan->slot[i],
+                        edesc->pset[i].opt,
+                        edesc->pset[i].src,
+                        edesc->pset[i].dst,
+                        edesc->pset[i].a_b_cnt,
+                        edesc->pset[i].ccnt,
+                        edesc->pset[i].src_dst_bidx,
+                        edesc->pset[i].src_dst_cidx,
+                        edesc->pset[i].link_bcntrld);
+                /* Link to the previous slot if not the last set */
+                if (i != (edesc->pset_nr - 1))
+                        edma_link(echan->slot[i], echan->slot[i+1]);
+                /* Final pset links to the dummy pset */
+                else
+                        edma_link(echan->slot[i], echan->ecc->dummy_slot);
+        }
+
+        edma_start(echan->ch_num);
+}
+
+static int edma_terminate_all(struct edma_chan *echan)
+{
+        unsigned long flags;
+        LIST_HEAD(head);
+
+        spin_lock_irqsave(&echan->vchan.lock, flags);
+
+        /*
+         * Stop DMA activity: we assume the callback will not be called
+         * after edma_dma() returns (even if it does, it will see
+         * echan->edesc is NULL and exit.)
+         */
+        if (echan->edesc) {
+                echan->edesc = NULL;
+                edma_stop(echan->ch_num);
+        }
+
+        vchan_get_all_descriptors(&echan->vchan, &head);
+        spin_unlock_irqrestore(&echan->vchan.lock, flags);
+        vchan_dma_desc_free_list(&echan->vchan, &head);
+
+        return 0;
+}
+
+
+static int edma_slave_config(struct edma_chan *echan,
+        struct dma_slave_config *config)
+{
+        if ((config->src_addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES) ||
+            (config->dst_addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES))
+                return -EINVAL;
+
+        if (config->direction == DMA_MEM_TO_DEV) {
+                if (config->dst_addr)
+                        echan->addr = config->dst_addr;
+                if (config->dst_addr_width)
+                        echan->addr_width = config->dst_addr_width;
+                if (config->dst_maxburst)
+                        echan->maxburst = config->dst_maxburst;
+        } else if (config->direction == DMA_DEV_TO_MEM) {
+                if (config->src_addr)
+                        echan->addr = config->src_addr;
+                if (config->src_addr_width)
+                        echan->addr_width = config->src_addr_width;
+                if (config->src_maxburst)
+                        echan->maxburst = config->src_maxburst;
+        }
+
+        return 0;
+}
+
+static int edma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
+                        unsigned long arg)
+{
+        int ret = 0;
+        struct dma_slave_config *config;
+        struct edma_chan *echan = to_edma_chan(chan);
+
+        switch (cmd) {
+        case DMA_TERMINATE_ALL:
+                edma_terminate_all(echan);
+                break;
+        case DMA_SLAVE_CONFIG:
+                config = (struct dma_slave_config *)arg;
+                ret = edma_slave_config(echan, config);
+                break;
+        default:
+                ret = -ENOSYS;
+        }
+
+        return ret;
+}
+
+static struct dma_async_tx_descriptor *edma_prep_slave_sg(
+        struct dma_chan *chan, struct scatterlist *sgl,
+        unsigned int sg_len, enum dma_transfer_direction direction,
+        unsigned long tx_flags, void *context)
+{
+        struct edma_chan *echan = to_edma_chan(chan);
+        struct device *dev = chan->device->dev;
+        struct edma_desc *edesc;
+        struct scatterlist *sg;
+        int i;
+        int acnt, bcnt, ccnt, src, dst, cidx;
+        int src_bidx, dst_bidx, src_cidx, dst_cidx;
+
+        if (unlikely(!echan || !sgl || !sg_len))
+                return NULL;
+
+        if (echan->addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED) {
+                dev_err(dev, "Undefined slave buswidth\n");
+                return NULL;
+        }
+
+        if (sg_len > MAX_NR_SG) {
+                dev_err(dev, "Exceeded max SG segments %d > %d\n",
+                        sg_len, MAX_NR_SG);
+                return NULL;
+        }
+
+        edesc = kzalloc(sizeof(*edesc) + sg_len *
+                sizeof(edesc->pset[0]), GFP_ATOMIC);
+        if (!edesc) {
+                dev_dbg(dev, "Failed to allocate a descriptor\n");
+                return NULL;
+        }
+
+        edesc->pset_nr = sg_len;
+
+        for_each_sg(sgl, sg, sg_len, i) {
+                /* Allocate a PaRAM slot, if needed */
+                if (echan->slot[i] < 0) {
+                        echan->slot[i] =
+                                edma_alloc_slot(EDMA_CTLR(echan->ch_num),
+                                                EDMA_SLOT_ANY);
+                        if (echan->slot[i] < 0) {
+                                dev_err(dev, "Failed to allocate slot\n");
+                                return NULL;
+                        }
+                }
+
+                acnt = echan->addr_width;
+
+                /*
+                 * If the maxburst is equal to the fifo width, use
+                 * A-synced transfers. This allows for large contiguous
+                 * buffer transfers using only one PaRAM set.
+                 */
+                if (echan->maxburst == 1) {
+                        edesc->absync = false;
+                        ccnt = sg_dma_len(sg) / acnt / (SZ_64K - 1);
+                        bcnt = sg_dma_len(sg) / acnt - ccnt * (SZ_64K - 1);
+                        if (bcnt)
+                                ccnt++;
+                        else
+                                bcnt = SZ_64K - 1;
+                        cidx = acnt;
+                /*
+                 * If maxburst is greater than the fifo address_width,
+                 * use AB-synced transfers where A count is the fifo
+                 * address_width and B count is the maxburst. In this
+                 * case, we are limited to transfers of C count frames
+                 * of (address_width * maxburst) where C count is limited
+                 * to SZ_64K-1. This places an upper bound on the length
+                 * of an SG segment that can be handled.
+                 */
+                } else {
+                        edesc->absync = true;
+                        bcnt = echan->maxburst;
+                        ccnt = sg_dma_len(sg) / (acnt * bcnt);
+                        if (ccnt > (SZ_64K - 1)) {
+                                dev_err(dev, "Exceeded max SG segment size\n");
+                                return NULL;
+                        }
+                        cidx = acnt * bcnt;
+                }
+
+                if (direction == DMA_MEM_TO_DEV) {
+                        src = sg_dma_address(sg);
+                        dst = echan->addr;
+                        src_bidx = acnt;
+                        src_cidx = cidx;
+                        dst_bidx = 0;
+                        dst_cidx = 0;
+                } else {
+                        src = echan->addr;
+                        dst = sg_dma_address(sg);
+                        src_bidx = 0;
+                        src_cidx = 0;
+                        dst_bidx = acnt;
+                        dst_cidx = cidx;
+                }
+
+                edesc->pset[i].opt = EDMA_TCC(EDMA_CHAN_SLOT(echan->ch_num));
+                /* Configure A or AB synchronized transfers */
+                if (edesc->absync)
+                        edesc->pset[i].opt |= SYNCDIM;
+                /* If this is the last set, enable completion interrupt flag */
+                if (i == sg_len - 1)
+                        edesc->pset[i].opt |= TCINTEN;
+
+                edesc->pset[i].src = src;
+                edesc->pset[i].dst = dst;
+
+                edesc->pset[i].src_dst_bidx = (dst_bidx << 16) | src_bidx;
+                edesc->pset[i].src_dst_cidx = (dst_cidx << 16) | src_cidx;
+
+                edesc->pset[i].a_b_cnt = bcnt << 16 | acnt;
+                edesc->pset[i].ccnt = ccnt;
+                edesc->pset[i].link_bcntrld = 0xffffffff;
+
+        }
+
+        return vchan_tx_prep(&echan->vchan, &edesc->vdesc, tx_flags);
+}
+
+static void edma_callback(unsigned ch_num, u16 ch_status, void *data)
+{
+        struct edma_chan *echan = data;
+        struct device *dev = echan->vchan.chan.device->dev;
+        struct edma_desc *edesc;
+        unsigned long flags;
+
+        /* Stop the channel */
+        edma_stop(echan->ch_num);
+
+        switch (ch_status) {
+        case DMA_COMPLETE:
+                dev_dbg(dev, "transfer complete on channel %d\n", ch_num);
+
+                spin_lock_irqsave(&echan->vchan.lock, flags);
+
+                edesc = echan->edesc;
+                if (edesc) {
+                        edma_execute(echan);
+                        vchan_cookie_complete(&edesc->vdesc);
+                }
+
+                spin_unlock_irqrestore(&echan->vchan.lock, flags);
+
+                break;
+        case DMA_CC_ERROR:
+                dev_dbg(dev, "transfer error on channel %d\n", ch_num);
+                break;
+        default:
+                break;
+        }
+}
+
+/* Alloc channel resources */
+static int edma_alloc_chan_resources(struct dma_chan *chan)
+{
+        struct edma_chan *echan = to_edma_chan(chan);
+        struct device *dev = chan->device->dev;
+        int ret;
+        int a_ch_num;
+        LIST_HEAD(descs);
+
+        a_ch_num = edma_alloc_channel(echan->ch_num, edma_callback,
+                                        chan, EVENTQ_DEFAULT);
+
+        if (a_ch_num < 0) {
+                ret = -ENODEV;
+                goto err_no_chan;
+        }
+
+        if (a_ch_num != echan->ch_num) {
+                dev_err(dev, "failed to allocate requested channel %u:%u\n",
+                        EDMA_CTLR(echan->ch_num),
+                        EDMA_CHAN_SLOT(echan->ch_num));
+                ret = -ENODEV;
+                goto err_wrong_chan;
+        }
+
+        echan->alloced = true;
+        echan->slot[0] = echan->ch_num;
+
+        dev_info(dev, "allocated channel for %u:%u\n",
+                 EDMA_CTLR(echan->ch_num), EDMA_CHAN_SLOT(echan->ch_num));
+
+        return 0;
+
+err_wrong_chan:
+        edma_free_channel(a_ch_num);
+err_no_chan:
+        return ret;
+}
+
+/* Free channel resources */
+static void edma_free_chan_resources(struct dma_chan *chan)
+{
+        struct edma_chan *echan = to_edma_chan(chan);
+        struct device *dev = chan->device->dev;
+        int i;
+
+        /* Terminate transfers */
+        edma_stop(echan->ch_num);
+
+        vchan_free_chan_resources(&echan->vchan);
+
+        /* Free EDMA PaRAM slots */
+        for (i = 1; i < EDMA_MAX_SLOTS; i++) {
+                if (echan->slot[i] >= 0) {
+                        edma_free_slot(echan->slot[i]);
+                        echan->slot[i] = -1;
+                }
+        }
+
+        /* Free EDMA channel */
+        if (echan->alloced) {
+                edma_free_channel(echan->ch_num);
+                echan->alloced = false;
+        }
+
+        dev_info(dev, "freeing channel for %u\n", echan->ch_num);
+}
+
+/* Send pending descriptor to hardware */
+static void edma_issue_pending(struct dma_chan *chan)
+{
+        struct edma_chan *echan = to_edma_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&echan->vchan.lock, flags);
+        if (vchan_issue_pending(&echan->vchan) && !echan->edesc)
+                edma_execute(echan);
+        spin_unlock_irqrestore(&echan->vchan.lock, flags);
+}
+
+static size_t edma_desc_size(struct edma_desc *edesc)
+{
+        int i;
+        size_t size;
+
+        if (edesc->absync)
+                for (size = i = 0; i < edesc->pset_nr; i++)
+                        size += (edesc->pset[i].a_b_cnt & 0xffff) *
+                                (edesc->pset[i].a_b_cnt >> 16) *
+                                 edesc->pset[i].ccnt;
+        else
+                size = (edesc->pset[0].a_b_cnt & 0xffff) *
+                        (edesc->pset[0].a_b_cnt >> 16) +
+                        (edesc->pset[0].a_b_cnt & 0xffff) *
+                        (SZ_64K - 1) * edesc->pset[0].ccnt;
+
+        return size;
+}
+
+/* Check request completion status */
+static enum dma_status edma_tx_status(struct dma_chan *chan,
+                                      dma_cookie_t cookie,
+                                      struct dma_tx_state *txstate)
+{
+        struct edma_chan *echan = to_edma_chan(chan);
+        struct virt_dma_desc *vdesc;
+        enum dma_status ret;
+        unsigned long flags;
+
+        ret = dma_cookie_status(chan, cookie, txstate);
+        if (ret == DMA_SUCCESS || !txstate)
+                return ret;
+
+        spin_lock_irqsave(&echan->vchan.lock, flags);
+        vdesc = vchan_find_desc(&echan->vchan, cookie);
+        if (vdesc) {
+                txstate->residue = edma_desc_size(to_edma_desc(&vdesc->tx));
+        } else if (echan->edesc && echan->edesc->vdesc.tx.cookie == cookie) {
+                struct edma_desc *edesc = echan->edesc;
+                txstate->residue = edma_desc_size(edesc);
+        } else {
+                txstate->residue = 0;
+        }
+        spin_unlock_irqrestore(&echan->vchan.lock, flags);
+
+        return ret;
+}
+
+static void __init edma_chan_init(struct edma_cc *ecc,
+                                  struct dma_device *dma,
+                                  struct edma_chan *echans)
+{
+        int i, j;
+
+        for (i = 0; i < EDMA_CHANS; i++) {
+                struct edma_chan *echan = &echans[i];
+                echan->ch_num = EDMA_CTLR_CHAN(ecc->ctlr, i);
+                echan->ecc = ecc;
+                echan->vchan.desc_free = edma_desc_free;
+
+                vchan_init(&echan->vchan, dma);
+
+                INIT_LIST_HEAD(&echan->node);
+                for (j = 0; j < EDMA_MAX_SLOTS; j++)
+                        echan->slot[j] = -1;
+        }
+}
+
+static void edma_dma_init(struct edma_cc *ecc, struct dma_device *dma,
+                          struct device *dev)
+{
+        dma->device_prep_slave_sg = edma_prep_slave_sg;
+        dma->device_alloc_chan_resources = edma_alloc_chan_resources;
+        dma->device_free_chan_resources = edma_free_chan_resources;
+        dma->device_issue_pending = edma_issue_pending;
+        dma->device_tx_status = edma_tx_status;
+        dma->device_control = edma_control;
+        dma->dev = dev;
+
+        INIT_LIST_HEAD(&dma->channels);
+}
+
+static int __devinit edma_probe(struct platform_device *pdev)
+{
+        struct edma_cc *ecc;
+        int ret;
+
+        ecc = devm_kzalloc(&pdev->dev, sizeof(*ecc), GFP_KERNEL);
+        if (!ecc) {
+                dev_err(&pdev->dev, "Can't allocate controller\n");
+                return -ENOMEM;
+        }
+
+        ecc->ctlr = pdev->id;
+        ecc->dummy_slot = edma_alloc_slot(ecc->ctlr, EDMA_SLOT_ANY);
+        if (ecc->dummy_slot < 0) {
+                dev_err(&pdev->dev, "Can't allocate PaRAM dummy slot\n");
+                return -EIO;
+        }
+
+        dma_cap_zero(ecc->dma_slave.cap_mask);
+        dma_cap_set(DMA_SLAVE, ecc->dma_slave.cap_mask);
+
+        edma_dma_init(ecc, &ecc->dma_slave, &pdev->dev);
+
+        edma_chan_init(ecc, &ecc->dma_slave, ecc->slave_chans);
+
+        ret = dma_async_device_register(&ecc->dma_slave);
+        if (ret)
+                goto err_reg1;
+
+        platform_set_drvdata(pdev, ecc);
+
+        dev_info(&pdev->dev, "TI EDMA DMA engine driver\n");
+
+        return 0;
+
+err_reg1:
+        edma_free_slot(ecc->dummy_slot);
+        return ret;
+}
+
+static int __devexit edma_remove(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct edma_cc *ecc = dev_get_drvdata(dev);
+
+        dma_async_device_unregister(&ecc->dma_slave);
+        edma_free_slot(ecc->dummy_slot);
+
+        return 0;
+}
+
+static struct platform_driver edma_driver = {
+        .probe          = edma_probe,
+        .remove         = __devexit_p(edma_remove),
+        .driver = {
+                .name = "edma-dma-engine",
+                .owner = THIS_MODULE,
+        },
+};
+
+bool edma_filter_fn(struct dma_chan *chan, void *param)
+{
+        if (chan->device->dev->driver == &edma_driver.driver) {
+                struct edma_chan *echan = to_edma_chan(chan);
+                unsigned ch_req = *(unsigned *)param;
+                return ch_req == echan->ch_num;
+        }
+        return false;
+}
+EXPORT_SYMBOL(edma_filter_fn);
+
+static struct platform_device *pdev0, *pdev1;
+
+static const struct platform_device_info edma_dev_info0 = {
+        .name = "edma-dma-engine",
+        .id = 0,
+        .dma_mask = DMA_BIT_MASK(32),
+};
+
+static const struct platform_device_info edma_dev_info1 = {
+        .name = "edma-dma-engine",
+        .id = 1,
+        .dma_mask = DMA_BIT_MASK(32),
+};
+
+static int edma_init(void)
+{
+        int ret = platform_driver_register(&edma_driver);
+
+        if (ret == 0) {
+                pdev0 = platform_device_register_full(&edma_dev_info0);
+                if (IS_ERR(pdev0)) {
+                        platform_driver_unregister(&edma_driver);
+                        ret = PTR_ERR(pdev0);
+                        goto out;
+                }
+        }
+
+        if (EDMA_CTLRS == 2) {
+                pdev1 = platform_device_register_full(&edma_dev_info1);
+                if (IS_ERR(pdev1)) {
+                        platform_driver_unregister(&edma_driver);
+                        platform_device_unregister(pdev0);
+                        ret = PTR_ERR(pdev1);
+                }
+        }
+
+out:
+        return ret;
+}
+subsys_initcall(edma_init);
+
+static void __exit edma_exit(void)
+{
+        platform_device_unregister(pdev0);
+        if (pdev1)
+                platform_device_unregister(pdev1);
+        platform_driver_unregister(&edma_driver);
+}
+module_exit(edma_exit);
+
+MODULE_AUTHOR("Matt Porter <mporter@ti.com>");
+MODULE_DESCRIPTION("TI EDMA DMA engine driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
index 86895760b598..b9d667851445 100644
--- a/drivers/dma/ioat/dma_v2.c
+++ b/drivers/dma/ioat/dma_v2.c
@@ -434,12 +434,11 @@ static struct ioat_ring_ent *ioat2_alloc_ring_ent(struct dma_chan *chan, gfp_t f
                 return NULL;
         memset(hw, 0, sizeof(*hw));
 
-        desc = kmem_cache_alloc(ioat2_cache, flags);
+        desc = kmem_cache_zalloc(ioat2_cache, flags);
         if (!desc) {
                 pci_pool_free(dma->dma_pool, hw, phys);
                 return NULL;
         }
-        memset(desc, 0, sizeof(*desc));
 
         dma_async_tx_descriptor_init(&desc->txd, chan);
         desc->txd.tx_submit = ioat2_tx_submit_unlock;
diff --git a/drivers/dma/ioat/pci.c b/drivers/dma/ioat/pci.c
index 5e3a40f79945..c0573061b45d 100644
--- a/drivers/dma/ioat/pci.c
+++ b/drivers/dma/ioat/pci.c
@@ -40,6 +40,17 @@ MODULE_VERSION(IOAT_DMA_VERSION);
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Intel Corporation");
 
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB0   0x0e20
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB1   0x0e21
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB2   0x0e22
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB3   0x0e23
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB4   0x0e24
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB5   0x0e25
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB6   0x0e26
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB7   0x0e27
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB8   0x0e2e
+#define PCI_DEVICE_ID_INTEL_IOAT_IVB9   0x0e2f
+
 static struct pci_device_id ioat_pci_tbl[] = {
         /* I/OAT v1 platforms */
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT) },
@@ -83,6 +94,17 @@ static struct pci_device_id ioat_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB8) },
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB9) },
 
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB0) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB1) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB2) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB3) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB4) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB5) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB6) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB7) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB8) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB9) },
+
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, ioat_pci_tbl);
diff --git a/drivers/dma/mmp_pdma.c b/drivers/dma/mmp_pdma.c
new file mode 100644
index 000000000000..14da1f403edf
--- /dev/null
+++ b/drivers/dma/mmp_pdma.c
@@ -0,0 +1,875 @@
+/*
+ * Copyright 2012 Marvell International Ltd.
+ *
+ * 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/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+#include <linux/dmaengine.h>
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/platform_data/mmp_dma.h>
+#include <linux/dmapool.h>
+#include <linux/of_device.h>
+#include <linux/of.h>
+
+#include "dmaengine.h"
+
+#define DCSR            0x0000
+#define DALGN           0x00a0
+#define DINT            0x00f0
+#define DDADR           0x0200
+#define DSADR           0x0204
+#define DTADR           0x0208
+#define DCMD            0x020c
+
+#define DCSR_RUN        (1 << 31)       /* Run Bit (read / write) */
+#define DCSR_NODESC     (1 << 30)       /* No-Descriptor Fetch (read / write) */
+#define DCSR_STOPIRQEN  (1 << 29)       /* Stop Interrupt Enable (read / write) */
+#define DCSR_REQPEND    (1 << 8)        /* Request Pending (read-only) */
+#define DCSR_STOPSTATE  (1 << 3)        /* Stop State (read-only) */
+#define DCSR_ENDINTR    (1 << 2)        /* End Interrupt (read / write) */
+#define DCSR_STARTINTR  (1 << 1)        /* Start Interrupt (read / write) */
+#define DCSR_BUSERR     (1 << 0)        /* Bus Error Interrupt (read / write) */
+
+#define DCSR_EORIRQEN   (1 << 28)       /* End of Receive Interrupt Enable (R/W) */
+#define DCSR_EORJMPEN   (1 << 27)       /* Jump to next descriptor on EOR */
+#define DCSR_EORSTOPEN  (1 << 26)       /* STOP on an EOR */
+#define DCSR_SETCMPST   (1 << 25)       /* Set Descriptor Compare Status */
+#define DCSR_CLRCMPST   (1 << 24)       /* Clear Descriptor Compare Status */
+#define DCSR_CMPST      (1 << 10)       /* The Descriptor Compare Status */
+#define DCSR_EORINTR    (1 << 9)        /* The end of Receive */
+
+#define DRCMR_MAPVLD    (1 << 7)        /* Map Valid (read / write) */
+#define DRCMR_CHLNUM    0x1f            /* mask for Channel Number (read / write) */
+
+#define DDADR_DESCADDR  0xfffffff0      /* Address of next descriptor (mask) */
+#define DDADR_STOP      (1 << 0)        /* Stop (read / write) */
+
+#define DCMD_INCSRCADDR (1 << 31)       /* Source Address Increment Setting. */
+#define DCMD_INCTRGADDR (1 << 30)       /* Target Address Increment Setting. */
+#define DCMD_FLOWSRC    (1 << 29)       /* Flow Control by the source. */
+#define DCMD_FLOWTRG    (1 << 28)       /* Flow Control by the target. */
+#define DCMD_STARTIRQEN (1 << 22)       /* Start Interrupt Enable */
+#define DCMD_ENDIRQEN   (1 << 21)       /* End Interrupt Enable */
+#define DCMD_ENDIAN     (1 << 18)       /* Device Endian-ness. */
+#define DCMD_BURST8     (1 << 16)       /* 8 byte burst */
+#define DCMD_BURST16    (2 << 16)       /* 16 byte burst */
+#define DCMD_BURST32    (3 << 16)       /* 32 byte burst */
+#define DCMD_WIDTH1     (1 << 14)       /* 1 byte width */
+#define DCMD_WIDTH2     (2 << 14)       /* 2 byte width (HalfWord) */
+#define DCMD_WIDTH4     (3 << 14)       /* 4 byte width (Word) */
+#define DCMD_LENGTH     0x01fff         /* length mask (max = 8K - 1) */
+
+#define PDMA_ALIGNMENT          3
+#define PDMA_MAX_DESC_BYTES     0x1000
+
+struct mmp_pdma_desc_hw {
+        u32 ddadr;      /* Points to the next descriptor + flags */
+        u32 dsadr;      /* DSADR value for the current transfer */
+        u32 dtadr;      /* DTADR value for the current transfer */
+        u32 dcmd;       /* DCMD value for the current transfer */
+} __aligned(32);
+
+struct mmp_pdma_desc_sw {
+        struct mmp_pdma_desc_hw desc;
+        struct list_head node;
+        struct list_head tx_list;
+        struct dma_async_tx_descriptor async_tx;
+};
+
+struct mmp_pdma_phy;
+
+struct mmp_pdma_chan {
+        struct device *dev;
+        struct dma_chan chan;
+        struct dma_async_tx_descriptor desc;
+        struct mmp_pdma_phy *phy;
+        enum dma_transfer_direction dir;
+
+        /* channel's basic info */
+        struct tasklet_struct tasklet;
+        u32 dcmd;
+        u32 drcmr;
+        u32 dev_addr;
+
+        /* list for desc */
+        spinlock_t desc_lock;           /* Descriptor list lock */
+        struct list_head chain_pending; /* Link descriptors queue for pending */
+        struct list_head chain_running; /* Link descriptors queue for running */
+        bool idle;                      /* channel statue machine */
+
+        struct dma_pool *desc_pool;     /* Descriptors pool */
+};
+
+struct mmp_pdma_phy {
+        int idx;
+        void __iomem *base;
+        struct mmp_pdma_chan *vchan;
+};
+
+struct mmp_pdma_device {
+        int                             dma_channels;
+        void __iomem                    *base;
+        struct device                   *dev;
+        struct dma_device               device;
+        struct mmp_pdma_phy             *phy;
+};
+
+#define tx_to_mmp_pdma_desc(tx) container_of(tx, struct mmp_pdma_desc_sw, async_tx)
+#define to_mmp_pdma_desc(lh) container_of(lh, struct mmp_pdma_desc_sw, node)
+#define to_mmp_pdma_chan(dchan) container_of(dchan, struct mmp_pdma_chan, chan)
+#define to_mmp_pdma_dev(dmadev) container_of(dmadev, struct mmp_pdma_device, device)
+
+static void set_desc(struct mmp_pdma_phy *phy, dma_addr_t addr)
+{
+        u32 reg = (phy->idx << 4) + DDADR;
+
+        writel(addr, phy->base + reg);
+}
+
+static void enable_chan(struct mmp_pdma_phy *phy)
+{
+        u32 reg;
+
+        if (!phy->vchan)
+                return;
+
+        reg = phy->vchan->drcmr;
+        reg = (((reg) < 64) ? 0x0100 : 0x1100) + (((reg) & 0x3f) << 2);
+        writel(DRCMR_MAPVLD | phy->idx, phy->base + reg);
+
+        reg = (phy->idx << 2) + DCSR;
+        writel(readl(phy->base + reg) | DCSR_RUN,
+                                        phy->base + reg);
+}
+
+static void disable_chan(struct mmp_pdma_phy *phy)
+{
+        u32 reg;
+
+        if (phy) {
+                reg = (phy->idx << 2) + DCSR;
+                writel(readl(phy->base + reg) & ~DCSR_RUN,
+                                                phy->base + reg);
+        }
+}
+
+static int clear_chan_irq(struct mmp_pdma_phy *phy)
+{
+        u32 dcsr;
+        u32 dint = readl(phy->base + DINT);
+        u32 reg = (phy->idx << 2) + DCSR;
+
+        if (dint & BIT(phy->idx)) {
+                /* clear irq */
+                dcsr = readl(phy->base + reg);
+                writel(dcsr, phy->base + reg);
+                if ((dcsr & DCSR_BUSERR) && (phy->vchan))
+                        dev_warn(phy->vchan->dev, "DCSR_BUSERR\n");
+                return 0;
+        }
+        return -EAGAIN;
+}
+
+static irqreturn_t mmp_pdma_chan_handler(int irq, void *dev_id)
+{
+        struct mmp_pdma_phy *phy = dev_id;
+
+        if (clear_chan_irq(phy) == 0) {
+                tasklet_schedule(&phy->vchan->tasklet);
+                return IRQ_HANDLED;
+        } else
+                return IRQ_NONE;
+}
+
+static irqreturn_t mmp_pdma_int_handler(int irq, void *dev_id)
+{
+        struct mmp_pdma_device *pdev = dev_id;
+        struct mmp_pdma_phy *phy;
+        u32 dint = readl(pdev->base + DINT);
+        int i, ret;
+        int irq_num = 0;
+
+        while (dint) {
+                i = __ffs(dint);
+                dint &= (dint - 1);
+                phy = &pdev->phy[i];
+                ret = mmp_pdma_chan_handler(irq, phy);
+                if (ret == IRQ_HANDLED)
+                        irq_num++;
+        }
+
+        if (irq_num)
+                return IRQ_HANDLED;
+        else
+                return IRQ_NONE;
+}
+
+/* lookup free phy channel as descending priority */
+static struct mmp_pdma_phy *lookup_phy(struct mmp_pdma_chan *pchan)
+{
+        int prio, i;
+        struct mmp_pdma_device *pdev = to_mmp_pdma_dev(pchan->chan.device);
+        struct mmp_pdma_phy *phy;
+
+        /*
+         * dma channel priorities
+         * ch 0 - 3,  16 - 19  <--> (0)
+         * ch 4 - 7,  20 - 23  <--> (1)
+         * ch 8 - 11, 24 - 27  <--> (2)
+         * ch 12 - 15, 28 - 31  <--> (3)
+         */
+        for (prio = 0; prio <= (((pdev->dma_channels - 1) & 0xf) >> 2); prio++) {
+                for (i = 0; i < pdev->dma_channels; i++) {
+                        if (prio != ((i & 0xf) >> 2))
+                                continue;
+                        phy = &pdev->phy[i];
+                        if (!phy->vchan) {
+                                phy->vchan = pchan;
+                                return phy;
+                        }
+                }
+        }
+
+        return NULL;
+}
+
+/* desc->tx_list ==> pending list */
+static void append_pending_queue(struct mmp_pdma_chan *chan,
+                                        struct mmp_pdma_desc_sw *desc)
+{
+        struct mmp_pdma_desc_sw *tail =
+                                to_mmp_pdma_desc(chan->chain_pending.prev);
+
+        if (list_empty(&chan->chain_pending))
+                goto out_splice;
+
+        /* one irq per queue, even appended */
+        tail->desc.ddadr = desc->async_tx.phys;
+        tail->desc.dcmd &= ~DCMD_ENDIRQEN;
+
+        /* softly link to pending list */
+out_splice:
+        list_splice_tail_init(&desc->tx_list, &chan->chain_pending);
+}
+
+/**
+ * start_pending_queue - transfer any pending transactions
+ * pending list ==> running list
+ */
+static void start_pending_queue(struct mmp_pdma_chan *chan)
+{
+        struct mmp_pdma_desc_sw *desc;
+
+        /* still in running, irq will start the pending list */
+        if (!chan->idle) {
+                dev_dbg(chan->dev, "DMA controller still busy\n");
+                return;
+        }
+
+        if (list_empty(&chan->chain_pending)) {
+                /* chance to re-fetch phy channel with higher prio */
+                if (chan->phy) {
+                        chan->phy->vchan = NULL;
+                        chan->phy = NULL;
+                }
+                dev_dbg(chan->dev, "no pending list\n");
+                return;
+        }
+
+        if (!chan->phy) {
+                chan->phy = lookup_phy(chan);
+                if (!chan->phy) {
+                        dev_dbg(chan->dev, "no free dma channel\n");
+                        return;
+                }
+        }
+
+        /*
+         * pending -> running
+         * reintilize pending list
+         */
+        desc = list_first_entry(&chan->chain_pending,
+                                struct mmp_pdma_desc_sw, node);
+        list_splice_tail_init(&chan->chain_pending, &chan->chain_running);
+
+        /*
+         * Program the descriptor's address into the DMA controller,
+         * then start the DMA transaction
+         */
+        set_desc(chan->phy, desc->async_tx.phys);
+        enable_chan(chan->phy);
+        chan->idle = false;
+}
+
+
+/* desc->tx_list ==> pending list */
+static dma_cookie_t mmp_pdma_tx_submit(struct dma_async_tx_descriptor *tx)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(tx->chan);
+        struct mmp_pdma_desc_sw *desc = tx_to_mmp_pdma_desc(tx);
+        struct mmp_pdma_desc_sw *child;
+        unsigned long flags;
+        dma_cookie_t cookie = -EBUSY;
+
+        spin_lock_irqsave(&chan->desc_lock, flags);
+
+        list_for_each_entry(child, &desc->tx_list, node) {
+                cookie = dma_cookie_assign(&child->async_tx);
+        }
+
+        append_pending_queue(chan, desc);
+
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+
+        return cookie;
+}
+
+struct mmp_pdma_desc_sw *mmp_pdma_alloc_descriptor(struct mmp_pdma_chan *chan)
+{
+        struct mmp_pdma_desc_sw *desc;
+        dma_addr_t pdesc;
+
+        desc = dma_pool_alloc(chan->desc_pool, GFP_ATOMIC, &pdesc);
+        if (!desc) {
+                dev_err(chan->dev, "out of memory for link descriptor\n");
+                return NULL;
+        }
+
+        memset(desc, 0, sizeof(*desc));
+        INIT_LIST_HEAD(&desc->tx_list);
+        dma_async_tx_descriptor_init(&desc->async_tx, &chan->chan);
+        /* each desc has submit */
+        desc->async_tx.tx_submit = mmp_pdma_tx_submit;
+        desc->async_tx.phys = pdesc;
+
+        return desc;
+}
+
+/**
+ * mmp_pdma_alloc_chan_resources - Allocate resources for DMA channel.
+ *
+ * This function will create a dma pool for descriptor allocation.
+ * Request irq only when channel is requested
+ * Return - The number of allocated descriptors.
+ */
+
+static int mmp_pdma_alloc_chan_resources(struct dma_chan *dchan)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+
+        if (chan->desc_pool)
+                return 1;
+
+        chan->desc_pool =
+                dma_pool_create(dev_name(&dchan->dev->device), chan->dev,
+                                  sizeof(struct mmp_pdma_desc_sw),
+                                  __alignof__(struct mmp_pdma_desc_sw), 0);
+        if (!chan->desc_pool) {
+                dev_err(chan->dev, "unable to allocate descriptor pool\n");
+                return -ENOMEM;
+        }
+        if (chan->phy) {
+                chan->phy->vchan = NULL;
+                chan->phy = NULL;
+        }
+        chan->idle = true;
+        chan->dev_addr = 0;
+        return 1;
+}
+
+static void mmp_pdma_free_desc_list(struct mmp_pdma_chan *chan,
+                                  struct list_head *list)
+{
+        struct mmp_pdma_desc_sw *desc, *_desc;
+
+        list_for_each_entry_safe(desc, _desc, list, node) {
+                list_del(&desc->node);
+                dma_pool_free(chan->desc_pool, desc, desc->async_tx.phys);
+        }
+}
+
+static void mmp_pdma_free_chan_resources(struct dma_chan *dchan)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&chan->desc_lock, flags);
+        mmp_pdma_free_desc_list(chan, &chan->chain_pending);
+        mmp_pdma_free_desc_list(chan, &chan->chain_running);
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+
+        dma_pool_destroy(chan->desc_pool);
+        chan->desc_pool = NULL;
+        chan->idle = true;
+        chan->dev_addr = 0;
+        if (chan->phy) {
+                chan->phy->vchan = NULL;
+                chan->phy = NULL;
+        }
+        return;
+}
+
+static struct dma_async_tx_descriptor *
+mmp_pdma_prep_memcpy(struct dma_chan *dchan,
+        dma_addr_t dma_dst, dma_addr_t dma_src,
+        size_t len, unsigned long flags)
+{
+        struct mmp_pdma_chan *chan;
+        struct mmp_pdma_desc_sw *first = NULL, *prev = NULL, *new;
+        size_t copy = 0;
+
+        if (!dchan)
+                return NULL;
+
+        if (!len)
+                return NULL;
+
+        chan = to_mmp_pdma_chan(dchan);
+
+        if (!chan->dir) {
+                chan->dir = DMA_MEM_TO_MEM;
+                chan->dcmd = DCMD_INCTRGADDR | DCMD_INCSRCADDR;
+                chan->dcmd |= DCMD_BURST32;
+        }
+
+        do {
+                /* Allocate the link descriptor from DMA pool */
+                new = mmp_pdma_alloc_descriptor(chan);
+                if (!new) {
+                        dev_err(chan->dev, "no memory for desc\n");
+                        goto fail;
+                }
+
+                copy = min_t(size_t, len, PDMA_MAX_DESC_BYTES);
+
+                new->desc.dcmd = chan->dcmd | (DCMD_LENGTH & copy);
+                new->desc.dsadr = dma_src;
+                new->desc.dtadr = dma_dst;
+
+                if (!first)
+                        first = new;
+                else
+                        prev->desc.ddadr = new->async_tx.phys;
+
+                new->async_tx.cookie = 0;
+                async_tx_ack(&new->async_tx);
+
+                prev = new;
+                len -= copy;
+
+                if (chan->dir == DMA_MEM_TO_DEV) {
+                        dma_src += copy;
+                } else if (chan->dir == DMA_DEV_TO_MEM) {
+                        dma_dst += copy;
+                } else if (chan->dir == DMA_MEM_TO_MEM) {
+                        dma_src += copy;
+                        dma_dst += copy;
+                }
+
+                /* Insert the link descriptor to the LD ring */
+                list_add_tail(&new->node, &first->tx_list);
+        } while (len);
+
+        first->async_tx.flags = flags; /* client is in control of this ack */
+        first->async_tx.cookie = -EBUSY;
+
+        /* last desc and fire IRQ */
+        new->desc.ddadr = DDADR_STOP;
+        new->desc.dcmd |= DCMD_ENDIRQEN;
+
+        return &first->async_tx;
+
+fail:
+        if (first)
+                mmp_pdma_free_desc_list(chan, &first->tx_list);
+        return NULL;
+}
+
+static struct dma_async_tx_descriptor *
+mmp_pdma_prep_slave_sg(struct dma_chan *dchan, struct scatterlist *sgl,
+                         unsigned int sg_len, enum dma_transfer_direction dir,
+                         unsigned long flags, void *context)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        struct mmp_pdma_desc_sw *first = NULL, *prev = NULL, *new = NULL;
+        size_t len, avail;
+        struct scatterlist *sg;
+        dma_addr_t addr;
+        int i;
+
+        if ((sgl == NULL) || (sg_len == 0))
+                return NULL;
+
+        for_each_sg(sgl, sg, sg_len, i) {
+                addr = sg_dma_address(sg);
+                avail = sg_dma_len(sgl);
+
+                do {
+                        len = min_t(size_t, avail, PDMA_MAX_DESC_BYTES);
+
+                        /* allocate and populate the descriptor */
+                        new = mmp_pdma_alloc_descriptor(chan);
+                        if (!new) {
+                                dev_err(chan->dev, "no memory for desc\n");
+                                goto fail;
+                        }
+
+                        new->desc.dcmd = chan->dcmd | (DCMD_LENGTH & len);
+                        if (dir == DMA_MEM_TO_DEV) {
+                                new->desc.dsadr = addr;
+                                new->desc.dtadr = chan->dev_addr;
+                        } else {
+                                new->desc.dsadr = chan->dev_addr;
+                                new->desc.dtadr = addr;
+                        }
+
+                        if (!first)
+                                first = new;
+                        else
+                                prev->desc.ddadr = new->async_tx.phys;
+
+                        new->async_tx.cookie = 0;
+                        async_tx_ack(&new->async_tx);
+                        prev = new;
+
+                        /* Insert the link descriptor to the LD ring */
+                        list_add_tail(&new->node, &first->tx_list);
+
+                        /* update metadata */
+                        addr += len;
+                        avail -= len;
+                } while (avail);
+        }
+
+        first->async_tx.cookie = -EBUSY;
+        first->async_tx.flags = flags;
+
+        /* last desc and fire IRQ */
+        new->desc.ddadr = DDADR_STOP;
+        new->desc.dcmd |= DCMD_ENDIRQEN;
+
+        return &first->async_tx;
+
+fail:
+        if (first)
+                mmp_pdma_free_desc_list(chan, &first->tx_list);
+        return NULL;
+}
+
+static int mmp_pdma_control(struct dma_chan *dchan, enum dma_ctrl_cmd cmd,
+                unsigned long arg)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        struct dma_slave_config *cfg = (void *)arg;
+        unsigned long flags;
+        int ret = 0;
+        u32 maxburst = 0, addr = 0;
+        enum dma_slave_buswidth width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
+
+        if (!dchan)
+                return -EINVAL;
+
+        switch (cmd) {
+        case DMA_TERMINATE_ALL:
+                disable_chan(chan->phy);
+                if (chan->phy) {
+                        chan->phy->vchan = NULL;
+                        chan->phy = NULL;
+                }
+                spin_lock_irqsave(&chan->desc_lock, flags);
+                mmp_pdma_free_desc_list(chan, &chan->chain_pending);
+                mmp_pdma_free_desc_list(chan, &chan->chain_running);
+                spin_unlock_irqrestore(&chan->desc_lock, flags);
+                chan->idle = true;
+                break;
+        case DMA_SLAVE_CONFIG:
+                if (cfg->direction == DMA_DEV_TO_MEM) {
+                        chan->dcmd = DCMD_INCTRGADDR | DCMD_FLOWSRC;
+                        maxburst = cfg->src_maxburst;
+                        width = cfg->src_addr_width;
+                        addr = cfg->src_addr;
+                } else if (cfg->direction == DMA_MEM_TO_DEV) {
+                        chan->dcmd = DCMD_INCSRCADDR | DCMD_FLOWTRG;
+                        maxburst = cfg->dst_maxburst;
+                        width = cfg->dst_addr_width;
+                        addr = cfg->dst_addr;
+                }
+
+                if (width == DMA_SLAVE_BUSWIDTH_1_BYTE)
+                        chan->dcmd |= DCMD_WIDTH1;
+                else if (width == DMA_SLAVE_BUSWIDTH_2_BYTES)
+                        chan->dcmd |= DCMD_WIDTH2;
+                else if (width == DMA_SLAVE_BUSWIDTH_4_BYTES)
+                        chan->dcmd |= DCMD_WIDTH4;
+
+                if (maxburst == 8)
+                        chan->dcmd |= DCMD_BURST8;
+                else if (maxburst == 16)
+                        chan->dcmd |= DCMD_BURST16;
+                else if (maxburst == 32)
+                        chan->dcmd |= DCMD_BURST32;
+
+                if (cfg) {
+                        chan->dir = cfg->direction;
+                        chan->drcmr = cfg->slave_id;
+                }
+                chan->dev_addr = addr;
+                break;
+        default:
+                return -ENOSYS;
+        }
+
+        return ret;
+}
+
+static enum dma_status mmp_pdma_tx_status(struct dma_chan *dchan,
+                        dma_cookie_t cookie, struct dma_tx_state *txstate)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        enum dma_status ret;
+        unsigned long flags;
+
+        spin_lock_irqsave(&chan->desc_lock, flags);
+        ret = dma_cookie_status(dchan, cookie, txstate);
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+
+        return ret;
+}
+
+/**
+ * mmp_pdma_issue_pending - Issue the DMA start command
+ * pending list ==> running list
+ */
+static void mmp_pdma_issue_pending(struct dma_chan *dchan)
+{
+        struct mmp_pdma_chan *chan = to_mmp_pdma_chan(dchan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&chan->desc_lock, flags);
+        start_pending_queue(chan);
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+}
+
+/*
+ * dma_do_tasklet
+ * Do call back
+ * Start pending list
+ */
+static void dma_do_tasklet(unsigned long data)
+{
+        struct mmp_pdma_chan *chan = (struct mmp_pdma_chan *)data;
+        struct mmp_pdma_desc_sw *desc, *_desc;
+        LIST_HEAD(chain_cleanup);
+        unsigned long flags;
+
+        /* submit pending list; callback for each desc; free desc */
+
+        spin_lock_irqsave(&chan->desc_lock, flags);
+
+        /* update the cookie if we have some descriptors to cleanup */
+        if (!list_empty(&chan->chain_running)) {
+                dma_cookie_t cookie;
+
+                desc = to_mmp_pdma_desc(chan->chain_running.prev);
+                cookie = desc->async_tx.cookie;
+                dma_cookie_complete(&desc->async_tx);
+
+                dev_dbg(chan->dev, "completed_cookie=%d\n", cookie);
+        }
+
+        /*
+         * move the descriptors to a temporary list so we can drop the lock
+         * during the entire cleanup operation
+         */
+        list_splice_tail_init(&chan->chain_running, &chain_cleanup);
+
+        /* the hardware is now idle and ready for more */
+        chan->idle = true;
+
+        /* Start any pending transactions automatically */
+        start_pending_queue(chan);
+        spin_unlock_irqrestore(&chan->desc_lock, flags);
+
+        /* Run the callback for each descriptor, in order */
+        list_for_each_entry_safe(desc, _desc, &chain_cleanup, node) {
+                struct dma_async_tx_descriptor *txd = &desc->async_tx;
+
+                /* Remove from the list of transactions */
+                list_del(&desc->node);
+                /* Run the link descriptor callback function */
+                if (txd->callback)
+                        txd->callback(txd->callback_param);
+
+                dma_pool_free(chan->desc_pool, desc, txd->phys);
+        }
+}
+
+static int __devexit mmp_pdma_remove(struct platform_device *op)
+{
+        struct mmp_pdma_device *pdev = platform_get_drvdata(op);
+
+        dma_async_device_unregister(&pdev->device);
+        return 0;
+}
+
+static int __devinit mmp_pdma_chan_init(struct mmp_pdma_device *pdev,
+                                                        int idx, int irq)
+{
+        struct mmp_pdma_phy *phy  = &pdev->phy[idx];
+        struct mmp_pdma_chan *chan;
+        int ret;
+
+        chan = devm_kzalloc(pdev->dev,
+                        sizeof(struct mmp_pdma_chan), GFP_KERNEL);
+        if (chan == NULL)
+                return -ENOMEM;
+
+        phy->idx = idx;
+        phy->base = pdev->base;
+
+        if (irq) {
+                ret = devm_request_irq(pdev->dev, irq,
+                        mmp_pdma_chan_handler, IRQF_DISABLED, "pdma", phy);
+                if (ret) {
+                        dev_err(pdev->dev, "channel request irq fail!\n");
+                        return ret;
+                }
+        }
+
+        spin_lock_init(&chan->desc_lock);
+        chan->dev = pdev->dev;
+        chan->chan.device = &pdev->device;
+        tasklet_init(&chan->tasklet, dma_do_tasklet, (unsigned long)chan);
+        INIT_LIST_HEAD(&chan->chain_pending);
+        INIT_LIST_HEAD(&chan->chain_running);
+
+        /* register virt channel to dma engine */
+        list_add_tail(&chan->chan.device_node,
+                        &pdev->device.channels);
+
+        return 0;
+}
+
+static struct of_device_id mmp_pdma_dt_ids[] = {
+        { .compatible = "marvell,pdma-1.0", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, mmp_pdma_dt_ids);
+
+static int __devinit mmp_pdma_probe(struct platform_device *op)
+{
+        struct mmp_pdma_device *pdev;
+        const struct of_device_id *of_id;
+        struct mmp_dma_platdata *pdata = dev_get_platdata(&op->dev);
+        struct resource *iores;
+        int i, ret, irq = 0;
+        int dma_channels = 0, irq_num = 0;
+
+        pdev = devm_kzalloc(&op->dev, sizeof(*pdev), GFP_KERNEL);
+        if (!pdev)
+                return -ENOMEM;
+        pdev->dev = &op->dev;
+
+        iores = platform_get_resource(op, IORESOURCE_MEM, 0);
+        if (!iores)
+                return -EINVAL;
+
+        pdev->base = devm_request_and_ioremap(pdev->dev, iores);
+        if (!pdev->base)
+                return -EADDRNOTAVAIL;
+
+        of_id = of_match_device(mmp_pdma_dt_ids, pdev->dev);
+        if (of_id)
+                of_property_read_u32(pdev->dev->of_node,
+                                "#dma-channels", &dma_channels);
+        else if (pdata && pdata->dma_channels)
+                dma_channels = pdata->dma_channels;
+        else
+                dma_channels = 32;      /* default 32 channel */
+        pdev->dma_channels = dma_channels;
+
+        for (i = 0; i < dma_channels; i++) {
+                if (platform_get_irq(op, i) > 0)
+                        irq_num++;
+        }
+
+        pdev->phy = devm_kzalloc(pdev->dev,
+                dma_channels * sizeof(struct mmp_pdma_chan), GFP_KERNEL);
+        if (pdev->phy == NULL)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&pdev->device.channels);
+
+        if (irq_num != dma_channels) {
+                /* all chan share one irq, demux inside */
+                irq = platform_get_irq(op, 0);
+                ret = devm_request_irq(pdev->dev, irq,
+                        mmp_pdma_int_handler, IRQF_DISABLED, "pdma", pdev);
+                if (ret)
+                        return ret;
+        }
+
+        for (i = 0; i < dma_channels; i++) {
+                irq = (irq_num != dma_channels) ? 0 : platform_get_irq(op, i);
+                ret = mmp_pdma_chan_init(pdev, i, irq);
+                if (ret)
+                        return ret;
+        }
+
+        dma_cap_set(DMA_SLAVE, pdev->device.cap_mask);
+        dma_cap_set(DMA_MEMCPY, pdev->device.cap_mask);
+        dma_cap_set(DMA_SLAVE, pdev->device.cap_mask);
+        pdev->device.dev = &op->dev;
+        pdev->device.device_alloc_chan_resources = mmp_pdma_alloc_chan_resources;
+        pdev->device.device_free_chan_resources = mmp_pdma_free_chan_resources;
+        pdev->device.device_tx_status = mmp_pdma_tx_status;
+        pdev->device.device_prep_dma_memcpy = mmp_pdma_prep_memcpy;
+        pdev->device.device_prep_slave_sg = mmp_pdma_prep_slave_sg;
+        pdev->device.device_issue_pending = mmp_pdma_issue_pending;
+        pdev->device.device_control = mmp_pdma_control;
+        pdev->device.copy_align = PDMA_ALIGNMENT;
+
+        if (pdev->dev->coherent_dma_mask)
+                dma_set_mask(pdev->dev, pdev->dev->coherent_dma_mask);
+        else
+                dma_set_mask(pdev->dev, DMA_BIT_MASK(64));
+
+        ret = dma_async_device_register(&pdev->device);
+        if (ret) {
+                dev_err(pdev->device.dev, "unable to register\n");
+                return ret;
+        }
+
+        dev_info(pdev->device.dev, "initialized\n");
+        return 0;
+}
+
+static const struct platform_device_id mmp_pdma_id_table[] = {
+        { "mmp-pdma", },
+        { },
+};
+
+static struct platform_driver mmp_pdma_driver = {
+        .driver         = {
+                .name   = "mmp-pdma",
+                .owner  = THIS_MODULE,
+                .of_match_table = mmp_pdma_dt_ids,
+        },
+        .id_table       = mmp_pdma_id_table,
+        .probe          = mmp_pdma_probe,
+        .remove         = __devexit_p(mmp_pdma_remove),
+};
+
+module_platform_driver(mmp_pdma_driver);
+
+MODULE_DESCRIPTION("MARVELL MMP Periphera DMA Driver");
+MODULE_AUTHOR("Marvell International Ltd.");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index 6d9c82e891d7..f3e8d71bcbc7 100644
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -20,6 +20,7 @@
 #include <linux/device.h>
 #include <mach/regs-icu.h>
 #include <linux/platform_data/dma-mmp_tdma.h>
+#include <linux/of_device.h>
 
 #include "dmaengine.h"
 
@@ -127,7 +128,6 @@ struct mmp_tdma_device {
         void __iomem                    *base;
         struct dma_device               device;
         struct mmp_tdma_chan            *tdmac[TDMA_CHANNEL_NUM];
-        int                             irq;
 };
 
 #define to_mmp_tdma_chan(dchan) container_of(dchan, struct mmp_tdma_chan, chan)
@@ -492,7 +492,7 @@ static int __devinit mmp_tdma_chan_init(struct mmp_tdma_device *tdev,
                 return -ENOMEM;
         }
         if (irq)
-                tdmac->irq = irq + idx;
+                tdmac->irq = irq;
         tdmac->dev         = tdev->dev;
         tdmac->chan.device = &tdev->device;
         tdmac->idx         = idx;
@@ -505,34 +505,43 @@ static int __devinit mmp_tdma_chan_init(struct mmp_tdma_device *tdev,
         /* add the channel to tdma_chan list */
         list_add_tail(&tdmac->chan.device_node,
                         &tdev->device.channels);
-
         return 0;
 }
 
+static struct of_device_id mmp_tdma_dt_ids[] = {
+        { .compatible = "marvell,adma-1.0", .data = (void *)MMP_AUD_TDMA},
+        { .compatible = "marvell,pxa910-squ", .data = (void *)PXA910_SQU},
+        {}
+};
+MODULE_DEVICE_TABLE(of, mmp_tdma_dt_ids);
+
 static int __devinit mmp_tdma_probe(struct platform_device *pdev)
 {
-        const struct platform_device_id *id = platform_get_device_id(pdev);
-        enum mmp_tdma_type type = id->driver_data;
+        enum mmp_tdma_type type;
+        const struct of_device_id *of_id;
         struct mmp_tdma_device *tdev;
         struct resource *iores;
         int i, ret;
-        int irq = 0;
+        int irq = 0, irq_num = 0;
         int chan_num = TDMA_CHANNEL_NUM;
 
+        of_id = of_match_device(mmp_tdma_dt_ids, &pdev->dev);
+        if (of_id)
+                type = (enum mmp_tdma_type) of_id->data;
+        else
+                type = platform_get_device_id(pdev)->driver_data;
+
         /* always have couple channels */
         tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL);
         if (!tdev)
                 return -ENOMEM;
 
         tdev->dev = &pdev->dev;
-        iores = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!iores)
-                return -EINVAL;
 
-        if (resource_size(iores) != chan_num)
-                tdev->irq = iores->start;
-        else
-                irq = iores->start;
+        for (i = 0; i < chan_num; i++) {
+                if (platform_get_irq(pdev, i) > 0)
+                        irq_num++;
+        }
 
         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!iores)
@@ -542,25 +551,26 @@ static int __devinit mmp_tdma_probe(struct platform_device *pdev)
         if (!tdev->base)
                 return -EADDRNOTAVAIL;
 
-        if (tdev->irq) {
-                ret = devm_request_irq(&pdev->dev, tdev->irq,
+        INIT_LIST_HEAD(&tdev->device.channels);
+
+        if (irq_num != chan_num) {
+                irq = platform_get_irq(pdev, 0);
+                ret = devm_request_irq(&pdev->dev, irq,
                         mmp_tdma_int_handler, IRQF_DISABLED, "tdma", tdev);
                 if (ret)
                         return ret;
         }
 
-        dma_cap_set(DMA_SLAVE, tdev->device.cap_mask);
-        dma_cap_set(DMA_CYCLIC, tdev->device.cap_mask);
-
-        INIT_LIST_HEAD(&tdev->device.channels);
-
         /* initialize channel parameters */
         for (i = 0; i < chan_num; i++) {
+                irq = (irq_num != chan_num) ? 0 : platform_get_irq(pdev, i);
                 ret = mmp_tdma_chan_init(tdev, i, irq, type);
                 if (ret)
                         return ret;
         }
 
+        dma_cap_set(DMA_SLAVE, tdev->device.cap_mask);
+        dma_cap_set(DMA_CYCLIC, tdev->device.cap_mask);
         tdev->device.dev = &pdev->dev;
         tdev->device.device_alloc_chan_resources =
                                         mmp_tdma_alloc_chan_resources;
@@ -595,6 +605,7 @@ static struct platform_driver mmp_tdma_driver = {
         .driver         = {
                 .name   = "mmp-tdma",
                 .owner  = THIS_MODULE,
+                .of_match_table = mmp_tdma_dt_ids,
         },
         .id_table       = mmp_tdma_id_table,
         .probe          = mmp_tdma_probe,
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index 734a4eb84d65..9f02e794b12b 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -101,7 +101,8 @@ struct mxs_dma_ccw {
         u32             pio_words[MXS_PIO_WORDS];
 };
 
-#define NUM_CCW (int)(PAGE_SIZE / sizeof(struct mxs_dma_ccw))
+#define CCW_BLOCK_SIZE  (4 * PAGE_SIZE)
+#define NUM_CCW (int)(CCW_BLOCK_SIZE / sizeof(struct mxs_dma_ccw))
 
 struct mxs_dma_chan {
         struct mxs_dma_engine           *mxs_dma;
@@ -354,14 +355,15 @@ static int mxs_dma_alloc_chan_resources(struct dma_chan *chan)
 
         mxs_chan->chan_irq = data->chan_irq;
 
-        mxs_chan->ccw = dma_alloc_coherent(mxs_dma->dma_device.dev, PAGE_SIZE,
-                                &mxs_chan->ccw_phys, GFP_KERNEL);
+        mxs_chan->ccw = dma_alloc_coherent(mxs_dma->dma_device.dev,
+                                CCW_BLOCK_SIZE, &mxs_chan->ccw_phys,
+                                GFP_KERNEL);
         if (!mxs_chan->ccw) {
                 ret = -ENOMEM;
                 goto err_alloc;
         }
 
-        memset(mxs_chan->ccw, 0, PAGE_SIZE);
+        memset(mxs_chan->ccw, 0, CCW_BLOCK_SIZE);
 
         if (mxs_chan->chan_irq != NO_IRQ) {
                 ret = request_irq(mxs_chan->chan_irq, mxs_dma_int_handler,
@@ -387,7 +389,7 @@ static int mxs_dma_alloc_chan_resources(struct dma_chan *chan)
 err_clk:
         free_irq(mxs_chan->chan_irq, mxs_dma);
 err_irq:
-        dma_free_coherent(mxs_dma->dma_device.dev, PAGE_SIZE,
+        dma_free_coherent(mxs_dma->dma_device.dev, CCW_BLOCK_SIZE,
                         mxs_chan->ccw, mxs_chan->ccw_phys);
 err_alloc:
         return ret;
@@ -402,7 +404,7 @@ static void mxs_dma_free_chan_resources(struct dma_chan *chan)
 
         free_irq(mxs_chan->chan_irq, mxs_dma);
 
-        dma_free_coherent(mxs_dma->dma_device.dev, PAGE_SIZE,
+        dma_free_coherent(mxs_dma->dma_device.dev, CCW_BLOCK_SIZE,
                         mxs_chan->ccw, mxs_chan->ccw_phys);
 
         clk_disable_unprepare(mxs_dma->clk);
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 169c0dbd71ae..665668b6f2b1 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -23,7 +23,6 @@
 #include <linux/dmaengine.h>
 #include <linux/amba/bus.h>
 #include <linux/amba/pl330.h>
-#include <linux/pm_runtime.h>
 #include <linux/scatterlist.h>
 #include <linux/of.h>
 
@@ -586,8 +585,6 @@ struct dma_pl330_dmac {
 
         /* Peripheral channels connected to this DMAC */
         struct dma_pl330_chan *peripherals; /* keep at end */
-
-        struct clk *clk;
 };
 
 struct dma_pl330_desc {
@@ -2395,7 +2392,7 @@ static int pl330_alloc_chan_resources(struct dma_chan *chan)
         pch->pl330_chid = pl330_request_channel(&pdmac->pif);
         if (!pch->pl330_chid) {
                 spin_unlock_irqrestore(&pch->lock, flags);
-                return 0;
+                return -ENOMEM;
         }
 
         tasklet_init(&pch->task, pl330_tasklet, (unsigned long) pch);
@@ -2889,29 +2886,17 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
                 goto probe_err1;
         }
 
-        pdmac->clk = clk_get(&adev->dev, "dma");
-        if (IS_ERR(pdmac->clk)) {
-                dev_err(&adev->dev, "Cannot get operation clock.\n");
-                ret = -EINVAL;
-                goto probe_err2;
-        }
-
         amba_set_drvdata(adev, pdmac);
 
-#ifndef CONFIG_PM_RUNTIME
-        /* enable dma clk */
-        clk_enable(pdmac->clk);
-#endif
-
         irq = adev->irq[0];
         ret = request_irq(irq, pl330_irq_handler, 0,
                         dev_name(&adev->dev), pi);
         if (ret)
-                goto probe_err3;
+                goto probe_err2;
 
         ret = pl330_add(pi);
         if (ret)
-                goto probe_err4;
+                goto probe_err3;
 
         INIT_LIST_HEAD(&pdmac->desc_pool);
         spin_lock_init(&pdmac->pool_lock);
@@ -2933,7 +2918,7 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         if (!pdmac->peripherals) {
                 ret = -ENOMEM;
                 dev_err(&adev->dev, "unable to allocate pdmac->peripherals\n");
-                goto probe_err5;
+                goto probe_err4;
         }
 
         for (i = 0; i < num_chan; i++) {
@@ -2961,6 +2946,7 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
                 if (pi->pcfg.num_peri) {
                         dma_cap_set(DMA_SLAVE, pd->cap_mask);
                         dma_cap_set(DMA_CYCLIC, pd->cap_mask);
+                        dma_cap_set(DMA_PRIVATE, pd->cap_mask);
                 }
         }
 
@@ -2976,7 +2962,7 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         ret = dma_async_device_register(pd);
         if (ret) {
                 dev_err(&adev->dev, "unable to register DMAC\n");
-                goto probe_err5;
+                goto probe_err4;
         }
 
         dev_info(&adev->dev,
@@ -2989,15 +2975,10 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
 
         return 0;
 
-probe_err5:
-        pl330_del(pi);
 probe_err4:
-        free_irq(irq, pi);
+        pl330_del(pi);
 probe_err3:
-#ifndef CONFIG_PM_RUNTIME
-        clk_disable(pdmac->clk);
-#endif
-        clk_put(pdmac->clk);
+        free_irq(irq, pi);
 probe_err2:
         iounmap(pi->base);
 probe_err1:
@@ -3044,10 +3025,6 @@ static int __devexit pl330_remove(struct amba_device *adev)
         res = &adev->res;
         release_mem_region(res->start, resource_size(res));
 
-#ifndef CONFIG_PM_RUNTIME
-        clk_disable(pdmac->clk);
-#endif
-
         kfree(pdmac);
 
         return 0;
@@ -3063,49 +3040,10 @@ static struct amba_id pl330_ids[] = {
 
 MODULE_DEVICE_TABLE(amba, pl330_ids);
 
-#ifdef CONFIG_PM_RUNTIME
-static int pl330_runtime_suspend(struct device *dev)
-{
-        struct dma_pl330_dmac *pdmac = dev_get_drvdata(dev);
-
-        if (!pdmac) {
-                dev_err(dev, "failed to get dmac\n");
-                return -ENODEV;
-        }
-
-        clk_disable(pdmac->clk);
-
-        return 0;
-}
-
-static int pl330_runtime_resume(struct device *dev)
-{
-        struct dma_pl330_dmac *pdmac = dev_get_drvdata(dev);
-
-        if (!pdmac) {
-                dev_err(dev, "failed to get dmac\n");
-                return -ENODEV;
-        }
-
-        clk_enable(pdmac->clk);
-
-        return 0;
-}
-#else
-#define pl330_runtime_suspend   NULL
-#define pl330_runtime_resume    NULL
-#endif /* CONFIG_PM_RUNTIME */
-
-static const struct dev_pm_ops pl330_pm_ops = {
-        .runtime_suspend = pl330_runtime_suspend,
-        .runtime_resume = pl330_runtime_resume,
-};
-
 static struct amba_driver pl330_driver = {
         .drv = {
                 .owner = THIS_MODULE,
                 .name = "dma-pl330",
-                .pm = &pl330_pm_ops,
         },
         .id_table = pl330_ids,
         .probe = pl330_probe,
diff --git a/drivers/dma/sirf-dma.c b/drivers/dma/sirf-dma.c
index 3eed8b35b0f1..64385cde044b 100644
--- a/drivers/dma/sirf-dma.c
+++ b/drivers/dma/sirf-dma.c
@@ -570,21 +570,19 @@ static int __devinit sirfsoc_dma_probe(struct platform_device *op)
 
         if (of_property_read_u32(dn, "cell-index", &id)) {
                 dev_err(dev, "Fail to get DMAC index\n");
-                ret = -ENODEV;
-                goto free_mem;
+                return -ENODEV;
         }
 
         sdma->irq = irq_of_parse_and_map(dn, 0);
         if (sdma->irq == NO_IRQ) {
                 dev_err(dev, "Error mapping IRQ!\n");
-                ret = -EINVAL;
-                goto free_mem;
+                return -EINVAL;
         }
 
         ret = of_address_to_resource(dn, 0, &res);
         if (ret) {
                 dev_err(dev, "Error parsing memory region!\n");
-                goto free_mem;
+                goto irq_dispose;
         }
 
         regs_start = res.start;
@@ -597,12 +595,11 @@ static int __devinit sirfsoc_dma_probe(struct platform_device *op)
                 goto irq_dispose;
         }
 
-        ret = devm_request_irq(dev, sdma->irq, &sirfsoc_dma_irq, 0, DRV_NAME,
-                sdma);
+        ret = request_irq(sdma->irq, &sirfsoc_dma_irq, 0, DRV_NAME, sdma);
         if (ret) {
                 dev_err(dev, "Error requesting IRQ!\n");
                 ret = -EINVAL;
-                goto unmap_mem;
+                goto irq_dispose;
         }
 
         dma = &sdma->dma;
@@ -652,13 +649,9 @@ static int __devinit sirfsoc_dma_probe(struct platform_device *op)
         return 0;
 
 free_irq:
-        devm_free_irq(dev, sdma->irq, sdma);
+        free_irq(sdma->irq, sdma);
 irq_dispose:
         irq_dispose_mapping(sdma->irq);
-unmap_mem:
-        iounmap(sdma->base);
-free_mem:
-        devm_kfree(dev, sdma);
         return ret;
 }
 
@@ -668,10 +661,8 @@ static int __devexit sirfsoc_dma_remove(struct platform_device *op)
         struct sirfsoc_dma *sdma = dev_get_drvdata(dev);
 
         dma_async_device_unregister(&sdma->dma);
-        devm_free_irq(dev, sdma->irq, sdma);
+        free_irq(sdma->irq, sdma);
         irq_dispose_mapping(sdma->irq);
-        iounmap(sdma->base);
-        devm_kfree(dev, sdma);
         return 0;
 }
 
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index eee8d9b9a20b..ae55091c2272 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -2921,19 +2921,23 @@ static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
         struct d40_base *base = NULL;
         int num_log_chans = 0;
         int num_phy_chans;
+        int clk_ret = -EINVAL;
         int i;
         u32 pid;
         u32 cid;
         u8 rev;
 
         clk = clk_get(&pdev->dev, NULL);
-
         if (IS_ERR(clk)) {
                 d40_err(&pdev->dev, "No matching clock found\n");
                 goto failure;
         }
 
-        clk_enable(clk);
+        clk_ret = clk_prepare_enable(clk);
+        if (clk_ret) {
+                d40_err(&pdev->dev, "Failed to prepare/enable clock\n");
+                goto failure;
+        }
 
         /* Get IO for DMAC base address */
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "base");
@@ -3063,10 +3067,10 @@ static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
         return base;
 
 failure:
-        if (!IS_ERR(clk)) {
-                clk_disable(clk);
+        if (!clk_ret)
+                clk_disable_unprepare(clk);
+        if (!IS_ERR(clk))
                 clk_put(clk);
-        }
         if (virtbase)
                 iounmap(virtbase);
         if (res)
diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c
index 45fbeed1c1a5..528c62dd4b00 100644
--- a/drivers/dma/tegra20-apb-dma.c
+++ b/drivers/dma/tegra20-apb-dma.c
@@ -169,6 +169,7 @@ typedef void (*dma_isr_handler)(struct tegra_dma_channel *tdc,
 /* tegra_dma_channel: Channel specific information */
 struct tegra_dma_channel {
         struct dma_chan         dma_chan;
+        char                    name[30];
         bool                    config_init;
         int                     id;
         int                     irq;
@@ -475,8 +476,7 @@ static void tegra_dma_abort_all(struct tegra_dma_channel *tdc)
         while (!list_empty(&tdc->pending_sg_req)) {
                 sgreq = list_first_entry(&tdc->pending_sg_req,
                                                 typeof(*sgreq), node);
-                list_del(&sgreq->node);
-                list_add_tail(&sgreq->node, &tdc->free_sg_req);
+                list_move_tail(&sgreq->node, &tdc->free_sg_req);
                 if (sgreq->last_sg) {
                         dma_desc = sgreq->dma_desc;
                         dma_desc->dma_status = DMA_ERROR;
@@ -570,8 +570,7 @@ static void handle_cont_sngl_cycle_dma_done(struct tegra_dma_channel *tdc,
 
         /* If not last req then put at end of pending list */
         if (!list_is_last(&sgreq->node, &tdc->pending_sg_req)) {
-                list_del(&sgreq->node);
-                list_add_tail(&sgreq->node, &tdc->pending_sg_req);
+                list_move_tail(&sgreq->node, &tdc->pending_sg_req);
                 sgreq->configured = false;
                 st = handle_continuous_head_request(tdc, sgreq, to_terminate);
                 if (!st)
@@ -1284,7 +1283,6 @@ static int __devinit tegra_dma_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&tdma->dma_dev.channels);
         for (i = 0; i < cdata->nr_channels; i++) {
                 struct tegra_dma_channel *tdc = &tdma->channels[i];
-                char irq_name[30];
 
                 tdc->chan_base_offset = TEGRA_APBDMA_CHANNEL_BASE_ADD_OFFSET +
                                         i * TEGRA_APBDMA_CHANNEL_REGISTER_SIZE;
@@ -1296,9 +1294,9 @@ static int __devinit tegra_dma_probe(struct platform_device *pdev)
                         goto err_irq;
                 }
                 tdc->irq = res->start;
-                snprintf(irq_name, sizeof(irq_name), "apbdma.%d", i);
+                snprintf(tdc->name, sizeof(tdc->name), "apbdma.%d", i);
                 ret = devm_request_irq(&pdev->dev, tdc->irq,
-                                tegra_dma_isr, 0, irq_name, tdc);
+                                tegra_dma_isr, 0, tdc->name, tdc);
                 if (ret) {
                         dev_err(&pdev->dev,
                                 "request_irq failed with err %d channel %d\n",
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 8ac5246e2ab2..06c42cfb7c34 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -26,6 +26,7 @@
 #include <linux/suspend.h>
 #include <linux/fault-inject.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -41,6 +42,12 @@
 #include "sd_ops.h"
 #include "sdio_ops.h"
 
+/*
+ * Background operations can take a long time, depending on the housekeeping
+ * operations the card has to perform.
+ */
+#define MMC_BKOPS_MAX_TIMEOUT   (4 * 60 * 1000) /* max time to wait in ms */
+
 static struct workqueue_struct *workqueue;
 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
 
@@ -245,6 +252,70 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         host->ops->request(host, mrq);
 }
 
+/**
+ *      mmc_start_bkops - start BKOPS for supported cards
+ *      @card: MMC card to start BKOPS
+ *      @form_exception: A flag to indicate if this function was
+ *                       called due to an exception raised by the card
+ *
+ *      Start background operations whenever requested.
+ *      When the urgent BKOPS bit is set in a R1 command response
+ *      then background operations should be started immediately.
+*/
+void mmc_start_bkops(struct mmc_card *card, bool from_exception)
+{
+        int err;
+        int timeout;
+        bool use_busy_signal;
+
+        BUG_ON(!card);
+
+        if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+                return;
+
+        err = mmc_read_bkops_status(card);
+        if (err) {
+                pr_err("%s: Failed to read bkops status: %d\n",
+                       mmc_hostname(card->host), err);
+                return;
+        }
+
+        if (!card->ext_csd.raw_bkops_status)
+                return;
+
+        if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
+            from_exception)
+                return;
+
+        mmc_claim_host(card->host);
+        if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
+                timeout = MMC_BKOPS_MAX_TIMEOUT;
+                use_busy_signal = true;
+        } else {
+                timeout = 0;
+                use_busy_signal = false;
+        }
+
+        err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                        EXT_CSD_BKOPS_START, 1, timeout, use_busy_signal);
+        if (err) {
+                pr_warn("%s: Error %d starting bkops\n",
+                        mmc_hostname(card->host), err);
+                goto out;
+        }
+
+        /*
+         * For urgent bkops status (LEVEL_2 and more)
+         * bkops executed synchronously, otherwise
+         * the operation is in progress
+         */
+        if (!use_busy_signal)
+                mmc_card_set_doing_bkops(card);
+out:
+        mmc_release_host(card->host);
+}
+EXPORT_SYMBOL(mmc_start_bkops);
+
 static void mmc_wait_done(struct mmc_request *mrq)
 {
         complete(&mrq->completion);
@@ -354,6 +425,14 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
         if (host->areq) {
                 mmc_wait_for_req_done(host, host->areq->mrq);
                 err = host->areq->err_check(host->card, host->areq);
+                /*
+                 * Check BKOPS urgency for each R1 response
+                 */
+                if (host->card && mmc_card_mmc(host->card) &&
+                    ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
+                     (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
+                    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT))
+                        mmc_start_bkops(host->card, true);
         }
 
         if (!err && areq)
@@ -398,7 +477,7 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  *      @card: the MMC card associated with the HPI transfer
  *
  *      Issued High Priority Interrupt, and check for card status
- *      util out-of prg-state.
+ *      until out-of prg-state.
  */
 int mmc_interrupt_hpi(struct mmc_card *card)
 {
@@ -424,8 +503,9 @@ int mmc_interrupt_hpi(struct mmc_card *card)
         case R1_STATE_IDLE:
         case R1_STATE_READY:
         case R1_STATE_STBY:
+        case R1_STATE_TRAN:
                 /*
-                 * In idle states, HPI is not needed and the caller
+                 * In idle and transfer states, HPI is not needed and the caller
                  * can issue the next intended command immediately
                  */
                 goto out;
@@ -489,6 +569,64 @@ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries
 EXPORT_SYMBOL(mmc_wait_for_cmd);
 
 /**
+ *      mmc_stop_bkops - stop ongoing BKOPS
+ *      @card: MMC card to check BKOPS
+ *
+ *      Send HPI command to stop ongoing background operations to
+ *      allow rapid servicing of foreground operations, e.g. read/
+ *      writes. Wait until the card comes out of the programming state
+ *      to avoid errors in servicing read/write requests.
+ */
+int mmc_stop_bkops(struct mmc_card *card)
+{
+        int err = 0;
+
+        BUG_ON(!card);
+        err = mmc_interrupt_hpi(card);
+
+        /*
+         * If err is EINVAL, we can't issue an HPI.
+         * It should complete the BKOPS.
+         */
+        if (!err || (err == -EINVAL)) {
+                mmc_card_clr_doing_bkops(card);
+                err = 0;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL(mmc_stop_bkops);
+
+int mmc_read_bkops_status(struct mmc_card *card)
+{
+        int err;
+        u8 *ext_csd;
+
+        /*
+         * In future work, we should consider storing the entire ext_csd.
+         */
+        ext_csd = kmalloc(512, GFP_KERNEL);
+        if (!ext_csd) {
+                pr_err("%s: could not allocate buffer to receive the ext_csd.\n",
+                       mmc_hostname(card->host));
+                return -ENOMEM;
+        }
+
+        mmc_claim_host(card->host);
+        err = mmc_send_ext_csd(card, ext_csd);
+        mmc_release_host(card->host);
+        if (err)
+                goto out;
+
+        card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
+        card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
+out:
+        kfree(ext_csd);
+        return err;
+}
+EXPORT_SYMBOL(mmc_read_bkops_status);
+
+/**
  *      mmc_set_data_timeout - set the timeout for a data command
  *      @data: data phase for command
  *      @card: the MMC card associated with the data transfer
@@ -975,7 +1113,8 @@ int mmc_regulator_set_ocr(struct mmc_host *mmc,
                 int             tmp;
                 int             voltage;
 
-                /* REVISIT mmc_vddrange_to_ocrmask() may have set some
+                /*
+                 * REVISIT mmc_vddrange_to_ocrmask() may have set some
                  * bits this regulator doesn't quite support ... don't
                  * be too picky, most cards and regulators are OK with
                  * a 0.1V range goof (it's a small error percentage).
@@ -989,12 +1128,13 @@ int mmc_regulator_set_ocr(struct mmc_host *mmc,
                         max_uV = min_uV + 100 * 1000;
                 }
 
-                /* avoid needless changes to this voltage; the regulator
-                 * might not allow this operation
+                /*
+                 * If we're using a fixed/static regulator, don't call
+                 * regulator_set_voltage; it would fail.
                  */
                 voltage = regulator_get_voltage(supply);
 
-                if (mmc->caps2 & MMC_CAP2_BROKEN_VOLTAGE)
+                if (regulator_count_voltages(supply) == 1)
                         min_uV = max_uV = voltage;
 
                 if (voltage < 0)
@@ -1133,48 +1273,6 @@ void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
         mmc_host_clk_release(host);
 }
 
-static void mmc_poweroff_notify(struct mmc_host *host)
-{
-        struct mmc_card *card;
-        unsigned int timeout;
-        unsigned int notify_type = EXT_CSD_NO_POWER_NOTIFICATION;
-        int err = 0;
-
-        card = host->card;
-        mmc_claim_host(host);
-
-        /*
-         * Send power notify command only if card
-         * is mmc and notify state is powered ON
-         */
-        if (card && mmc_card_mmc(card) &&
-            (card->poweroff_notify_state == MMC_POWERED_ON)) {
-
-                if (host->power_notify_type == MMC_HOST_PW_NOTIFY_SHORT) {
-                        notify_type = EXT_CSD_POWER_OFF_SHORT;
-                        timeout = card->ext_csd.generic_cmd6_time;
-                        card->poweroff_notify_state = MMC_POWEROFF_SHORT;
-                } else {
-                        notify_type = EXT_CSD_POWER_OFF_LONG;
-                        timeout = card->ext_csd.power_off_longtime;
-                        card->poweroff_notify_state = MMC_POWEROFF_LONG;
-                }
-
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                 EXT_CSD_POWER_OFF_NOTIFICATION,
-                                 notify_type, timeout);
-
-                if (err && err != -EBADMSG)
-                        pr_err("Device failed to respond within %d poweroff "
-                               "time. Forcefully powering down the device\n",
-                               timeout);
-
-                /* Set the card state to no notification after the poweroff */
-                card->poweroff_notify_state = MMC_NO_POWER_NOTIFICATION;
-        }
-        mmc_release_host(host);
-}
-
 /*
  * Apply power to the MMC stack.  This is a two-stage process.
  * First, we enable power to the card without the clock running.
@@ -1237,8 +1335,6 @@ static void mmc_power_up(struct mmc_host *host)
 
 void mmc_power_off(struct mmc_host *host)
 {
-        int err = 0;
-
         if (host->ios.power_mode == MMC_POWER_OFF)
                 return;
 
@@ -1247,22 +1343,6 @@ void mmc_power_off(struct mmc_host *host)
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
-        /*
-         * For eMMC 4.5 device send AWAKE command before
-         * POWER_OFF_NOTIFY command, because in sleep state
-         * eMMC 4.5 devices respond to only RESET and AWAKE cmd
-         */
-        if (host->card && mmc_card_is_sleep(host->card) &&
-            host->bus_ops->resume) {
-                err = host->bus_ops->resume(host);
-
-                if (!err)
-                        mmc_poweroff_notify(host);
-                else
-                        pr_warning("%s: error %d during resume "
-                                   "(continue with poweroff sequence)\n",
-                                   mmc_hostname(host), err);
-        }
 
         /*
          * Reset ocr mask to be the highest possible voltage supported for
@@ -2052,6 +2132,11 @@ void mmc_rescan(struct work_struct *work)
         if (host->rescan_disable)
                 return;
 
+        /* If there is a non-removable card registered, only scan once */
+        if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
+                return;
+        host->rescan_entered = 1;
+
         mmc_bus_get(host);
 
         /*
@@ -2327,9 +2412,14 @@ int mmc_suspend_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-
-                if (host->bus_ops->suspend)
+                if (host->bus_ops->suspend) {
+                        if (mmc_card_doing_bkops(host->card)) {
+                                err = mmc_stop_bkops(host->card);
+                                if (err)
+                                        goto out;
+                        }
                         err = host->bus_ops->suspend(host);
+                }
 
                 if (err == -ENOSYS || !host->bus_ops->resume) {
                         /*
@@ -2411,15 +2501,24 @@ int mmc_pm_notify(struct notifier_block *notify_block,
         struct mmc_host *host = container_of(
                 notify_block, struct mmc_host, pm_notify);
         unsigned long flags;
-
+        int err = 0;
 
         switch (mode) {
         case PM_HIBERNATION_PREPARE:
         case PM_SUSPEND_PREPARE:
+                if (host->card && mmc_card_mmc(host->card) &&
+                    mmc_card_doing_bkops(host->card)) {
+                        err = mmc_stop_bkops(host->card);
+                        if (err) {
+                                pr_err("%s: didn't stop bkops\n",
+                                        mmc_hostname(host));
+                                return err;
+                        }
+                        mmc_card_clr_doing_bkops(host->card);
+                }
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 1;
-                host->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
                 spin_unlock_irqrestore(&host->lock, flags);
                 cancel_delayed_work_sync(&host->detect);
 
@@ -2443,7 +2542,6 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 0;
-                host->power_notify_type = MMC_HOST_PW_NOTIFY_LONG;
                 spin_unlock_irqrestore(&host->lock, flags);
                 mmc_detect_change(host, 0);
 
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 9ab5b17d488a..d96c643dde1c 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -281,7 +281,7 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
         if (err)
                 goto out_free;
 
-        for (i = 511; i >= 0; i--)
+        for (i = 0; i < 512; i++)
                 n += sprintf(buf + n, "%02x", ext_csd[i]);
         n += sprintf(buf + n, "\n");
         BUG_ON(n != EXT_CSD_STR_LEN);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 396b25891bb9..7cc46382fd64 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -463,6 +463,17 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
 
         if (card->ext_csd.rev >= 5) {
+                /* check whether the eMMC card supports BKOPS */
+                if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
+                        card->ext_csd.bkops = 1;
+                        card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN];
+                        card->ext_csd.raw_bkops_status =
+                                ext_csd[EXT_CSD_BKOPS_STATUS];
+                        if (!card->ext_csd.bkops_en)
+                                pr_info("%s: BKOPS_EN bit is not set\n",
+                                        mmc_hostname(card->host));
+                }
+
                 /* check whether the eMMC card supports HPI */
                 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
                         card->ext_csd.hpi = 1;
@@ -996,7 +1007,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                  * so check for success and update the flag
                  */
                 if (!err)
-                        card->poweroff_notify_state = MMC_POWERED_ON;
+                        card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
         }
 
         /*
@@ -1262,6 +1273,35 @@ err:
         return err;
 }
 
+static int mmc_can_poweroff_notify(const struct mmc_card *card)
+{
+        return card &&
+                mmc_card_mmc(card) &&
+                (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
+}
+
+static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
+{
+        unsigned int timeout = card->ext_csd.generic_cmd6_time;
+        int err;
+
+        /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
+        if (notify_type == EXT_CSD_POWER_OFF_LONG)
+                timeout = card->ext_csd.power_off_longtime;
+
+        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                         EXT_CSD_POWER_OFF_NOTIFICATION,
+                         notify_type, timeout);
+        if (err)
+                pr_err("%s: Power Off Notification timed out, %u\n",
+                       mmc_hostname(card->host), timeout);
+
+        /* Disable the power off notification after the switch operation. */
+        card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
+
+        return err;
+}
+
 /*
  * Host is being removed. Free up the current card.
  */
@@ -1322,11 +1362,11 @@ static int mmc_suspend(struct mmc_host *host)
         BUG_ON(!host->card);
 
         mmc_claim_host(host);
-        if (mmc_card_can_sleep(host)) {
+        if (mmc_can_poweroff_notify(host->card))
+                err = mmc_poweroff_notify(host->card, EXT_CSD_POWER_OFF_SHORT);
+        else if (mmc_card_can_sleep(host))
                 err = mmc_card_sleep(host);
-                if (!err)
-                        mmc_card_set_sleep(host->card);
-        } else if (!mmc_host_is_spi(host))
+        else if (!mmc_host_is_spi(host))
                 err = mmc_deselect_cards(host);
         host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
         mmc_release_host(host);
@@ -1348,11 +1388,7 @@ static int mmc_resume(struct mmc_host *host)
         BUG_ON(!host->card);
 
         mmc_claim_host(host);
-        if (mmc_card_is_sleep(host->card)) {
-                err = mmc_card_awake(host);
-                mmc_card_clr_sleep(host->card);
-        } else
-                err = mmc_init_card(host, host->ocr, host->card);
+        err = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
 
         return err;
@@ -1363,7 +1399,6 @@ static int mmc_power_restore(struct mmc_host *host)
         int ret;
 
         host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
-        mmc_card_clr_sleep(host->card);
         mmc_claim_host(host);
         ret = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 0ed2cc5f35b6..a0e172042e65 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -230,6 +230,10 @@ mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
         return 0;
 }
 
+/*
+ * NOTE: void *buf, caller for the buf is required to use DMA-capable
+ * buffer or on-stack buffer (with some overhead in callee).
+ */
 static int
 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
                 u32 opcode, void *buf, unsigned len)
@@ -239,13 +243,19 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         struct mmc_data data = {0};
         struct scatterlist sg;
         void *data_buf;
+        int is_on_stack;
 
-        /* dma onto stack is unsafe/nonportable, but callers to this
-         * routine normally provide temporary on-stack buffers ...
-         */
-        data_buf = kmalloc(len, GFP_KERNEL);
-        if (data_buf == NULL)
-                return -ENOMEM;
+        is_on_stack = object_is_on_stack(buf);
+        if (is_on_stack) {
+                /*
+                 * dma onto stack is unsafe/nonportable, but callers to this
+                 * routine normally provide temporary on-stack buffers ...
+                 */
+                data_buf = kmalloc(len, GFP_KERNEL);
+                if (!data_buf)
+                        return -ENOMEM;
+        } else
+                data_buf = buf;
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -280,8 +290,10 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 
         mmc_wait_for_req(host, &mrq);
 
-        memcpy(buf, data_buf, len);
-        kfree(data_buf);
+        if (is_on_stack) {
+                memcpy(buf, data_buf, len);
+                kfree(data_buf);
+        }
 
         if (cmd.error)
                 return cmd.error;
@@ -294,24 +306,32 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 int mmc_send_csd(struct mmc_card *card, u32 *csd)
 {
         int ret, i;
+        u32 *csd_tmp;
 
         if (!mmc_host_is_spi(card->host))
                 return mmc_send_cxd_native(card->host, card->rca << 16,
                                 csd, MMC_SEND_CSD);
 
-        ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);
+        csd_tmp = kmalloc(16, GFP_KERNEL);
+        if (!csd_tmp)
+                return -ENOMEM;
+
+        ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
         if (ret)
-                return ret;
+                goto err;
 
         for (i = 0;i < 4;i++)
-                csd[i] = be32_to_cpu(csd[i]);
+                csd[i] = be32_to_cpu(csd_tmp[i]);
 
-        return 0;
+err:
+        kfree(csd_tmp);
+        return ret;
 }
 
 int mmc_send_cid(struct mmc_host *host, u32 *cid)
 {
         int ret, i;
+        u32 *cid_tmp;
 
         if (!mmc_host_is_spi(host)) {
                 if (!host->card)
@@ -320,14 +340,20 @@ int mmc_send_cid(struct mmc_host *host, u32 *cid)
                                 cid, MMC_SEND_CID);
         }
 
-        ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16);
+        cid_tmp = kmalloc(16, GFP_KERNEL);
+        if (!cid_tmp)
+                return -ENOMEM;
+
+        ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
         if (ret)
-                return ret;
+                goto err;
 
         for (i = 0;i < 4;i++)
-                cid[i] = be32_to_cpu(cid[i]);
+                cid[i] = be32_to_cpu(cid_tmp[i]);
 
-        return 0;
+err:
+        kfree(cid_tmp);
+        return ret;
 }
 
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
@@ -367,18 +393,19 @@ int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
 }
 
 /**
- *      mmc_switch - modify EXT_CSD register
+ *      __mmc_switch - modify EXT_CSD register
  *      @card: the MMC card associated with the data transfer
  *      @set: cmd set values
  *      @index: EXT_CSD register index
  *      @value: value to program into EXT_CSD register
  *      @timeout_ms: timeout (ms) for operation performed by register write,
  *                   timeout of zero implies maximum possible timeout
+ *      @use_busy_signal: use the busy signal as response type
  *
  *      Modifies the EXT_CSD register for selected card.
  */
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
-               unsigned int timeout_ms)
+int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+               unsigned int timeout_ms, bool use_busy_signal)
 {
         int err;
         struct mmc_command cmd = {0};
@@ -392,13 +419,23 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
                   (index << 16) |
                   (value << 8) |
                   set;
-        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        cmd.flags = MMC_CMD_AC;
+        if (use_busy_signal)
+                cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
+        else
+                cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
+
+
         cmd.cmd_timeout_ms = timeout_ms;
 
         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
         if (err)
                 return err;
 
+        /* No need to check card status in case of unblocking command */
+        if (!use_busy_signal)
+                return 0;
+
         /* Must check status to be sure of no errors */
         do {
                 err = mmc_send_status(card, &status);
@@ -423,6 +460,13 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(__mmc_switch);
+
+int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+                unsigned int timeout_ms)
+{
+        return __mmc_switch(card, set, index, value, timeout_ms, true);
+}
 EXPORT_SYMBOL_GPL(mmc_switch);
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 236842ec955a..6bf68799fe97 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -193,14 +193,7 @@ static int sdio_bus_remove(struct device *dev)
 }
 
 #ifdef CONFIG_PM
-
-static int pm_no_operation(struct device *dev)
-{
-        return 0;
-}
-
 static const struct dev_pm_ops sdio_bus_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(pm_no_operation, pm_no_operation)
         SET_RUNTIME_PM_OPS(
                 pm_generic_runtime_suspend,
                 pm_generic_runtime_resume,
diff --git a/drivers/mmc/core/slot-gpio.c b/drivers/mmc/core/slot-gpio.c
index 058242916cef..08c6b3dfe080 100644
--- a/drivers/mmc/core/slot-gpio.c
+++ b/drivers/mmc/core/slot-gpio.c
@@ -100,7 +100,13 @@ int mmc_gpio_request_ro(struct mmc_host *host, unsigned int gpio)
 
         ctx = host->slot.handler_priv;
 
-        return gpio_request_one(gpio, GPIOF_DIR_IN, ctx->ro_label);
+        ret = gpio_request_one(gpio, GPIOF_DIR_IN, ctx->ro_label);
+        if (ret < 0)
+                return ret;
+
+        ctx->ro_gpio = gpio;
+
+        return 0;
 }
 EXPORT_SYMBOL(mmc_gpio_request_ro);
 
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index aa131b32e3b2..9bf10e7bbfaf 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -540,6 +540,15 @@ config MMC_DW_PLTFM
 
           If unsure, say Y.
 
+config MMC_DW_EXYNOS
+        tristate "Exynos specific extentions for Synopsys DW Memory Card Interface"
+        depends on MMC_DW
+        select MMC_DW_PLTFM
+        help
+          This selects support for Samsung Exynos SoC specific extensions to the
+          Synopsys DesignWare Memory Card Interface driver. Select this option
+          for platforms based on Exynos4 and Exynos5 SoC's.
+
 config MMC_DW_PCI
         tristate "Synopsys Designware MCI support on PCI bus"
         depends on MMC_DW && PCI
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 8922b06be925..17ad0a7ba40b 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -39,6 +39,7 @@ obj-$(CONFIG_MMC_VIA_SDMMC)	+= via-sdmmc.o
 obj-$(CONFIG_SDH_BFIN)          += bfin_sdh.o
 obj-$(CONFIG_MMC_DW)            += dw_mmc.o
 obj-$(CONFIG_MMC_DW_PLTFM)      += dw_mmc-pltfm.o
+obj-$(CONFIG_MMC_DW_EXYNOS)     += dw_mmc-exynos.o
 obj-$(CONFIG_MMC_DW_PCI)        += dw_mmc-pci.o
 obj-$(CONFIG_MMC_SH_MMCIF)      += sh_mmcif.o
 obj-$(CONFIG_MMC_JZ4740)        += jz4740_mmc.o
diff --git a/drivers/mmc/host/atmel-mci-regs.h b/drivers/mmc/host/atmel-mci-regs.h
index ab56f7db5315..c97001e15227 100644
--- a/drivers/mmc/host/atmel-mci-regs.h
+++ b/drivers/mmc/host/atmel-mci-regs.h
@@ -140,6 +140,13 @@
 #define atmci_writel(port,reg,value)                    \
         __raw_writel((value), (port)->regs + reg)
 
+/* On AVR chips the Peripheral DMA Controller is not connected to MCI. */
+#ifdef CONFIG_AVR32
+#       define ATMCI_PDC_CONNECTED      0
+#else
+#       define ATMCI_PDC_CONNECTED      1
+#endif
+
 /*
  * Fix sconfig's burst size according to atmel MCI. We need to convert them as:
  * 1 -> 0, 4 -> 1, 8 -> 2, 16 -> 3.
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 852d5fbda630..ddf096e3803f 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -19,6 +19,9 @@
 #include <linux/interrupt.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/scatterlist.h>
 #include <linux/seq_file.h>
@@ -71,7 +74,7 @@ enum atmci_pdc_buf {
 };
 
 struct atmel_mci_caps {
-        bool    has_dma;
+        bool    has_dma_conf_reg;
         bool    has_pdc;
         bool    has_cfg_reg;
         bool    has_cstor_reg;
@@ -418,7 +421,7 @@ static int atmci_regs_show(struct seq_file *s, void *v)
         atmci_show_status_reg(s, "SR", buf[ATMCI_SR / 4]);
         atmci_show_status_reg(s, "IMR", buf[ATMCI_IMR / 4]);
 
-        if (host->caps.has_dma) {
+        if (host->caps.has_dma_conf_reg) {
                 u32 val;
 
                 val = buf[ATMCI_DMA / 4];
@@ -500,6 +503,70 @@ err:
         dev_err(&mmc->class_dev, "failed to initialize debugfs for slot\n");
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id atmci_dt_ids[] = {
+        { .compatible = "atmel,hsmci" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, atmci_dt_ids);
+
+static struct mci_platform_data __devinit*
+atmci_of_init(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct device_node *cnp;
+        struct mci_platform_data *pdata;
+        u32 slot_id;
+
+        if (!np) {
+                dev_err(&pdev->dev, "device node not found\n");
+                return ERR_PTR(-EINVAL);
+        }
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                dev_err(&pdev->dev, "could not allocate memory for pdata\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        for_each_child_of_node(np, cnp) {
+                if (of_property_read_u32(cnp, "reg", &slot_id)) {
+                        dev_warn(&pdev->dev, "reg property is missing for %s\n",
+                                 cnp->full_name);
+                        continue;
+                }
+
+                if (slot_id >= ATMCI_MAX_NR_SLOTS) {
+                        dev_warn(&pdev->dev, "can't have more than %d slots\n",
+                                 ATMCI_MAX_NR_SLOTS);
+                        break;
+                }
+
+                if (of_property_read_u32(cnp, "bus-width",
+                                         &pdata->slot[slot_id].bus_width))
+                        pdata->slot[slot_id].bus_width = 1;
+
+                pdata->slot[slot_id].detect_pin =
+                        of_get_named_gpio(cnp, "cd-gpios", 0);
+
+                pdata->slot[slot_id].detect_is_active_high =
+                        of_property_read_bool(cnp, "cd-inverted");
+
+                pdata->slot[slot_id].wp_pin =
+                        of_get_named_gpio(cnp, "wp-gpios", 0);
+        }
+
+        return pdata;
+}
+#else /* CONFIG_OF */
+static inline struct mci_platform_data*
+atmci_of_init(struct platform_device *dev)
+{
+        return ERR_PTR(-EINVAL);
+}
+#endif
+
 static inline unsigned int atmci_get_version(struct atmel_mci *host)
 {
         return atmci_readl(host, ATMCI_VERSION) & 0x00000fff;
@@ -774,7 +841,7 @@ static void atmci_dma_complete(void *arg)
 
         dev_vdbg(&host->pdev->dev, "DMA complete\n");
 
-        if (host->caps.has_dma)
+        if (host->caps.has_dma_conf_reg)
                 /* Disable DMA hardware handshaking on MCI */
                 atmci_writel(host, ATMCI_DMA, atmci_readl(host, ATMCI_DMA) & ~ATMCI_DMAEN);
 
@@ -961,7 +1028,9 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
                 maxburst = atmci_convert_chksize(host->dma_conf.dst_maxburst);
         }
 
-        atmci_writel(host, ATMCI_DMA, ATMCI_DMA_CHKSIZE(maxburst) | ATMCI_DMAEN);
+        if (host->caps.has_dma_conf_reg)
+                atmci_writel(host, ATMCI_DMA, ATMCI_DMA_CHKSIZE(maxburst) |
+                        ATMCI_DMAEN);
 
         sglen = dma_map_sg(chan->device->dev, data->sg,
                         data->sg_len, direction);
@@ -2046,6 +2115,13 @@ static int __init atmci_init_slot(struct atmel_mci *host,
         slot->sdc_reg = sdc_reg;
         slot->sdio_irq = sdio_irq;
 
+        dev_dbg(&mmc->class_dev,
+                "slot[%u]: bus_width=%u, detect_pin=%d, "
+                "detect_is_active_high=%s, wp_pin=%d\n",
+                id, slot_data->bus_width, slot_data->detect_pin,
+                slot_data->detect_is_active_high ? "true" : "false",
+                slot_data->wp_pin);
+
         mmc->ops = &atmci_ops;
         mmc->f_min = DIV_ROUND_UP(host->bus_hz, 512);
         mmc->f_max = host->bus_hz / 2;
@@ -2169,7 +2245,10 @@ static bool atmci_configure_dma(struct atmel_mci *host)
 
         pdata = host->pdev->dev.platform_data;
 
-        if (pdata && find_slave_dev(pdata->dma_slave)) {
+        if (!pdata)
+                return false;
+
+        if (pdata->dma_slave && find_slave_dev(pdata->dma_slave)) {
                 dma_cap_mask_t mask;
 
                 /* Try to grab a DMA channel */
@@ -2210,8 +2289,8 @@ static void __init atmci_get_cap(struct atmel_mci *host)
         dev_info(&host->pdev->dev,
                         "version: 0x%x\n", version);
 
-        host->caps.has_dma = 0;
-        host->caps.has_pdc = 1;
+        host->caps.has_dma_conf_reg = 0;
+        host->caps.has_pdc = ATMCI_PDC_CONNECTED;
         host->caps.has_cfg_reg = 0;
         host->caps.has_cstor_reg = 0;
         host->caps.has_highspeed = 0;
@@ -2228,12 +2307,7 @@ static void __init atmci_get_cap(struct atmel_mci *host)
                 host->caps.has_odd_clk_div = 1;
         case 0x400:
         case 0x300:
-#ifdef CONFIG_AT_HDMAC
-                host->caps.has_dma = 1;
-#else
-                dev_info(&host->pdev->dev,
-                        "has dma capability but dma engine is not selected, then use pio\n");
-#endif
+                host->caps.has_dma_conf_reg = 1;
                 host->caps.has_pdc = 0;
                 host->caps.has_cfg_reg = 1;
                 host->caps.has_cstor_reg = 1;
@@ -2268,8 +2342,14 @@ static int __init atmci_probe(struct platform_device *pdev)
         if (!regs)
                 return -ENXIO;
         pdata = pdev->dev.platform_data;
-        if (!pdata)
-                return -ENXIO;
+        if (!pdata) {
+                pdata = atmci_of_init(pdev);
+                if (IS_ERR(pdata)) {
+                        dev_err(&pdev->dev, "platform data not available\n");
+                        return PTR_ERR(pdata);
+                }
+        }
+
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
                 return irq;
@@ -2308,7 +2388,7 @@ static int __init atmci_probe(struct platform_device *pdev)
 
         /* Get MCI capabilities and set operations according to it */
         atmci_get_cap(host);
-        if (host->caps.has_dma && atmci_configure_dma(host)) {
+        if (atmci_configure_dma(host)) {
                 host->prepare_data = &atmci_prepare_data_dma;
                 host->submit_data = &atmci_submit_data_dma;
                 host->stop_transfer = &atmci_stop_transfer_dma;
@@ -2487,6 +2567,7 @@ static struct platform_driver atmci_driver = {
         .driver         = {
                 .name           = "atmel_mci",
                 .pm             = ATMCI_PM_OPS,
+                .of_match_table = of_match_ptr(atmci_dt_ids),
         },
 };
 
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index a17dd7363ceb..b9b463eca1ec 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -24,9 +24,7 @@
 #include <asm/portmux.h>
 #include <asm/bfin_sdh.h>
 
-#if defined(CONFIG_BF51x)
-#define bfin_read_SDH_PWR_CTL           bfin_read_RSI_PWR_CTL
-#define bfin_write_SDH_PWR_CTL          bfin_write_RSI_PWR_CTL
+#if defined(CONFIG_BF51x) || defined(__ADSPBF60x__)
 #define bfin_read_SDH_CLK_CTL           bfin_read_RSI_CLK_CTL
 #define bfin_write_SDH_CLK_CTL          bfin_write_RSI_CLK_CTL
 #define bfin_write_SDH_ARGUMENT         bfin_write_RSI_ARGUMENT
@@ -45,8 +43,16 @@
 #define bfin_write_SDH_E_STATUS         bfin_write_RSI_E_STATUS
 #define bfin_read_SDH_STATUS            bfin_read_RSI_STATUS
 #define bfin_write_SDH_MASK0            bfin_write_RSI_MASK0
+#define bfin_write_SDH_E_MASK           bfin_write_RSI_E_MASK
 #define bfin_read_SDH_CFG               bfin_read_RSI_CFG
 #define bfin_write_SDH_CFG              bfin_write_RSI_CFG
+# if defined(__ADSPBF60x__)
+#  define bfin_read_SDH_BLK_SIZE        bfin_read_RSI_BLKSZ
+#  define bfin_write_SDH_BLK_SIZE       bfin_write_RSI_BLKSZ
+# else
+#  define bfin_read_SDH_PWR_CTL         bfin_read_RSI_PWR_CTL
+#  define bfin_write_SDH_PWR_CTL        bfin_write_RSI_PWR_CTL
+# endif
 #endif
 
 struct sdh_host {
@@ -62,6 +68,7 @@ struct sdh_host {
         dma_addr_t              sg_dma;
         int                     dma_len;
 
+        unsigned long           sclk;
         unsigned int            imask;
         unsigned int            power_mode;
         unsigned int            clk_div;
@@ -127,11 +134,15 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
         /* Only supports power-of-2 block size */
         if (data->blksz & (data->blksz - 1))
                 return -EINVAL;
+#ifndef RSI_BLKSZ
         data_ctl |= ((ffs(data->blksz) - 1) << 4);
+#else
+        bfin_write_SDH_BLK_SIZE(data->blksz);
+#endif
 
         bfin_write_SDH_DATA_CTL(data_ctl);
         /* the time of a host clock period in ns */
-        cycle_ns = 1000000000 / (get_sclk() / (2 * (host->clk_div + 1)));
+        cycle_ns = 1000000000 / (host->sclk / (2 * (host->clk_div + 1)));
         timeout = data->timeout_ns / cycle_ns;
         timeout += data->timeout_clks;
         bfin_write_SDH_DATA_TIMER(timeout);
@@ -145,8 +156,13 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
 
         sdh_enable_stat_irq(host, (DAT_CRC_FAIL | DAT_TIME_OUT | DAT_END));
         host->dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma_dir);
-#if defined(CONFIG_BF54x)
-        dma_cfg |= DMAFLOW_ARRAY | NDSIZE_5 | RESTART | WDSIZE_32 | DMAEN;
+#if defined(CONFIG_BF54x) || defined(CONFIG_BF60x)
+        dma_cfg |= DMAFLOW_ARRAY | RESTART | WDSIZE_32 | DMAEN;
+# ifdef RSI_BLKSZ
+        dma_cfg |= PSIZE_32 | NDSIZE_3;
+# else
+        dma_cfg |= NDSIZE_5;
+# endif
         {
                 struct scatterlist *sg;
                 int i;
@@ -156,7 +172,7 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
                         host->sg_cpu[i].x_count = sg_dma_len(sg) / 4;
                         host->sg_cpu[i].x_modify = 4;
                         dev_dbg(mmc_dev(host->mmc), "%d: start_addr:0x%lx, "
-                                "cfg:0x%x, x_count:0x%x, x_modify:0x%x\n",
+                                "cfg:0x%lx, x_count:0x%lx, x_modify:0x%lx\n",
                                 i, host->sg_cpu[i].start_addr,
                                 host->sg_cpu[i].cfg, host->sg_cpu[i].x_count,
                                 host->sg_cpu[i].x_modify);
@@ -172,6 +188,7 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
         set_dma_curr_desc_addr(host->dma_ch, (unsigned long *)host->sg_dma);
         set_dma_x_count(host->dma_ch, 0);
         set_dma_x_modify(host->dma_ch, 0);
+        SSYNC();
         set_dma_config(host->dma_ch, dma_cfg);
 #elif defined(CONFIG_BF51x)
         /* RSI DMA doesn't work in array mode */
@@ -179,6 +196,7 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
         set_dma_start_addr(host->dma_ch, sg_dma_address(&data->sg[0]));
         set_dma_x_count(host->dma_ch, length / 4);
         set_dma_x_modify(host->dma_ch, 4);
+        SSYNC();
         set_dma_config(host->dma_ch, dma_cfg);
 #endif
         bfin_write_SDH_DATA_CTL(bfin_read_SDH_DATA_CTL() | DTX_DMA_E | DTX_E);
@@ -296,7 +314,6 @@ static int sdh_data_done(struct sdh_host *host, unsigned int stat)
         else
                 data->bytes_xfered = 0;
 
-        sdh_disable_stat_irq(host, DAT_END | DAT_TIME_OUT | DAT_CRC_FAIL | RX_OVERRUN | TX_UNDERRUN);
         bfin_write_SDH_STATUS_CLR(DAT_END_STAT | DAT_TIMEOUT_STAT | \
                         DAT_CRC_FAIL_STAT | DAT_BLK_END_STAT | RX_OVERRUN | TX_UNDERRUN);
         bfin_write_SDH_DATA_CTL(0);
@@ -321,74 +338,115 @@ static void sdh_request(struct mmc_host *mmc, struct mmc_request *mrq)
         dev_dbg(mmc_dev(host->mmc), "%s enter, mrp:%p, cmd:%p\n", __func__, mrq, mrq->cmd);
         WARN_ON(host->mrq != NULL);
 
+        spin_lock(&host->lock);
         host->mrq = mrq;
         host->data = mrq->data;
 
         if (mrq->data && mrq->data->flags & MMC_DATA_READ) {
                 ret = sdh_setup_data(host, mrq->data);
                 if (ret)
-                        return;
+                        goto data_err;
         }
 
         sdh_start_cmd(host, mrq->cmd);
+data_err:
+        spin_unlock(&host->lock);
 }
 
 static void sdh_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct sdh_host *host;
-        unsigned long flags;
         u16 clk_ctl = 0;
+#ifndef RSI_BLKSZ
         u16 pwr_ctl = 0;
+#endif
         u16 cfg;
         host = mmc_priv(mmc);
 
-        spin_lock_irqsave(&host->lock, flags);
-        if (ios->clock) {
-                unsigned long  sys_clk, ios_clk;
-                unsigned char clk_div;
-                ios_clk = 2 * ios->clock;
-                sys_clk = get_sclk();
-                clk_div = sys_clk / ios_clk;
-                if (sys_clk % ios_clk == 0)
-                        clk_div -= 1;
-                clk_div = min_t(unsigned char, clk_div, 0xFF);
-                clk_ctl |= clk_div;
-                clk_ctl |= CLK_E;
-                host->clk_div = clk_div;
-        } else
-                sdh_stop_clock(host);
-
-        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
-#ifdef CONFIG_SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
-                pwr_ctl |= ROD_CTL;
-#else
-                pwr_ctl |= SD_CMD_OD | ROD_CTL;
-#endif
+        spin_lock(&host->lock);
 
-        if (ios->bus_width == MMC_BUS_WIDTH_4) {
-                cfg = bfin_read_SDH_CFG();
+        cfg = bfin_read_SDH_CFG();
+        cfg |= MWE;
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_4:
+#ifndef RSI_BLKSZ
                 cfg &= ~PD_SDDAT3;
+#endif
                 cfg |= PUP_SDDAT3;
                 /* Enable 4 bit SDIO */
-                cfg |= (SD4E | MWE);
-                bfin_write_SDH_CFG(cfg);
-                clk_ctl |= WIDE_BUS;
-        } else {
-                cfg = bfin_read_SDH_CFG();
-                cfg |= MWE;
-                bfin_write_SDH_CFG(cfg);
+                cfg |= SD4E;
+                clk_ctl |= WIDE_BUS_4;
+                break;
+        case MMC_BUS_WIDTH_8:
+#ifndef RSI_BLKSZ
+                cfg &= ~PD_SDDAT3;
+#endif
+                cfg |= PUP_SDDAT3;
+                /* Disable 4 bit SDIO */
+                cfg &= ~SD4E;
+                clk_ctl |= BYTE_BUS_8;
+                break;
+        default:
+                cfg &= ~PUP_SDDAT3;
+                /* Disable 4 bit SDIO */
+                cfg &= ~SD4E;
         }
 
-        bfin_write_SDH_CLK_CTL(clk_ctl);
-
         host->power_mode = ios->power_mode;
-        if (ios->power_mode == MMC_POWER_ON)
+#ifndef RSI_BLKSZ
+        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) {
+                pwr_ctl |= ROD_CTL;
+# ifndef CONFIG_SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
+                pwr_ctl |= SD_CMD_OD;
+# endif
+        }
+
+        if (ios->power_mode != MMC_POWER_OFF)
                 pwr_ctl |= PWR_ON;
+        else
+                pwr_ctl &= ~PWR_ON;
 
         bfin_write_SDH_PWR_CTL(pwr_ctl);
+#else
+# ifndef CONFIG_SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
+        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
+                cfg |= SD_CMD_OD;
+        else
+                cfg &= ~SD_CMD_OD;
+# endif
+
+
+        if (ios->power_mode != MMC_POWER_OFF)
+                cfg |= PWR_ON;
+        else
+                cfg &= ~PWR_ON;
+
+        bfin_write_SDH_CFG(cfg);
+#endif
         SSYNC();
 
-        spin_unlock_irqrestore(&host->lock, flags);
+        if (ios->power_mode == MMC_POWER_ON && ios->clock) {
+                unsigned char clk_div;
+                clk_div = (get_sclk() / ios->clock - 1) / 2;
+                clk_div = min_t(unsigned char, clk_div, 0xFF);
+                clk_ctl |= clk_div;
+                clk_ctl |= CLK_E;
+                host->clk_div = clk_div;
+                bfin_write_SDH_CLK_CTL(clk_ctl);
+
+        } else
+                sdh_stop_clock(host);
+
+        /* set up sdh interrupt mask*/
+        if (ios->power_mode == MMC_POWER_ON)
+                bfin_write_SDH_MASK0(DAT_END | DAT_TIME_OUT | DAT_CRC_FAIL |
+                        RX_OVERRUN | TX_UNDERRUN | CMD_SENT | CMD_RESP_END |
+                        CMD_TIME_OUT | CMD_CRC_FAIL);
+        else
+                bfin_write_SDH_MASK0(0);
+        SSYNC();
+
+        spin_unlock(&host->lock);
 
         dev_dbg(mmc_dev(host->mmc), "SDH: clk_div = 0x%x actual clock:%ld expected clock:%d\n",
                 host->clk_div,
@@ -405,7 +463,7 @@ static irqreturn_t sdh_dma_irq(int irq, void *devid)
 {
         struct sdh_host *host = devid;
 
-        dev_dbg(mmc_dev(host->mmc), "%s enter, irq_stat: 0x%04x\n", __func__,
+        dev_dbg(mmc_dev(host->mmc), "%s enter, irq_stat: 0x%04lx\n", __func__,
                 get_dma_curr_irqstat(host->dma_ch));
         clear_dma_irqstat(host->dma_ch);
         SSYNC();
@@ -420,6 +478,9 @@ static irqreturn_t sdh_stat_irq(int irq, void *devid)
         int handled = 0;
 
         dev_dbg(mmc_dev(host->mmc), "%s enter\n", __func__);
+
+        spin_lock(&host->lock);
+
         status = bfin_read_SDH_E_STATUS();
         if (status & SD_CARD_DET) {
                 mmc_detect_change(host->mmc, 0);
@@ -437,11 +498,30 @@ static irqreturn_t sdh_stat_irq(int irq, void *devid)
         if (status & (DAT_END | DAT_TIME_OUT | DAT_CRC_FAIL | RX_OVERRUN | TX_UNDERRUN))
                 handled |= sdh_data_done(host, status);
 
+        spin_unlock(&host->lock);
+
         dev_dbg(mmc_dev(host->mmc), "%s exit\n\n", __func__);
 
         return IRQ_RETVAL(handled);
 }
 
+static void sdh_reset(void)
+{
+#if defined(CONFIG_BF54x)
+        /* Secure Digital Host shares DMA with Nand controller */
+        bfin_write_DMAC1_PERIMUX(bfin_read_DMAC1_PERIMUX() | 0x1);
+#endif
+
+        bfin_write_SDH_CFG(bfin_read_SDH_CFG() | CLKS_EN);
+        SSYNC();
+
+        /* Disable card inserting detection pin. set MMC_CAP_NEEDS_POLL, and
+         * mmc stack will do the detection.
+         */
+        bfin_write_SDH_CFG((bfin_read_SDH_CFG() & 0x1F) | (PUP_SDDAT | PUP_SDDAT3));
+        SSYNC();
+}
+
 static int __devinit sdh_probe(struct platform_device *pdev)
 {
         struct mmc_host *mmc;
@@ -462,8 +542,16 @@ static int __devinit sdh_probe(struct platform_device *pdev)
         }
 
         mmc->ops = &sdh_ops;
-        mmc->max_segs = 32;
+#if defined(CONFIG_BF51x)
+        mmc->max_segs = 1;
+#else
+        mmc->max_segs = PAGE_SIZE / sizeof(struct dma_desc_array);
+#endif
+#ifdef RSI_BLKSZ
+        mmc->max_seg_size = -1;
+#else
         mmc->max_seg_size = 1 << 16;
+#endif
         mmc->max_blk_size = 1 << 11;
         mmc->max_blk_count = 1 << 11;
         mmc->max_req_size = PAGE_SIZE;
@@ -473,6 +561,7 @@ static int __devinit sdh_probe(struct platform_device *pdev)
         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_NEEDS_POLL;
         host = mmc_priv(mmc);
         host->mmc = mmc;
+        host->sclk = get_sclk();
 
         spin_lock_init(&host->lock);
         host->irq = drv_data->irq_int0;
@@ -497,7 +586,6 @@ static int __devinit sdh_probe(struct platform_device *pdev)
         }
 
         platform_set_drvdata(pdev, mmc);
-        mmc_add_host(mmc);
 
         ret = request_irq(host->irq, sdh_stat_irq, 0, "SDH Status IRQ", host);
         if (ret) {
@@ -510,20 +598,10 @@ static int __devinit sdh_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "unable to request peripheral pins\n");
                 goto out4;
         }
-#if defined(CONFIG_BF54x)
-        /* Secure Digital Host shares DMA with Nand controller */
-        bfin_write_DMAC1_PERIMUX(bfin_read_DMAC1_PERIMUX() | 0x1);
-#endif
-
-        bfin_write_SDH_CFG(bfin_read_SDH_CFG() | CLKS_EN);
-        SSYNC();
 
-        /* Disable card inserting detection pin. set MMC_CAP_NEES_POLL, and
-         * mmc stack will do the detection.
-         */
-        bfin_write_SDH_CFG((bfin_read_SDH_CFG() & 0x1F) | (PUP_SDDAT | PUP_SDDAT3));
-        SSYNC();
+        sdh_reset();
 
+        mmc_add_host(mmc);
         return 0;
 
 out4:
@@ -571,7 +649,6 @@ static int sdh_suspend(struct platform_device *dev, pm_message_t state)
         if (mmc)
                 ret = mmc_suspend_host(mmc);
 
-        bfin_write_SDH_PWR_CTL(bfin_read_SDH_PWR_CTL() & ~PWR_ON);
         peripheral_free_list(drv_data->pin_req);
 
         return ret;
@@ -589,16 +666,7 @@ static int sdh_resume(struct platform_device *dev)
                 return ret;
         }
 
-        bfin_write_SDH_PWR_CTL(bfin_read_SDH_PWR_CTL() | PWR_ON);
-#if defined(CONFIG_BF54x)
-        /* Secure Digital Host shares DMA with Nand controller */
-        bfin_write_DMAC1_PERIMUX(bfin_read_DMAC1_PERIMUX() | 0x1);
-#endif
-        bfin_write_SDH_CFG(bfin_read_SDH_CFG() | CLKS_EN);
-        SSYNC();
-
-        bfin_write_SDH_CFG((bfin_read_SDH_CFG() & 0x1F) | (PUP_SDDAT | PUP_SDDAT3));
-        SSYNC();
+        sdh_reset();
 
         if (mmc)
                 ret = mmc_resume_host(mmc);
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index 3dfd3473269d..20636772c09b 100644
--- a/drivers/mmc/host/davinci_mmc.c
+++ b/drivers/mmc/host/davinci_mmc.c
@@ -30,11 +30,12 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/delay.h>
+#include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
+#include <linux/edma.h>
 #include <linux/mmc/mmc.h>
 
 #include <linux/platform_data/mmc-davinci.h>
-#include <mach/edma.h>
 
 /*
  * Register Definitions
@@ -200,21 +201,13 @@ struct mmc_davinci_host {
         u32 bytes_left;
 
         u32 rxdma, txdma;
+        struct dma_chan *dma_tx;
+        struct dma_chan *dma_rx;
         bool use_dma;
         bool do_dma;
         bool sdio_int;
         bool active_request;
 
-        /* Scatterlist DMA uses one or more parameter RAM entries:
-         * the main one (associated with rxdma or txdma) plus zero or
-         * more links.  The entries for a given transfer differ only
-         * by memory buffer (address, length) and link field.
-         */
-        struct edmacc_param     tx_template;
-        struct edmacc_param     rx_template;
-        unsigned                n_link;
-        u32                     links[MAX_NR_SG - 1];
-
         /* For PIO we walk scatterlists one segment at a time. */
         unsigned int            sg_len;
         struct scatterlist *sg;
@@ -410,153 +403,74 @@ static void mmc_davinci_start_command(struct mmc_davinci_host *host,
 
 static void davinci_abort_dma(struct mmc_davinci_host *host)
 {
-        int sync_dev;
+        struct dma_chan *sync_dev;
 
         if (host->data_dir == DAVINCI_MMC_DATADIR_READ)
-                sync_dev = host->rxdma;
+                sync_dev = host->dma_rx;
         else
-                sync_dev = host->txdma;
-
-        edma_stop(sync_dev);
-        edma_clean_channel(sync_dev);
-}
-
-static void
-mmc_davinci_xfer_done(struct mmc_davinci_host *host, struct mmc_data *data);
-
-static void mmc_davinci_dma_cb(unsigned channel, u16 ch_status, void *data)
-{
-        if (DMA_COMPLETE != ch_status) {
-                struct mmc_davinci_host *host = data;
-
-                /* Currently means:  DMA Event Missed, or "null" transfer
-                 * request was seen.  In the future, TC errors (like bad
-                 * addresses) might be presented too.
-                 */
-                dev_warn(mmc_dev(host->mmc), "DMA %s error\n",
-                        (host->data->flags & MMC_DATA_WRITE)
-                                ? "write" : "read");
-                host->data->error = -EIO;
-                mmc_davinci_xfer_done(host, host->data);
-        }
-}
-
-/* Set up tx or rx template, to be modified and updated later */
-static void __init mmc_davinci_dma_setup(struct mmc_davinci_host *host,
-                bool tx, struct edmacc_param *template)
-{
-        unsigned        sync_dev;
-        const u16       acnt = 4;
-        const u16       bcnt = rw_threshold >> 2;
-        const u16       ccnt = 0;
-        u32             src_port = 0;
-        u32             dst_port = 0;
-        s16             src_bidx, dst_bidx;
-        s16             src_cidx, dst_cidx;
-
-        /*
-         * A-B Sync transfer:  each DMA request is for one "frame" of
-         * rw_threshold bytes, broken into "acnt"-size chunks repeated
-         * "bcnt" times.  Each segment needs "ccnt" such frames; since
-         * we tell the block layer our mmc->max_seg_size limit, we can
-         * trust (later) that it's within bounds.
-         *
-         * The FIFOs are read/written in 4-byte chunks (acnt == 4) and
-         * EDMA will optimize memory operations to use larger bursts.
-         */
-        if (tx) {
-                sync_dev = host->txdma;
-
-                /* src_prt, ccnt, and link to be set up later */
-                src_bidx = acnt;
-                src_cidx = acnt * bcnt;
-
-                dst_port = host->mem_res->start + DAVINCI_MMCDXR;
-                dst_bidx = 0;
-                dst_cidx = 0;
-        } else {
-                sync_dev = host->rxdma;
-
-                src_port = host->mem_res->start + DAVINCI_MMCDRR;
-                src_bidx = 0;
-                src_cidx = 0;
-
-                /* dst_prt, ccnt, and link to be set up later */
-                dst_bidx = acnt;
-                dst_cidx = acnt * bcnt;
-        }
-
-        /*
-         * We can't use FIFO mode for the FIFOs because MMC FIFO addresses
-         * are not 256-bit (32-byte) aligned.  So we use INCR, and the W8BIT
-         * parameter is ignored.
-         */
-        edma_set_src(sync_dev, src_port, INCR, W8BIT);
-        edma_set_dest(sync_dev, dst_port, INCR, W8BIT);
+                sync_dev = host->dma_tx;
 
-        edma_set_src_index(sync_dev, src_bidx, src_cidx);
-        edma_set_dest_index(sync_dev, dst_bidx, dst_cidx);
-
-        edma_set_transfer_params(sync_dev, acnt, bcnt, ccnt, 8, ABSYNC);
-
-        edma_read_slot(sync_dev, template);
-
-        /* don't bother with irqs or chaining */
-        template->opt |= EDMA_CHAN_SLOT(sync_dev) << 12;
+        dmaengine_terminate_all(sync_dev);
 }
 
-static void mmc_davinci_send_dma_request(struct mmc_davinci_host *host,
+static int mmc_davinci_send_dma_request(struct mmc_davinci_host *host,
                 struct mmc_data *data)
 {
-        struct edmacc_param     *template;
-        int                     channel, slot;
-        unsigned                link;
-        struct scatterlist      *sg;
-        unsigned                sg_len;
-        unsigned                bytes_left = host->bytes_left;
-        const unsigned          shift = ffs(rw_threshold) - 1;
+        struct dma_chan *chan;
+        struct dma_async_tx_descriptor *desc;
+        int ret = 0;
 
         if (host->data_dir == DAVINCI_MMC_DATADIR_WRITE) {
-                template = &host->tx_template;
-                channel = host->txdma;
+                struct dma_slave_config dma_tx_conf = {
+                        .direction = DMA_MEM_TO_DEV,
+                        .dst_addr = host->mem_res->start + DAVINCI_MMCDXR,
+                        .dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
+                        .dst_maxburst =
+                                rw_threshold / DMA_SLAVE_BUSWIDTH_4_BYTES,
+                };
+                chan = host->dma_tx;
+                dmaengine_slave_config(host->dma_tx, &dma_tx_conf);
+
+                desc = dmaengine_prep_slave_sg(host->dma_tx,
+                                data->sg,
+                                host->sg_len,
+                                DMA_MEM_TO_DEV,
+                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                if (!desc) {
+                        dev_dbg(mmc_dev(host->mmc),
+                                "failed to allocate DMA TX descriptor");
+                        ret = -1;
+                        goto out;
+                }
         } else {
-                template = &host->rx_template;
-                channel = host->rxdma;
-        }
-
-        /* We know sg_len and ccnt will never be out of range because
-         * we told the mmc layer which in turn tells the block layer
-         * to ensure that it only hands us one scatterlist segment
-         * per EDMA PARAM entry.  Update the PARAM
-         * entries needed for each segment of this scatterlist.
-         */
-        for (slot = channel, link = 0, sg = data->sg, sg_len = host->sg_len;
-                        sg_len-- != 0 && bytes_left;
-                        sg = sg_next(sg), slot = host->links[link++]) {
-                u32             buf = sg_dma_address(sg);
-                unsigned        count = sg_dma_len(sg);
-
-                template->link_bcntrld = sg_len
-                                ? (EDMA_CHAN_SLOT(host->links[link]) << 5)
-                                : 0xffff;
-
-                if (count > bytes_left)
-                        count = bytes_left;
-                bytes_left -= count;
-
-                if (host->data_dir == DAVINCI_MMC_DATADIR_WRITE)
-                        template->src = buf;
-                else
-                        template->dst = buf;
-                template->ccnt = count >> shift;
-
-                edma_write_slot(slot, template);
+                struct dma_slave_config dma_rx_conf = {
+                        .direction = DMA_DEV_TO_MEM,
+                        .src_addr = host->mem_res->start + DAVINCI_MMCDRR,
+                        .src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
+                        .src_maxburst =
+                                rw_threshold / DMA_SLAVE_BUSWIDTH_4_BYTES,
+                };
+                chan = host->dma_rx;
+                dmaengine_slave_config(host->dma_rx, &dma_rx_conf);
+
+                desc = dmaengine_prep_slave_sg(host->dma_rx,
+                                data->sg,
+                                host->sg_len,
+                                DMA_DEV_TO_MEM,
+                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                if (!desc) {
+                        dev_dbg(mmc_dev(host->mmc),
+                                "failed to allocate DMA RX descriptor");
+                        ret = -1;
+                        goto out;
+                }
         }
 
-        if (host->version == MMC_CTLR_VERSION_2)
-                edma_clear_event(channel);
+        dmaengine_submit(desc);
+        dma_async_issue_pending(chan);
 
-        edma_start(channel);
+out:
+        return ret;
 }
 
 static int mmc_davinci_start_dma_transfer(struct mmc_davinci_host *host,
@@ -564,6 +478,7 @@ static int mmc_davinci_start_dma_transfer(struct mmc_davinci_host *host,
 {
         int i;
         int mask = rw_threshold - 1;
+        int ret = 0;
 
         host->sg_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
                                 ((data->flags & MMC_DATA_WRITE)
@@ -583,70 +498,48 @@ static int mmc_davinci_start_dma_transfer(struct mmc_davinci_host *host,
         }
 
         host->do_dma = 1;
-        mmc_davinci_send_dma_request(host, data);
+        ret = mmc_davinci_send_dma_request(host, data);
 
-        return 0;
+        return ret;
 }
 
 static void __init_or_module
 davinci_release_dma_channels(struct mmc_davinci_host *host)
 {
-        unsigned        i;
-
         if (!host->use_dma)
                 return;
 
-        for (i = 0; i < host->n_link; i++)
-                edma_free_slot(host->links[i]);
-
-        edma_free_channel(host->txdma);
-        edma_free_channel(host->rxdma);
+        dma_release_channel(host->dma_tx);
+        dma_release_channel(host->dma_rx);
 }
 
 static int __init davinci_acquire_dma_channels(struct mmc_davinci_host *host)
 {
-        u32 link_size;
-        int r, i;
-
-        /* Acquire master DMA write channel */
-        r = edma_alloc_channel(host->txdma, mmc_davinci_dma_cb, host,
-                        EVENTQ_DEFAULT);
-        if (r < 0) {
-                dev_warn(mmc_dev(host->mmc), "alloc %s channel err %d\n",
-                                "tx", r);
-                return r;
-        }
-        mmc_davinci_dma_setup(host, true, &host->tx_template);
-
-        /* Acquire master DMA read channel */
-        r = edma_alloc_channel(host->rxdma, mmc_davinci_dma_cb, host,
-                        EVENTQ_DEFAULT);
-        if (r < 0) {
-                dev_warn(mmc_dev(host->mmc), "alloc %s channel err %d\n",
-                                "rx", r);
-                goto free_master_write;
+        int r;
+        dma_cap_mask_t mask;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        host->dma_tx =
+                dma_request_channel(mask, edma_filter_fn, &host->txdma);
+        if (!host->dma_tx) {
+                dev_err(mmc_dev(host->mmc), "Can't get dma_tx channel\n");
+                return -ENODEV;
         }
-        mmc_davinci_dma_setup(host, false, &host->rx_template);
 
-        /* Allocate parameter RAM slots, which will later be bound to a
-         * channel as needed to handle a scatterlist.
-         */
-        link_size = min_t(unsigned, host->nr_sg, ARRAY_SIZE(host->links));
-        for (i = 0; i < link_size; i++) {
-                r = edma_alloc_slot(EDMA_CTLR(host->txdma), EDMA_SLOT_ANY);
-                if (r < 0) {
-                        dev_dbg(mmc_dev(host->mmc), "dma PaRAM alloc --> %d\n",
-                                r);
-                        break;
-                }
-                host->links[i] = r;
+        host->dma_rx =
+                dma_request_channel(mask, edma_filter_fn, &host->rxdma);
+        if (!host->dma_rx) {
+                dev_err(mmc_dev(host->mmc), "Can't get dma_rx channel\n");
+                r = -ENODEV;
+                goto free_master_write;
         }
-        host->n_link = i;
 
         return 0;
 
 free_master_write:
-        edma_free_channel(host->txdma);
+        dma_release_channel(host->dma_tx);
 
         return r;
 }
@@ -1359,7 +1252,7 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
          * Each hw_seg uses one EDMA parameter RAM slot, always one
          * channel and then usually some linked slots.
          */
-        mmc->max_segs           = 1 + host->n_link;
+        mmc->max_segs           = MAX_NR_SG;
 
         /* EDMA limit per hw segment (one or two MBytes) */
         mmc->max_seg_size       = MAX_CCNT * rw_threshold;
diff --git a/drivers/mmc/host/dw_mmc-exynos.c b/drivers/mmc/host/dw_mmc-exynos.c
new file mode 100644
index 000000000000..660bbc528862
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc-exynos.c
@@ -0,0 +1,253 @@
+/*
+ * Exynos Specific Extensions for Synopsys DW Multimedia Card Interface driver
+ *
+ * Copyright (C) 2012, Samsung Electronics Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/dw_mmc.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+
+#include "dw_mmc.h"
+#include "dw_mmc-pltfm.h"
+
+#define NUM_PINS(x)                     (x + 2)
+
+#define SDMMC_CLKSEL                    0x09C
+#define SDMMC_CLKSEL_CCLK_SAMPLE(x)     (((x) & 7) << 0)
+#define SDMMC_CLKSEL_CCLK_DRIVE(x)      (((x) & 7) << 16)
+#define SDMMC_CLKSEL_CCLK_DIVIDER(x)    (((x) & 7) << 24)
+#define SDMMC_CLKSEL_GET_DRV_WD3(x)     (((x) >> 16) & 0x7)
+#define SDMMC_CLKSEL_TIMING(x, y, z)    (SDMMC_CLKSEL_CCLK_SAMPLE(x) |  \
+                                        SDMMC_CLKSEL_CCLK_DRIVE(y) |    \
+                                        SDMMC_CLKSEL_CCLK_DIVIDER(z))
+
+#define SDMMC_CMD_USE_HOLD_REG          BIT(29)
+
+#define EXYNOS4210_FIXED_CIU_CLK_DIV    2
+#define EXYNOS4412_FIXED_CIU_CLK_DIV    4
+
+/* Variations in Exynos specific dw-mshc controller */
+enum dw_mci_exynos_type {
+        DW_MCI_TYPE_EXYNOS4210,
+        DW_MCI_TYPE_EXYNOS4412,
+        DW_MCI_TYPE_EXYNOS5250,
+};
+
+/* Exynos implementation specific driver private data */
+struct dw_mci_exynos_priv_data {
+        enum dw_mci_exynos_type         ctrl_type;
+        u8                              ciu_div;
+        u32                             sdr_timing;
+        u32                             ddr_timing;
+};
+
+static struct dw_mci_exynos_compatible {
+        char                            *compatible;
+        enum dw_mci_exynos_type         ctrl_type;
+} exynos_compat[] = {
+        {
+                .compatible     = "samsung,exynos4210-dw-mshc",
+                .ctrl_type      = DW_MCI_TYPE_EXYNOS4210,
+        }, {
+                .compatible     = "samsung,exynos4412-dw-mshc",
+                .ctrl_type      = DW_MCI_TYPE_EXYNOS4412,
+        }, {
+                .compatible     = "samsung,exynos5250-dw-mshc",
+                .ctrl_type      = DW_MCI_TYPE_EXYNOS5250,
+        },
+};
+
+static int dw_mci_exynos_priv_init(struct dw_mci *host)
+{
+        struct dw_mci_exynos_priv_data *priv;
+        int idx;
+
+        priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(host->dev, "mem alloc failed for private data\n");
+                return -ENOMEM;
+        }
+
+        for (idx = 0; idx < ARRAY_SIZE(exynos_compat); idx++) {
+                if (of_device_is_compatible(host->dev->of_node,
+                                        exynos_compat[idx].compatible))
+                        priv->ctrl_type = exynos_compat[idx].ctrl_type;
+        }
+
+        host->priv = priv;
+        return 0;
+}
+
+static int dw_mci_exynos_setup_clock(struct dw_mci *host)
+{
+        struct dw_mci_exynos_priv_data *priv = host->priv;
+
+        if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS5250)
+                host->bus_hz /= (priv->ciu_div + 1);
+        else if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4412)
+                host->bus_hz /= EXYNOS4412_FIXED_CIU_CLK_DIV;
+        else if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4210)
+                host->bus_hz /= EXYNOS4210_FIXED_CIU_CLK_DIV;
+
+        return 0;
+}
+
+static void dw_mci_exynos_prepare_command(struct dw_mci *host, u32 *cmdr)
+{
+        /*
+         * Exynos4412 and Exynos5250 extends the use of CMD register with the
+         * use of bit 29 (which is reserved on standard MSHC controllers) for
+         * optionally bypassing the HOLD register for command and data. The
+         * HOLD register should be bypassed in case there is no phase shift
+         * applied on CMD/DATA that is sent to the card.
+         */
+        if (SDMMC_CLKSEL_GET_DRV_WD3(mci_readl(host, CLKSEL)))
+                *cmdr |= SDMMC_CMD_USE_HOLD_REG;
+}
+
+static void dw_mci_exynos_set_ios(struct dw_mci *host, struct mmc_ios *ios)
+{
+        struct dw_mci_exynos_priv_data *priv = host->priv;
+
+        if (ios->timing == MMC_TIMING_UHS_DDR50)
+                mci_writel(host, CLKSEL, priv->ddr_timing);
+        else
+                mci_writel(host, CLKSEL, priv->sdr_timing);
+}
+
+static int dw_mci_exynos_parse_dt(struct dw_mci *host)
+{
+        struct dw_mci_exynos_priv_data *priv = host->priv;
+        struct device_node *np = host->dev->of_node;
+        u32 timing[2];
+        u32 div = 0;
+        int ret;
+
+        of_property_read_u32(np, "samsung,dw-mshc-ciu-div", &div);
+        priv->ciu_div = div;
+
+        ret = of_property_read_u32_array(np,
+                        "samsung,dw-mshc-sdr-timing", timing, 2);
+        if (ret)
+                return ret;
+
+        priv->sdr_timing = SDMMC_CLKSEL_TIMING(timing[0], timing[1], div);
+
+        ret = of_property_read_u32_array(np,
+                        "samsung,dw-mshc-ddr-timing", timing, 2);
+        if (ret)
+                return ret;
+
+        priv->ddr_timing = SDMMC_CLKSEL_TIMING(timing[0], timing[1], div);
+        return 0;
+}
+
+static int dw_mci_exynos_setup_bus(struct dw_mci *host,
+                                struct device_node *slot_np, u8 bus_width)
+{
+        int idx, gpio, ret;
+
+        if (!slot_np)
+                return -EINVAL;
+
+        /* cmd + clock + bus-width pins */
+        for (idx = 0; idx < NUM_PINS(bus_width); idx++) {
+                gpio = of_get_gpio(slot_np, idx);
+                if (!gpio_is_valid(gpio)) {
+                        dev_err(host->dev, "invalid gpio: %d\n", gpio);
+                        return -EINVAL;
+                }
+
+                ret = devm_gpio_request(host->dev, gpio, "dw-mci-bus");
+                if (ret) {
+                        dev_err(host->dev, "gpio [%d] request failed\n", gpio);
+                        return -EBUSY;
+                }
+        }
+
+        gpio = of_get_named_gpio(slot_np, "wp-gpios", 0);
+        if (gpio_is_valid(gpio)) {
+                if (devm_gpio_request(host->dev, gpio, "dw-mci-wp"))
+                        dev_info(host->dev, "gpio [%d] request failed\n",
+                                                gpio);
+        } else {
+                dev_info(host->dev, "wp gpio not available");
+                host->pdata->quirks |= DW_MCI_QUIRK_NO_WRITE_PROTECT;
+        }
+
+        if (host->pdata->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION)
+                return 0;
+
+        gpio = of_get_named_gpio(slot_np, "samsung,cd-pinmux-gpio", 0);
+        if (gpio_is_valid(gpio)) {
+                if (devm_gpio_request(host->dev, gpio, "dw-mci-cd"))
+                        dev_err(host->dev, "gpio [%d] request failed\n", gpio);
+        } else {
+                dev_info(host->dev, "cd gpio not available");
+        }
+
+        return 0;
+}
+
+/* Exynos5250 controller specific capabilities */
+static unsigned long exynos5250_dwmmc_caps[4] = {
+        MMC_CAP_UHS_DDR50 | MMC_CAP_1_8V_DDR |
+                MMC_CAP_8_BIT_DATA | MMC_CAP_CMD23,
+        MMC_CAP_CMD23,
+        MMC_CAP_CMD23,
+        MMC_CAP_CMD23,
+};
+
+static struct dw_mci_drv_data exynos5250_drv_data = {
+        .caps                   = exynos5250_dwmmc_caps,
+        .init                   = dw_mci_exynos_priv_init,
+        .setup_clock            = dw_mci_exynos_setup_clock,
+        .prepare_command        = dw_mci_exynos_prepare_command,
+        .set_ios                = dw_mci_exynos_set_ios,
+        .parse_dt               = dw_mci_exynos_parse_dt,
+        .setup_bus              = dw_mci_exynos_setup_bus,
+};
+
+static const struct of_device_id dw_mci_exynos_match[] = {
+        { .compatible = "samsung,exynos5250-dw-mshc",
+                        .data = (void *)&exynos5250_drv_data, },
+        {},
+};
+MODULE_DEVICE_TABLE(of, dw_mci_pltfm_match);
+
+int dw_mci_exynos_probe(struct platform_device *pdev)
+{
+        struct dw_mci_drv_data *drv_data;
+        const struct of_device_id *match;
+
+        match = of_match_node(dw_mci_exynos_match, pdev->dev.of_node);
+        drv_data = match->data;
+        return dw_mci_pltfm_register(pdev, drv_data);
+}
+
+static struct platform_driver dw_mci_exynos_pltfm_driver = {
+        .probe          = dw_mci_exynos_probe,
+        .remove         = __exit_p(dw_mci_pltfm_remove),
+        .driver         = {
+                .name           = "dwmmc_exynos",
+                .of_match_table = of_match_ptr(dw_mci_exynos_match),
+                .pm             = &dw_mci_pltfm_pmops,
+        },
+};
+
+module_platform_driver(dw_mci_exynos_pltfm_driver);
+
+MODULE_DESCRIPTION("Samsung Specific DW-MSHC Driver Extension");
+MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:dwmmc-exynos");
diff --git a/drivers/mmc/host/dw_mmc-pci.c b/drivers/mmc/host/dw_mmc-pci.c
index dc0d25a013e0..edb37e9135ae 100644
--- a/drivers/mmc/host/dw_mmc-pci.c
+++ b/drivers/mmc/host/dw_mmc-pci.c
@@ -59,7 +59,7 @@ static int __devinit dw_mci_pci_probe(struct pci_dev *pdev,
 
         host->irq = pdev->irq;
         host->irq_flags = IRQF_SHARED;
-        host->dev = pdev->dev;
+        host->dev = &pdev->dev;
         host->pdata = &pci_board_data;
 
         host->regs = pci_iomap(pdev, PCI_BAR_NO, COMPLETE_BAR);
@@ -140,18 +140,7 @@ static struct pci_driver dw_mci_pci_driver = {
         },
 };
 
-static int __init dw_mci_init(void)
-{
-        return pci_register_driver(&dw_mci_pci_driver);
-}
-
-static void __exit dw_mci_exit(void)
-{
-        pci_unregister_driver(&dw_mci_pci_driver);
-}
-
-module_init(dw_mci_init);
-module_exit(dw_mci_exit);
+module_pci_driver(dw_mci_pci_driver);
 
 MODULE_DESCRIPTION("DW Multimedia Card PCI Interface driver");
 MODULE_AUTHOR("Shashidhar Hiremath <shashidharh@vayavyalabs.com>");
diff --git a/drivers/mmc/host/dw_mmc-pltfm.c b/drivers/mmc/host/dw_mmc-pltfm.c
index 92ec3eb3aae7..c960ca7ffbe6 100644
--- a/drivers/mmc/host/dw_mmc-pltfm.c
+++ b/drivers/mmc/host/dw_mmc-pltfm.c
@@ -19,59 +19,63 @@
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/dw_mmc.h>
+#include <linux/of.h>
+
 #include "dw_mmc.h"
 
-static int dw_mci_pltfm_probe(struct platform_device *pdev)
+int dw_mci_pltfm_register(struct platform_device *pdev,
+                                struct dw_mci_drv_data *drv_data)
 {
         struct dw_mci *host;
         struct resource *regs;
         int ret;
 
-        host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
+        host = devm_kzalloc(&pdev->dev, sizeof(struct dw_mci), GFP_KERNEL);
         if (!host)
                 return -ENOMEM;
 
         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!regs) {
-                ret = -ENXIO;
-                goto err_free;
-        }
+        if (!regs)
+                return -ENXIO;
 
         host->irq = platform_get_irq(pdev, 0);
-        if (host->irq < 0) {
-                ret = host->irq;
-                goto err_free;
-        }
+        if (host->irq < 0)
+                return host->irq;
 
-        host->dev = pdev->dev;
+        host->drv_data = drv_data;
+        host->dev = &pdev->dev;
         host->irq_flags = 0;
         host->pdata = pdev->dev.platform_data;
-        ret = -ENOMEM;
-        host->regs = ioremap(regs->start, resource_size(regs));
+        host->regs = devm_request_and_ioremap(&pdev->dev, regs);
         if (!host->regs)
-                goto err_free;
+                return -ENOMEM;
+
+        if (host->drv_data->init) {
+                ret = host->drv_data->init(host);
+                if (ret)
+                        return ret;
+        }
+
         platform_set_drvdata(pdev, host);
         ret = dw_mci_probe(host);
-        if (ret)
-                goto err_out;
-        return ret;
-err_out:
-        iounmap(host->regs);
-err_free:
-        kfree(host);
         return ret;
 }
+EXPORT_SYMBOL_GPL(dw_mci_pltfm_register);
 
-static int __exit dw_mci_pltfm_remove(struct platform_device *pdev)
+static int __devinit dw_mci_pltfm_probe(struct platform_device *pdev)
+{
+        return dw_mci_pltfm_register(pdev, NULL);
+}
+
+static int __devexit dw_mci_pltfm_remove(struct platform_device *pdev)
 {
         struct dw_mci *host = platform_get_drvdata(pdev);
 
         platform_set_drvdata(pdev, NULL);
         dw_mci_remove(host);
-        iounmap(host->regs);
-        kfree(host);
         return 0;
 }
+EXPORT_SYMBOL_GPL(dw_mci_pltfm_remove);
 
 #ifdef CONFIG_PM_SLEEP
 /*
@@ -105,12 +109,20 @@ static int dw_mci_pltfm_resume(struct device *dev)
 #define dw_mci_pltfm_resume     NULL
 #endif /* CONFIG_PM_SLEEP */
 
-static SIMPLE_DEV_PM_OPS(dw_mci_pltfm_pmops, dw_mci_pltfm_suspend, dw_mci_pltfm_resume);
+SIMPLE_DEV_PM_OPS(dw_mci_pltfm_pmops, dw_mci_pltfm_suspend, dw_mci_pltfm_resume);
+EXPORT_SYMBOL_GPL(dw_mci_pltfm_pmops);
+
+static const struct of_device_id dw_mci_pltfm_match[] = {
+        { .compatible = "snps,dw-mshc", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, dw_mci_pltfm_match);
 
 static struct platform_driver dw_mci_pltfm_driver = {
         .remove         = __exit_p(dw_mci_pltfm_remove),
         .driver         = {
                 .name           = "dw_mmc",
+                .of_match_table = of_match_ptr(dw_mci_pltfm_match),
                 .pm             = &dw_mci_pltfm_pmops,
         },
 };
diff --git a/drivers/mmc/host/dw_mmc-pltfm.h b/drivers/mmc/host/dw_mmc-pltfm.h
new file mode 100644
index 000000000000..301f24541fc2
--- /dev/null
+++ b/drivers/mmc/host/dw_mmc-pltfm.h
@@ -0,0 +1,20 @@
+/*
+ * Synopsys DesignWare Multimedia Card Interface Platform driver
+ *
+ * Copyright (C) 2012, Samsung Electronics Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _DW_MMC_PLTFM_H_
+#define _DW_MMC_PLTFM_H_
+
+extern int dw_mci_pltfm_register(struct platform_device *pdev,
+                                struct dw_mci_drv_data *drv_data);
+extern int __devexit dw_mci_pltfm_remove(struct platform_device *pdev);
+extern const struct dev_pm_ops dw_mci_pltfm_pmops;
+
+#endif /* _DW_MMC_PLTFM_H_ */
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index af40d227bece..c2828f35c3b8 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -33,6 +33,7 @@
 #include <linux/bitops.h>
 #include <linux/regulator/consumer.h>
 #include <linux/workqueue.h>
+#include <linux/of.h>
 
 #include "dw_mmc.h"
 
@@ -230,6 +231,7 @@ static void dw_mci_set_timeout(struct dw_mci *host)
 static u32 dw_mci_prepare_command(struct mmc_host *mmc, struct mmc_command *cmd)
 {
         struct mmc_data *data;
+        struct dw_mci_slot *slot = mmc_priv(mmc);
         u32 cmdr;
         cmd->error = -EINPROGRESS;
 
@@ -259,6 +261,9 @@ static u32 dw_mci_prepare_command(struct mmc_host *mmc, struct mmc_command *cmd)
                         cmdr |= SDMMC_CMD_DAT_WR;
         }
 
+        if (slot->host->drv_data->prepare_command)
+                slot->host->drv_data->prepare_command(slot->host, &cmdr);
+
         return cmdr;
 }
 
@@ -266,7 +271,7 @@ static void dw_mci_start_command(struct dw_mci *host,
                                  struct mmc_command *cmd, u32 cmd_flags)
 {
         host->cmd = cmd;
-        dev_vdbg(&host->dev,
+        dev_vdbg(host->dev,
                  "start command: ARGR=0x%08x CMDR=0x%08x\n",
                  cmd->arg, cmd_flags);
 
@@ -308,7 +313,7 @@ static void dw_mci_dma_cleanup(struct dw_mci *host)
 
         if (data)
                 if (!data->host_cookie)
-                        dma_unmap_sg(&host->dev,
+                        dma_unmap_sg(host->dev,
                                      data->sg,
                                      data->sg_len,
                                      dw_mci_get_dma_dir(data));
@@ -334,7 +339,7 @@ static void dw_mci_idmac_complete_dma(struct dw_mci *host)
 {
         struct mmc_data *data = host->data;
 
-        dev_vdbg(&host->dev, "DMA complete\n");
+        dev_vdbg(host->dev, "DMA complete\n");
 
         host->dma_ops->cleanup(host);
 
@@ -405,23 +410,11 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 static int dw_mci_idmac_init(struct dw_mci *host)
 {
         struct idmac_desc *p;
-        int i, dma_support;
+        int i;
 
         /* Number of descriptors in the ring buffer */
         host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
 
-        /* Check if Hardware Configuration Register has support for DMA */
-        dma_support = (mci_readl(host, HCON) >> 16) & 0x3;
-
-        if (!dma_support || dma_support > 2) {
-                dev_err(&host->dev,
-                        "Host Controller does not support IDMA Tx.\n");
-                host->dma_ops = NULL;
-                return -ENODEV;
-        }
-
-        dev_info(&host->dev, "Using internal DMA controller.\n");
-
         /* Forward link the descriptor list */
         for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
                 p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
@@ -476,7 +469,7 @@ static int dw_mci_pre_dma_transfer(struct dw_mci *host,
                         return -EINVAL;
         }
 
-        sg_len = dma_map_sg(&host->dev,
+        sg_len = dma_map_sg(host->dev,
                             data->sg,
                             data->sg_len,
                             dw_mci_get_dma_dir(data));
@@ -519,7 +512,7 @@ static void dw_mci_post_req(struct mmc_host *mmc,
                 return;
 
         if (data->host_cookie)
-                dma_unmap_sg(&slot->host->dev,
+                dma_unmap_sg(slot->host->dev,
                              data->sg,
                              data->sg_len,
                              dw_mci_get_dma_dir(data));
@@ -545,7 +538,7 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
 
         host->using_dma = 1;
 
-        dev_vdbg(&host->dev,
+        dev_vdbg(host->dev,
                  "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
                  (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
                  sg_len);
@@ -814,6 +807,9 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 slot->clock = ios->clock;
         }
 
+        if (slot->host->drv_data->set_ios)
+                slot->host->drv_data->set_ios(slot->host, ios);
+
         switch (ios->power_mode) {
         case MMC_POWER_UP:
                 set_bit(DW_MMC_CARD_NEED_INIT, &slot->flags);
@@ -830,7 +826,9 @@ static int dw_mci_get_ro(struct mmc_host *mmc)
         struct dw_mci_board *brd = slot->host->pdata;
 
         /* Use platform get_ro function, else try on board write protect */
-        if (brd->get_ro)
+        if (brd->quirks & DW_MCI_QUIRK_NO_WRITE_PROTECT)
+                read_only = 0;
+        else if (brd->get_ro)
                 read_only = brd->get_ro(slot->id);
         else
                 read_only =
@@ -939,12 +937,12 @@ static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
                 slot = list_entry(host->queue.next,
                                   struct dw_mci_slot, queue_node);
                 list_del(&slot->queue_node);
-                dev_vdbg(&host->dev, "list not empty: %s is next\n",
+                dev_vdbg(host->dev, "list not empty: %s is next\n",
                          mmc_hostname(slot->mmc));
                 host->state = STATE_SENDING_CMD;
                 dw_mci_start_request(host, slot);
         } else {
-                dev_vdbg(&host->dev, "list empty\n");
+                dev_vdbg(host->dev, "list empty\n");
                 host->state = STATE_IDLE;
         }
 
@@ -1083,7 +1081,7 @@ static void dw_mci_tasklet_func(unsigned long priv)
                                         data->bytes_xfered = 0;
                                         data->error = -ETIMEDOUT;
                                 } else {
-                                        dev_err(&host->dev,
+                                        dev_err(host->dev,
                                                 "data FIFO error "
                                                 "(status=%08x)\n",
                                                 status);
@@ -1767,12 +1765,60 @@ static void dw_mci_work_routine_card(struct work_struct *work)
         }
 }
 
-static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
+#ifdef CONFIG_OF
+/* given a slot id, find out the device node representing that slot */
+static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
+{
+        struct device_node *np;
+        const __be32 *addr;
+        int len;
+
+        if (!dev || !dev->of_node)
+                return NULL;
+
+        for_each_child_of_node(dev->of_node, np) {
+                addr = of_get_property(np, "reg", &len);
+                if (!addr || (len < sizeof(int)))
+                        continue;
+                if (be32_to_cpup(addr) == slot)
+                        return np;
+        }
+        return NULL;
+}
+
+/* find out bus-width for a given slot */
+static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
+{
+        struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
+        u32 bus_wd = 1;
+
+        if (!np)
+                return 1;
+
+        if (of_property_read_u32(np, "bus-width", &bus_wd))
+                dev_err(dev, "bus-width property not found, assuming width"
+                               " as 1\n");
+        return bus_wd;
+}
+#else /* CONFIG_OF */
+static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
+{
+        return 1;
+}
+static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
+{
+        return NULL;
+}
+#endif /* CONFIG_OF */
+
+static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 {
         struct mmc_host *mmc;
         struct dw_mci_slot *slot;
+        int ctrl_id, ret;
+        u8 bus_width;
 
-        mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->dev);
+        mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), host->dev);
         if (!mmc)
                 return -ENOMEM;
 
@@ -1780,6 +1826,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         slot->id = id;
         slot->mmc = mmc;
         slot->host = host;
+        host->slot[id] = slot;
 
         mmc->ops = &dw_mci_ops;
         mmc->f_min = DIV_ROUND_UP(host->bus_hz, 510);
@@ -1800,21 +1847,44 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         if (host->pdata->caps)
                 mmc->caps = host->pdata->caps;
 
+        if (host->dev->of_node) {
+                ctrl_id = of_alias_get_id(host->dev->of_node, "mshc");
+                if (ctrl_id < 0)
+                        ctrl_id = 0;
+        } else {
+                ctrl_id = to_platform_device(host->dev)->id;
+        }
+        if (host->drv_data && host->drv_data->caps)
+                mmc->caps |= host->drv_data->caps[ctrl_id];
+
         if (host->pdata->caps2)
                 mmc->caps2 = host->pdata->caps2;
 
         if (host->pdata->get_bus_wd)
-                if (host->pdata->get_bus_wd(slot->id) >= 4)
-                        mmc->caps |= MMC_CAP_4_BIT_DATA;
+                bus_width = host->pdata->get_bus_wd(slot->id);
+        else if (host->dev->of_node)
+                bus_width = dw_mci_of_get_bus_wd(host->dev, slot->id);
+        else
+                bus_width = 1;
+
+        if (host->drv_data->setup_bus) {
+                struct device_node *slot_np;
+                slot_np = dw_mci_of_find_slot_node(host->dev, slot->id);
+                ret = host->drv_data->setup_bus(host, slot_np, bus_width);
+                if (ret)
+                        goto err_setup_bus;
+        }
+
+        switch (bus_width) {
+        case 8:
+                mmc->caps |= MMC_CAP_8_BIT_DATA;
+        case 4:
+                mmc->caps |= MMC_CAP_4_BIT_DATA;
+        }
 
         if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
-        if (mmc->caps2 & MMC_CAP2_POWEROFF_NOTIFY)
-                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
-        else
-                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_NONE;
-
         if (host->pdata->blk_settings) {
                 mmc->max_segs = host->pdata->blk_settings->max_segs;
                 mmc->max_blk_size = host->pdata->blk_settings->max_blk_size;
@@ -1850,7 +1920,6 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         else
                 clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
 
-        host->slot[id] = slot;
         mmc_add_host(mmc);
 
 #if defined(CONFIG_DEBUG_FS)
@@ -1867,6 +1936,10 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
         queue_work(host->card_workqueue, &host->card_work);
 
         return 0;
+
+err_setup_bus:
+        mmc_free_host(mmc);
+        return -EINVAL;
 }
 
 static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
@@ -1884,10 +1957,10 @@ static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
 static void dw_mci_init_dma(struct dw_mci *host)
 {
         /* Alloc memory for sg translation */
-        host->sg_cpu = dma_alloc_coherent(&host->dev, PAGE_SIZE,
+        host->sg_cpu = dma_alloc_coherent(host->dev, PAGE_SIZE,
                                           &host->sg_dma, GFP_KERNEL);
         if (!host->sg_cpu) {
-                dev_err(&host->dev, "%s: could not alloc DMA memory\n",
+                dev_err(host->dev, "%s: could not alloc DMA memory\n",
                         __func__);
                 goto no_dma;
         }
@@ -1895,6 +1968,7 @@ static void dw_mci_init_dma(struct dw_mci *host)
         /* Determine which DMA interface to use */
 #ifdef CONFIG_MMC_DW_IDMAC
         host->dma_ops = &dw_mci_idmac_ops;
+        dev_info(&host->dev, "Using internal DMA controller.\n");
 #endif
 
         if (!host->dma_ops)
@@ -1903,12 +1977,12 @@ static void dw_mci_init_dma(struct dw_mci *host)
         if (host->dma_ops->init && host->dma_ops->start &&
             host->dma_ops->stop && host->dma_ops->cleanup) {
                 if (host->dma_ops->init(host)) {
-                        dev_err(&host->dev, "%s: Unable to initialize "
+                        dev_err(host->dev, "%s: Unable to initialize "
                                 "DMA Controller.\n", __func__);
                         goto no_dma;
                 }
         } else {
-                dev_err(&host->dev, "DMA initialization not found.\n");
+                dev_err(host->dev, "DMA initialization not found.\n");
                 goto no_dma;
         }
 
@@ -1916,7 +1990,7 @@ static void dw_mci_init_dma(struct dw_mci *host)
         return;
 
 no_dma:
-        dev_info(&host->dev, "Using PIO mode.\n");
+        dev_info(host->dev, "Using PIO mode.\n");
         host->use_dma = 0;
         return;
 }
@@ -1942,30 +2016,133 @@ static bool mci_wait_reset(struct device *dev, struct dw_mci *host)
         return false;
 }
 
+#ifdef CONFIG_OF
+static struct dw_mci_of_quirks {
+        char *quirk;
+        int id;
+} of_quirks[] = {
+        {
+                .quirk  = "supports-highspeed",
+                .id     = DW_MCI_QUIRK_HIGHSPEED,
+        }, {
+                .quirk  = "broken-cd",
+                .id     = DW_MCI_QUIRK_BROKEN_CARD_DETECTION,
+        },
+};
+
+static struct dw_mci_board *dw_mci_parse_dt(struct dw_mci *host)
+{
+        struct dw_mci_board *pdata;
+        struct device *dev = host->dev;
+        struct device_node *np = dev->of_node;
+        int idx, ret;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                dev_err(dev, "could not allocate memory for pdata\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        /* find out number of slots supported */
+        if (of_property_read_u32(dev->of_node, "num-slots",
+                                &pdata->num_slots)) {
+                dev_info(dev, "num-slots property not found, "
+                                "assuming 1 slot is available\n");
+                pdata->num_slots = 1;
+        }
+
+        /* get quirks */
+        for (idx = 0; idx < ARRAY_SIZE(of_quirks); idx++)
+                if (of_get_property(np, of_quirks[idx].quirk, NULL))
+                        pdata->quirks |= of_quirks[idx].id;
+
+        if (of_property_read_u32(np, "fifo-depth", &pdata->fifo_depth))
+                dev_info(dev, "fifo-depth property not found, using "
+                                "value of FIFOTH register as default\n");
+
+        of_property_read_u32(np, "card-detect-delay", &pdata->detect_delay_ms);
+
+        if (host->drv_data->parse_dt) {
+                ret = host->drv_data->parse_dt(host);
+                if (ret)
+                        return ERR_PTR(ret);
+        }
+
+        return pdata;
+}
+
+#else /* CONFIG_OF */
+static struct dw_mci_board *dw_mci_parse_dt(struct dw_mci *host)
+{
+        return ERR_PTR(-EINVAL);
+}
+#endif /* CONFIG_OF */
+
 int dw_mci_probe(struct dw_mci *host)
 {
         int width, i, ret = 0;
         u32 fifo_size;
+        int init_slots = 0;
 
-        if (!host->pdata || !host->pdata->init) {
-                dev_err(&host->dev,
-                        "Platform data must supply init function\n");
-                return -ENODEV;
+        if (!host->pdata) {
+                host->pdata = dw_mci_parse_dt(host);
+                if (IS_ERR(host->pdata)) {
+                        dev_err(host->dev, "platform data not available\n");
+                        return -EINVAL;
+                }
         }
 
         if (!host->pdata->select_slot && host->pdata->num_slots > 1) {
-                dev_err(&host->dev,
+                dev_err(host->dev,
                         "Platform data must supply select_slot function\n");
                 return -ENODEV;
         }
 
-        if (!host->pdata->bus_hz) {
-                dev_err(&host->dev,
+        host->biu_clk = clk_get(host->dev, "biu");
+        if (IS_ERR(host->biu_clk)) {
+                dev_dbg(host->dev, "biu clock not available\n");
+        } else {
+                ret = clk_prepare_enable(host->biu_clk);
+                if (ret) {
+                        dev_err(host->dev, "failed to enable biu clock\n");
+                        clk_put(host->biu_clk);
+                        return ret;
+                }
+        }
+
+        host->ciu_clk = clk_get(host->dev, "ciu");
+        if (IS_ERR(host->ciu_clk)) {
+                dev_dbg(host->dev, "ciu clock not available\n");
+        } else {
+                ret = clk_prepare_enable(host->ciu_clk);
+                if (ret) {
+                        dev_err(host->dev, "failed to enable ciu clock\n");
+                        clk_put(host->ciu_clk);
+                        goto err_clk_biu;
+                }
+        }
+
+        if (IS_ERR(host->ciu_clk))
+                host->bus_hz = host->pdata->bus_hz;
+        else
+                host->bus_hz = clk_get_rate(host->ciu_clk);
+
+        if (host->drv_data->setup_clock) {
+                ret = host->drv_data->setup_clock(host);
+                if (ret) {
+                        dev_err(host->dev,
+                                "implementation specific clock setup failed\n");
+                        goto err_clk_ciu;
+                }
+        }
+
+        if (!host->bus_hz) {
+                dev_err(host->dev,
                         "Platform data must supply bus speed\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto err_clk_ciu;
         }
 
-        host->bus_hz = host->pdata->bus_hz;
         host->quirks = host->pdata->quirks;
 
         spin_lock_init(&host->lock);
@@ -1998,7 +2175,7 @@ int dw_mci_probe(struct dw_mci *host)
         }
 
         /* Reset all blocks */
-        if (!mci_wait_reset(&host->dev, host))
+        if (!mci_wait_reset(host->dev, host))
                 return -ENODEV;
 
         host->dma_ops = host->pdata->dma_ops;
@@ -2054,10 +2231,18 @@ int dw_mci_probe(struct dw_mci *host)
         /* We need at least one slot to succeed */
         for (i = 0; i < host->num_slots; i++) {
                 ret = dw_mci_init_slot(host, i);
-                if (ret) {
-                        ret = -ENODEV;
-                        goto err_init_slot;
-                }
+                if (ret)
+                        dev_dbg(host->dev, "slot %d init failed\n", i);
+                else
+                        init_slots++;
+        }
+
+        if (init_slots) {
+                dev_info(host->dev, "%d slots initialized\n", init_slots);
+        } else {
+                dev_dbg(host->dev, "attempted to initialize %d slots, "
+                                        "but failed on all\n", host->num_slots);
+                goto err_init_slot;
         }
 
         /*
@@ -2065,7 +2250,7 @@ int dw_mci_probe(struct dw_mci *host)
          * Need to check the version-id and set data-offset for DATA register.
          */
         host->verid = SDMMC_GET_VERID(mci_readl(host, VERID));
-        dev_info(&host->dev, "Version ID is %04x\n", host->verid);
+        dev_info(host->dev, "Version ID is %04x\n", host->verid);
 
         if (host->verid < DW_MMC_240A)
                 host->data_offset = DATA_OFFSET;
@@ -2082,22 +2267,16 @@ int dw_mci_probe(struct dw_mci *host)
                    DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
         mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
 
-        dev_info(&host->dev, "DW MMC controller at irq %d, "
+        dev_info(host->dev, "DW MMC controller at irq %d, "
                  "%d bit host data width, "
                  "%u deep fifo\n",
                  host->irq, width, fifo_size);
         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
-                dev_info(&host->dev, "Internal DMAC interrupt fix enabled.\n");
+                dev_info(host->dev, "Internal DMAC interrupt fix enabled.\n");
 
         return 0;
 
 err_init_slot:
-        /* De-init any initialized slots */
-        while (i > 0) {
-                if (host->slot[i])
-                        dw_mci_cleanup_slot(host->slot[i], i);
-                i--;
-        }
         free_irq(host->irq, host);
 
 err_workqueue:
@@ -2106,13 +2285,24 @@ err_workqueue:
 err_dmaunmap:
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
-        dma_free_coherent(&host->dev, PAGE_SIZE,
+        dma_free_coherent(host->dev, PAGE_SIZE,
                           host->sg_cpu, host->sg_dma);
 
         if (host->vmmc) {
                 regulator_disable(host->vmmc);
                 regulator_put(host->vmmc);
         }
+
+err_clk_ciu:
+        if (!IS_ERR(host->ciu_clk)) {
+                clk_disable_unprepare(host->ciu_clk);
+                clk_put(host->ciu_clk);
+        }
+err_clk_biu:
+        if (!IS_ERR(host->biu_clk)) {
+                clk_disable_unprepare(host->biu_clk);
+                clk_put(host->biu_clk);
+        }
         return ret;
 }
 EXPORT_SYMBOL(dw_mci_probe);
@@ -2125,7 +2315,7 @@ void dw_mci_remove(struct dw_mci *host)
         mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
 
         for (i = 0; i < host->num_slots; i++) {
-                dev_dbg(&host->dev, "remove slot %d\n", i);
+                dev_dbg(host->dev, "remove slot %d\n", i);
                 if (host->slot[i])
                         dw_mci_cleanup_slot(host->slot[i], i);
         }
@@ -2136,7 +2326,7 @@ void dw_mci_remove(struct dw_mci *host)
 
         free_irq(host->irq, host);
         destroy_workqueue(host->card_workqueue);
-        dma_free_coherent(&host->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
+        dma_free_coherent(host->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
 
         if (host->use_dma && host->dma_ops->exit)
                 host->dma_ops->exit(host);
@@ -2146,6 +2336,12 @@ void dw_mci_remove(struct dw_mci *host)
                 regulator_put(host->vmmc);
         }
 
+        if (!IS_ERR(host->ciu_clk))
+                clk_disable_unprepare(host->ciu_clk);
+        if (!IS_ERR(host->biu_clk))
+                clk_disable_unprepare(host->biu_clk);
+        clk_put(host->ciu_clk);
+        clk_put(host->biu_clk);
 }
 EXPORT_SYMBOL(dw_mci_remove);
 
@@ -2188,7 +2384,7 @@ int dw_mci_resume(struct dw_mci *host)
         if (host->vmmc)
                 regulator_enable(host->vmmc);
 
-        if (!mci_wait_reset(&host->dev, host)) {
+        if (!mci_wait_reset(host->dev, host)) {
                 ret = -ENODEV;
                 return ret;
         }
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
index 15c27e17c23f..53b8fd987e47 100644
--- a/drivers/mmc/host/dw_mmc.h
+++ b/drivers/mmc/host/dw_mmc.h
@@ -182,4 +182,28 @@ extern int dw_mci_suspend(struct dw_mci *host);
 extern int dw_mci_resume(struct dw_mci *host);
 #endif
 
+/**
+ * dw_mci driver data - dw-mshc implementation specific driver data.
+ * @caps: mmc subsystem specified capabilities of the controller(s).
+ * @init: early implementation specific initialization.
+ * @setup_clock: implementation specific clock configuration.
+ * @prepare_command: handle CMD register extensions.
+ * @set_ios: handle bus specific extensions.
+ * @parse_dt: parse implementation specific device tree properties.
+ * @setup_bus: initialize io-interface
+ *
+ * Provide controller implementation specific extensions. The usage of this
+ * data structure is fully optional and usage of each member in this structure
+ * is optional as well.
+ */
+struct dw_mci_drv_data {
+        unsigned long   *caps;
+        int             (*init)(struct dw_mci *host);
+        int             (*setup_clock)(struct dw_mci *host);
+        void            (*prepare_command)(struct dw_mci *host, u32 *cmdr);
+        void            (*set_ios)(struct dw_mci *host, struct mmc_ios *ios);
+        int             (*parse_dt)(struct dw_mci *host);
+        int             (*setup_bus)(struct dw_mci *host,
+                                struct device_node *slot_np, u8 bus_width);
+};
 #endif /* _DW_MMC_H_ */
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 273306c68d58..a600eabbd6c3 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1532,20 +1532,7 @@ static struct spi_driver mmc_spi_driver = {
         .remove =       __devexit_p(mmc_spi_remove),
 };
 
-
-static int __init mmc_spi_init(void)
-{
-        return spi_register_driver(&mmc_spi_driver);
-}
-module_init(mmc_spi_init);
-
-
-static void __exit mmc_spi_exit(void)
-{
-        spi_unregister_driver(&mmc_spi_driver);
-}
-module_exit(mmc_spi_exit);
-
+module_spi_driver(mmc_spi_driver);
 
 MODULE_AUTHOR("Mike Lavender, David Brownell, "
                 "Hans-Peter Nilsson, Jan Nikitenko");
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 50ff19a62368..edc3e9baf0e7 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -1309,14 +1309,10 @@ static int __devinit mmci_probe(struct amba_device *dev,
                 goto host_free;
         }
 
-        ret = clk_prepare(host->clk);
+        ret = clk_prepare_enable(host->clk);
         if (ret)
                 goto clk_free;
 
-        ret = clk_enable(host->clk);
-        if (ret)
-                goto clk_unprep;
-
         host->plat = plat;
         host->variant = variant;
         host->mclk = clk_get_rate(host->clk);
@@ -1515,9 +1511,7 @@ static int __devinit mmci_probe(struct amba_device *dev,
  err_gpio_cd:
         iounmap(host->base);
  clk_disable:
-        clk_disable(host->clk);
- clk_unprep:
-        clk_unprepare(host->clk);
+        clk_disable_unprepare(host->clk);
  clk_free:
         clk_put(host->clk);
  host_free:
@@ -1564,8 +1558,7 @@ static int __devexit mmci_remove(struct amba_device *dev)
                         gpio_free(host->gpio_cd);
 
                 iounmap(host->base);
-                clk_disable(host->clk);
-                clk_unprepare(host->clk);
+                clk_disable_unprepare(host->clk);
                 clk_put(host->clk);
 
                 if (host->vcc)
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 7b1161de01d6..565c2e4fac75 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -44,6 +44,7 @@
 #include <mach/hardware.h>
 
 #define DRIVER_NAME "mxc-mmc"
+#define MXCMCI_TIMEOUT_MS 10000
 
 #define MMC_REG_STR_STP_CLK             0x00
 #define MMC_REG_STATUS                  0x04
@@ -150,6 +151,8 @@ struct mxcmci_host {
         int                     dmareq;
         struct dma_slave_config dma_slave_config;
         struct imx_dma_data     dma_data;
+
+        struct timer_list       watchdog;
 };
 
 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios);
@@ -271,9 +274,32 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
         dmaengine_submit(host->desc);
         dma_async_issue_pending(host->dma);
 
+        mod_timer(&host->watchdog, jiffies + msecs_to_jiffies(MXCMCI_TIMEOUT_MS));
+
         return 0;
 }
 
+static void mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat);
+static void mxcmci_data_done(struct mxcmci_host *host, unsigned int stat);
+
+static void mxcmci_dma_callback(void *data)
+{
+        struct mxcmci_host *host = data;
+        u32 stat;
+
+        del_timer(&host->watchdog);
+
+        stat = readl(host->base + MMC_REG_STATUS);
+        writel(stat & ~STATUS_DATA_TRANS_DONE, host->base + MMC_REG_STATUS);
+
+        dev_dbg(mmc_dev(host->mmc), "%s: 0x%08x\n", __func__, stat);
+
+        if (stat & STATUS_READ_OP_DONE)
+                writel(STATUS_READ_OP_DONE, host->base + MMC_REG_STATUS);
+
+        mxcmci_data_done(host, stat);
+}
+
 static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd,
                 unsigned int cmdat)
 {
@@ -305,8 +331,14 @@ static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_command *cmd,
 
         int_cntr = INT_END_CMD_RES_EN;
 
-        if (mxcmci_use_dma(host))
-                int_cntr |= INT_READ_OP_EN | INT_WRITE_OP_DONE_EN;
+        if (mxcmci_use_dma(host)) {
+                if (host->dma_dir == DMA_FROM_DEVICE) {
+                        host->desc->callback = mxcmci_dma_callback;
+                        host->desc->callback_param = host;
+                } else {
+                        int_cntr |= INT_WRITE_OP_DONE_EN;
+                }
+        }
 
         spin_lock_irqsave(&host->lock, flags);
         if (host->use_sdio)
@@ -345,11 +377,9 @@ static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat)
         struct mmc_data *data = host->data;
         int data_error;
 
-        if (mxcmci_use_dma(host)) {
-                dmaengine_terminate_all(host->dma);
+        if (mxcmci_use_dma(host))
                 dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len,
                                 host->dma_dir);
-        }
 
         if (stat & STATUS_ERR_MASK) {
                 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",
@@ -624,8 +654,10 @@ static irqreturn_t mxcmci_irq(int irq, void *devid)
                 mxcmci_cmd_done(host, stat);
 
         if (mxcmci_use_dma(host) &&
-                  (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE)))
+                  (stat & (STATUS_DATA_TRANS_DONE | STATUS_WRITE_OP_DONE))) {
+                del_timer(&host->watchdog);
                 mxcmci_data_done(host, stat);
+        }
 
         if (host->default_irq_mask &&
                   (stat & (STATUS_CARD_INSERTION | STATUS_CARD_REMOVAL)))
@@ -836,6 +868,34 @@ static bool filter(struct dma_chan *chan, void *param)
         return true;
 }
 
+static void mxcmci_watchdog(unsigned long data)
+{
+        struct mmc_host *mmc = (struct mmc_host *)data;
+        struct mxcmci_host *host = mmc_priv(mmc);
+        struct mmc_request *req = host->req;
+        unsigned int stat = readl(host->base + MMC_REG_STATUS);
+
+        if (host->dma_dir == DMA_FROM_DEVICE) {
+                dmaengine_terminate_all(host->dma);
+                dev_err(mmc_dev(host->mmc),
+                        "%s: read time out (status = 0x%08x)\n",
+                        __func__, stat);
+        } else {
+                dev_err(mmc_dev(host->mmc),
+                        "%s: write time out (status = 0x%08x)\n",
+                        __func__, stat);
+                mxcmci_softreset(host);
+        }
+
+        /* Mark transfer as erroneus and inform the upper layers */
+
+        host->data->error = -ETIMEDOUT;
+        host->req = NULL;
+        host->cmd = NULL;
+        host->data = NULL;
+        mmc_request_done(host->mmc, req);
+}
+
 static const struct mmc_host_ops mxcmci_ops = {
         .request                = mxcmci_request,
         .set_ios                = mxcmci_set_ios,
@@ -968,6 +1028,10 @@ static int mxcmci_probe(struct platform_device *pdev)
 
         mmc_add_host(mmc);
 
+        init_timer(&host->watchdog);
+        host->watchdog.function = &mxcmci_watchdog;
+        host->watchdog.data = (unsigned long)mmc;
+
         return 0;
 
 out_free_irq:
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index c6259a829544..48ad361613ef 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -27,16 +27,10 @@
 #include <linux/mmc/card.h>
 #include <linux/clk.h>
 #include <linux/scatterlist.h>
-#include <linux/i2c/tps65010.h>
 #include <linux/slab.h>
 
-#include <asm/io.h>
-#include <asm/irq.h>
-
 #include <plat/mmc.h>
-#include <asm/gpio.h>
 #include <plat/dma.h>
-#include <plat/fpga.h>
 
 #define OMAP_MMC_REG_CMD        0x00
 #define OMAP_MMC_REG_ARGL       0x01
@@ -105,7 +99,6 @@ struct mmc_omap_slot {
         u16                     saved_con;
         u16                     bus_mode;
         unsigned int            fclk_freq;
-        unsigned                powered:1;
 
         struct tasklet_struct   cover_tasklet;
         struct timer_list       cover_timer;
@@ -137,7 +130,6 @@ struct mmc_omap_host {
         unsigned int            phys_base;
         int                     irq;
         unsigned char           bus_mode;
-        unsigned char           hw_bus_mode;
         unsigned int            reg_shift;
 
         struct work_struct      cmd_abort_work;
@@ -695,22 +687,29 @@ mmc_omap_xfer_data(struct mmc_omap_host *host, int write)
         host->buffer += nwords;
 }
 
-static inline void mmc_omap_report_irq(u16 status)
+#ifdef CONFIG_MMC_DEBUG
+static void mmc_omap_report_irq(struct mmc_omap_host *host, u16 status)
 {
         static const char *mmc_omap_status_bits[] = {
                 "EOC", "CD", "CB", "BRS", "EOFB", "DTO", "DCRC", "CTO",
                 "CCRC", "CRW", "AF", "AE", "OCRB", "CIRQ", "CERR"
         };
-        int i, c = 0;
+        int i;
+        char res[64], *buf = res;
+
+        buf += sprintf(buf, "MMC IRQ 0x%x:", status);
 
         for (i = 0; i < ARRAY_SIZE(mmc_omap_status_bits); i++)
-                if (status & (1 << i)) {
-                        if (c)
-                                printk(" ");
-                        printk("%s", mmc_omap_status_bits[i]);
-                        c++;
-                }
+                if (status & (1 << i))
+                        buf += sprintf(buf, " %s", mmc_omap_status_bits[i]);
+        dev_vdbg(mmc_dev(host->mmc), "%s\n", res);
 }
+#else
+static void mmc_omap_report_irq(struct mmc_omap_host *host, u16 status)
+{
+}
+#endif
+
 
 static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
 {
@@ -744,12 +743,10 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                         cmd = host->cmd->opcode;
                 else
                         cmd = -1;
-#ifdef CONFIG_MMC_DEBUG
                 dev_dbg(mmc_dev(host->mmc), "MMC IRQ %04x (CMD %d): ",
                         status, cmd);
-                mmc_omap_report_irq(status);
-                printk("\n");
-#endif
+                mmc_omap_report_irq(host, status);
+
                 if (host->total_bytes_left) {
                         if ((status & OMAP_MMC_STAT_A_FULL) ||
                             (status & OMAP_MMC_STAT_END_OF_DATA))
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 38adc330c007..54bfd0cc106b 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -35,7 +35,6 @@
 #include <linux/mmc/core.h>
 #include <linux/mmc/mmc.h>
 #include <linux/io.h>
-#include <linux/semaphore.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
@@ -44,7 +43,6 @@
 #include <plat/cpu.h>
 
 /* OMAP HSMMC Host Controller Registers */
-#define OMAP_HSMMC_SYSCONFIG    0x0010
 #define OMAP_HSMMC_SYSSTATUS    0x0014
 #define OMAP_HSMMC_CON          0x002C
 #define OMAP_HSMMC_BLK          0x0104
@@ -161,8 +159,6 @@ struct omap_hsmmc_host {
         unsigned int            dma_sg_idx;
         unsigned char           bus_mode;
         unsigned char           power_mode;
-        u32                     *buffer;
-        u32                     bytesleft;
         int                     suspended;
         int                     irq;
         int                     use_dma, dma_ch;
@@ -171,7 +167,6 @@ struct omap_hsmmc_host {
         int                     slot_id;
         int                     response_busy;
         int                     context_loss;
-        int                     vdd;
         int                     protect_card;
         int                     reqs_blocked;
         int                     use_reg;
@@ -300,12 +295,12 @@ static int omap_hsmmc_reg_get(struct omap_hsmmc_host *host)
         struct regulator *reg;
         int ocr_value = 0;
 
-        mmc_slot(host).set_power = omap_hsmmc_set_power;
-
         reg = regulator_get(host->dev, "vmmc");
         if (IS_ERR(reg)) {
                 dev_dbg(host->dev, "vmmc regulator missing\n");
+                return PTR_ERR(reg);
         } else {
+                mmc_slot(host).set_power = omap_hsmmc_set_power;
                 host->vcc = reg;
                 ocr_value = mmc_regulator_get_ocrmask(reg);
                 if (!mmc_slot(host).ocr_mask) {
@@ -495,7 +490,7 @@ static void omap_hsmmc_set_clock(struct omap_hsmmc_host *host)
         unsigned long regval;
         unsigned long timeout;
 
-        dev_dbg(mmc_dev(host->mmc), "Set clock to %uHz\n", ios->clock);
+        dev_vdbg(mmc_dev(host->mmc), "Set clock to %uHz\n", ios->clock);
 
         omap_hsmmc_stop_clock(host);
 
@@ -579,21 +574,8 @@ static int omap_hsmmc_context_restore(struct omap_hsmmc_host *host)
         if (host->context_loss == context_loss)
                 return 1;
 
-        /* Wait for hardware reset */
-        timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
-        while ((OMAP_HSMMC_READ(host->base, SYSSTATUS) & RESETDONE) != RESETDONE
-                && time_before(jiffies, timeout))
-                ;
-
-        /* Do software reset */
-        OMAP_HSMMC_WRITE(host->base, SYSCONFIG, SOFTRESET);
-        timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
-        while ((OMAP_HSMMC_READ(host->base, SYSSTATUS) & RESETDONE) != RESETDONE
-                && time_before(jiffies, timeout))
-                ;
-
-        OMAP_HSMMC_WRITE(host->base, SYSCONFIG,
-                        OMAP_HSMMC_READ(host->base, SYSCONFIG) | AUTOIDLE);
+        if (!OMAP_HSMMC_READ(host->base, SYSSTATUS) & RESETDONE)
+                return 1;
 
         if (host->pdata->controller_flags & OMAP_HSMMC_SUPPORTS_DUAL_VOLT) {
                 if (host->power_mode != MMC_POWER_OFF &&
@@ -745,7 +727,7 @@ omap_hsmmc_start_command(struct omap_hsmmc_host *host, struct mmc_command *cmd,
 {
         int cmdreg = 0, resptype = 0, cmdtype = 0;
 
-        dev_dbg(mmc_dev(host->mmc), "%s: CMD%d, argument 0x%08x\n",
+        dev_vdbg(mmc_dev(host->mmc), "%s: CMD%d, argument 0x%08x\n",
                 mmc_hostname(host->mmc), cmd->opcode, cmd->arg);
         host->cmd = cmd;
 
@@ -934,7 +916,7 @@ static void omap_hsmmc_dbg_report_irq(struct omap_hsmmc_host *host, u32 status)
                         buf += len;
                 }
 
-        dev_dbg(mmc_dev(host->mmc), "%s\n", res);
+        dev_vdbg(mmc_dev(host->mmc), "%s\n", res);
 }
 #else
 static inline void omap_hsmmc_dbg_report_irq(struct omap_hsmmc_host *host,
@@ -981,72 +963,40 @@ static inline void omap_hsmmc_reset_controller_fsm(struct omap_hsmmc_host *host,
                         __func__);
 }
 
+static void hsmmc_command_incomplete(struct omap_hsmmc_host *host, int err)
+{
+        omap_hsmmc_reset_controller_fsm(host, SRC);
+        host->cmd->error = err;
+
+        if (host->data) {
+                omap_hsmmc_reset_controller_fsm(host, SRD);
+                omap_hsmmc_dma_cleanup(host, err);
+        }
+
+}
+
 static void omap_hsmmc_do_irq(struct omap_hsmmc_host *host, int status)
 {
         struct mmc_data *data;
         int end_cmd = 0, end_trans = 0;
 
-        if (!host->req_in_progress) {
-                do {
-                        OMAP_HSMMC_WRITE(host->base, STAT, status);
-                        /* Flush posted write */
-                        status = OMAP_HSMMC_READ(host->base, STAT);
-                } while (status & INT_EN_MASK);
-                return;
-        }
-
         data = host->data;
-        dev_dbg(mmc_dev(host->mmc), "IRQ Status is %x\n", status);
+        dev_vdbg(mmc_dev(host->mmc), "IRQ Status is %x\n", status);
 
         if (status & ERR) {
                 omap_hsmmc_dbg_report_irq(host, status);
-                if ((status & CMD_TIMEOUT) ||
-                        (status & CMD_CRC)) {
-                        if (host->cmd) {
-                                if (status & CMD_TIMEOUT) {
-                                        omap_hsmmc_reset_controller_fsm(host,
-                                                                        SRC);
-                                        host->cmd->error = -ETIMEDOUT;
-                                } else {
-                                        host->cmd->error = -EILSEQ;
-                                }
-                                end_cmd = 1;
-                        }
-                        if (host->data || host->response_busy) {
-                                if (host->data)
-                                        omap_hsmmc_dma_cleanup(host,
-                                                                -ETIMEDOUT);
-                                host->response_busy = 0;
-                                omap_hsmmc_reset_controller_fsm(host, SRD);
-                        }
-                }
-                if ((status & DATA_TIMEOUT) ||
-                        (status & DATA_CRC)) {
-                        if (host->data || host->response_busy) {
-                                int err = (status & DATA_TIMEOUT) ?
-                                                -ETIMEDOUT : -EILSEQ;
-
-                                if (host->data)
-                                        omap_hsmmc_dma_cleanup(host, err);
-                                else
-                                        host->mrq->cmd->error = err;
-                                host->response_busy = 0;
-                                omap_hsmmc_reset_controller_fsm(host, SRD);
-                                end_trans = 1;
-                        }
-                }
-                if (status & CARD_ERR) {
-                        dev_dbg(mmc_dev(host->mmc),
-                                "Ignoring card err CMD%d\n", host->cmd->opcode);
-                        if (host->cmd)
-                                end_cmd = 1;
-                        if (host->data)
-                                end_trans = 1;
+                if (status & (CMD_TIMEOUT | DATA_TIMEOUT))
+                        hsmmc_command_incomplete(host, -ETIMEDOUT);
+                else if (status & (CMD_CRC | DATA_CRC))
+                        hsmmc_command_incomplete(host, -EILSEQ);
+
+                end_cmd = 1;
+                if (host->data || host->response_busy) {
+                        end_trans = 1;
+                        host->response_busy = 0;
                 }
         }
 
-        OMAP_HSMMC_WRITE(host->base, STAT, status);
-
         if (end_cmd || ((status & CC) && host->cmd))
                 omap_hsmmc_cmd_done(host, host->cmd);
         if ((end_trans || (status & TC)) && host->mrq)
@@ -1062,11 +1012,13 @@ static irqreturn_t omap_hsmmc_irq(int irq, void *dev_id)
         int status;
 
         status = OMAP_HSMMC_READ(host->base, STAT);
-        do {
+        while (status & INT_EN_MASK && host->req_in_progress) {
                 omap_hsmmc_do_irq(host, status);
+
                 /* Flush posted write */
+                OMAP_HSMMC_WRITE(host->base, STAT, status);
                 status = OMAP_HSMMC_READ(host->base, STAT);
-        } while (status & INT_EN_MASK);
+        }
 
         return IRQ_HANDLED;
 }
@@ -1501,12 +1453,10 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 case MMC_POWER_OFF:
                         mmc_slot(host).set_power(host->dev, host->slot_id,
                                                  0, 0);
-                        host->vdd = 0;
                         break;
                 case MMC_POWER_UP:
                         mmc_slot(host).set_power(host->dev, host->slot_id,
                                                  1, ios->vdd);
-                        host->vdd = ios->vdd;
                         break;
                 case MMC_POWER_ON:
                         do_send_init_stream = 1;
@@ -1598,10 +1548,6 @@ static void omap_hsmmc_conf_bus_power(struct omap_hsmmc_host *host)
         value = OMAP_HSMMC_READ(host->base, CAPA);
         OMAP_HSMMC_WRITE(host->base, CAPA, value | capa);
 
-        /* Set the controller to AUTO IDLE mode */
-        value = OMAP_HSMMC_READ(host->base, SYSCONFIG);
-        OMAP_HSMMC_WRITE(host->base, SYSCONFIG, value | AUTOIDLE);
-
         /* Set SD bus power bit */
         set_sd_bus_power(host);
 }
@@ -1659,8 +1605,6 @@ static int omap_hsmmc_regs_show(struct seq_file *s, void *data)
 
         pm_runtime_get_sync(host->dev);
 
-        seq_printf(s, "SYSCONFIG:\t0x%08x\n",
-                        OMAP_HSMMC_READ(host->base, SYSCONFIG));
         seq_printf(s, "CON:\t\t0x%08x\n",
                         OMAP_HSMMC_READ(host->base, CON));
         seq_printf(s, "HCTL:\t\t0x%08x\n",
@@ -2105,8 +2049,7 @@ static int omap_hsmmc_suspend(struct device *dev)
         if (ret) {
                 host->suspended = 0;
                 if (host->pdata->resume) {
-                        ret = host->pdata->resume(dev, host->slot_id);
-                        if (ret)
+                        if (host->pdata->resume(dev, host->slot_id))
                                 dev_dbg(dev, "Unmask interrupt failed\n");
                 }
                 goto err;
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index ca3915dac03d..3f9d6d577a91 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -30,6 +30,9 @@
 #include <linux/regulator/consumer.h>
 #include <linux/gpio.h>
 #include <linux/gfp.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_device.h>
 
 #include <asm/sizes.h>
 
@@ -573,6 +576,50 @@ static irqreturn_t pxamci_detect_irq(int irq, void *devid)
         return IRQ_HANDLED;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id pxa_mmc_dt_ids[] = {
+        { .compatible = "marvell,pxa-mmc" },
+        { }
+};
+
+MODULE_DEVICE_TABLE(of, pxa_mmc_dt_ids);
+
+static int __devinit pxamci_of_init(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct pxamci_platform_data *pdata;
+        u32 tmp;
+
+        if (!np)
+                return 0;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        pdata->gpio_card_detect =
+                of_get_named_gpio(np, "cd-gpios", 0);
+        pdata->gpio_card_ro =
+                of_get_named_gpio(np, "wp-gpios", 0);
+
+        /* pxa-mmc specific */
+        pdata->gpio_power =
+                of_get_named_gpio(np, "pxa-mmc,gpio-power", 0);
+
+        if (of_property_read_u32(np, "pxa-mmc,detect-delay-ms", &tmp) == 0)
+                pdata->detect_delay_ms = tmp;
+
+        pdev->dev.platform_data = pdata;
+
+        return 0;
+}
+#else
+static int __devinit pxamci_of_init(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+
 static int pxamci_probe(struct platform_device *pdev)
 {
         struct mmc_host *mmc;
@@ -580,6 +627,10 @@ static int pxamci_probe(struct platform_device *pdev)
         struct resource *r, *dmarx, *dmatx;
         int ret, irq, gpio_cd = -1, gpio_ro = -1, gpio_power = -1;
 
+        ret = pxamci_of_init(pdev);
+        if (ret)
+                return ret;
+
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
         if (!r || irq < 0)
@@ -866,6 +917,7 @@ static struct platform_driver pxamci_driver = {
         .driver         = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(pxa_mmc_dt_ids),
 #ifdef CONFIG_PM
                 .pm     = &pxamci_pm_ops,
 #endif
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index a6e53a1ebb08..90140eb03e36 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -24,6 +24,7 @@
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/mmc/host.h>
+#include <linux/of.h>
 
 #include "sdhci-pltfm.h"
 
@@ -126,11 +127,18 @@ static int __devexit sdhci_dove_remove(struct platform_device *pdev)
         return sdhci_pltfm_unregister(pdev);
 }
 
+static const struct of_device_id sdhci_dove_of_match_table[] __devinitdata = {
+        { .compatible = "marvell,dove-sdhci", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, sdhci_dove_of_match_table);
+
 static struct platform_driver sdhci_dove_driver = {
         .driver         = {
                 .name   = "sdhci-dove",
                 .owner  = THIS_MODULE,
                 .pm     = SDHCI_PLTFM_PMOPS,
+                .of_match_table = of_match_ptr(sdhci_dove_of_match_table),
         },
         .probe          = sdhci_dove_probe,
         .remove         = __devexit_p(sdhci_dove_remove),
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index f8eb1fb0c921..ae5fcbfa1eef 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -21,6 +21,32 @@
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
+#define VENDOR_V_22     0x12
+static u32 esdhc_readl(struct sdhci_host *host, int reg)
+{
+        u32 ret;
+
+        ret = in_be32(host->ioaddr + reg);
+        /*
+         * The bit of ADMA flag in eSDHC is not compatible with standard
+         * SDHC register, so set fake flag SDHCI_CAN_DO_ADMA2 when ADMA is
+         * supported by eSDHC.
+         * And for many FSL eSDHC controller, the reset value of field
+         * SDHCI_CAN_DO_ADMA1 is one, but some of them can't support ADMA,
+         * only these vendor version is greater than 2.2/0x12 support ADMA.
+         * For FSL eSDHC, must aligned 4-byte, so use 0xFC to read the
+         * the verdor version number, oxFE is SDHCI_HOST_VERSION.
+         */
+        if ((reg == SDHCI_CAPABILITIES) && (ret & SDHCI_CAN_DO_ADMA1)) {
+                u32 tmp = in_be32(host->ioaddr + SDHCI_SLOT_INT_STATUS);
+                tmp = (tmp & SDHCI_VENDOR_VER_MASK) >> SDHCI_VENDOR_VER_SHIFT;
+                if (tmp > VENDOR_V_22)
+                        ret |= SDHCI_CAN_DO_ADMA2;
+        }
+
+        return ret;
+}
+
 static u16 esdhc_readw(struct sdhci_host *host, int reg)
 {
         u16 ret;
@@ -144,7 +170,7 @@ static void esdhc_of_resume(struct sdhci_host *host)
 #endif
 
 static struct sdhci_ops sdhci_esdhc_ops = {
-        .read_l = sdhci_be32bs_readl,
+        .read_l = esdhc_readl,
         .read_w = esdhc_readw,
         .read_b = esdhc_readb,
         .write_l = sdhci_be32bs_writel,
@@ -161,9 +187,13 @@ static struct sdhci_ops sdhci_esdhc_ops = {
 };
 
 static struct sdhci_pltfm_data sdhci_esdhc_pdata = {
-        /* card detection could be handled via GPIO */
+        /*
+         * card detection could be handled via GPIO
+         * eSDHC cannot support End Attribute in NOP ADMA descriptor
+         */
         .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_CARD_DETECTION
-                | SDHCI_QUIRK_NO_CARD_NO_RESET,
+                | SDHCI_QUIRK_NO_CARD_NO_RESET
+                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .ops = &sdhci_esdhc_ops,
 };
 
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 9722d43d6140..4bb74b042a06 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -1476,24 +1476,7 @@ static struct pci_driver sdhci_driver = {
         },
 };
 
-/*****************************************************************************\
- *                                                                           *
- * Driver init/exit                                                          *
- *                                                                           *
-\*****************************************************************************/
-
-static int __init sdhci_drv_init(void)
-{
-        return pci_register_driver(&sdhci_driver);
-}
-
-static void __exit sdhci_drv_exit(void)
-{
-        pci_unregister_driver(&sdhci_driver);
-}
-
-module_init(sdhci_drv_init);
-module_exit(sdhci_drv_exit);
+module_pci_driver(sdhci_driver);
 
 MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
 MODULE_DESCRIPTION("Secure Digital Host Controller Interface PCI driver");
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index d9a4ef4f1ed0..65551a9709cc 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -75,6 +75,9 @@ void sdhci_get_of_property(struct platform_device *pdev)
                 if (sdhci_of_wp_inverted(np))
                         host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
 
+                if (of_get_property(np, "broken-cd", NULL))
+                        host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
+
                 if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc"))
                         host->quirks |= SDHCI_QUIRK_BROKEN_DMA;
 
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index b6ee8857e226..8e63a9c04e31 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -197,7 +197,7 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
                 goto err_clk_get;
         }
         pltfm_host->clk = clk;
-        clk_enable(clk);
+        clk_prepare_enable(clk);
 
         host->quirks = SDHCI_QUIRK_BROKEN_ADMA
                 | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
@@ -239,7 +239,7 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
         return 0;
 
 err_add_host:
-        clk_disable(clk);
+        clk_disable_unprepare(clk);
         clk_put(clk);
 err_clk_get:
         sdhci_pltfm_free(pdev);
@@ -255,7 +255,7 @@ static int __devexit sdhci_pxav2_remove(struct platform_device *pdev)
 
         sdhci_remove_host(host, 1);
 
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
         sdhci_pltfm_free(pdev);
         kfree(pxa);
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index 07fe3834fe0b..e918a2bb3af1 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -24,12 +24,14 @@
 #include <linux/gpio.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/slot-gpio.h>
 #include <linux/platform_data/pxa_sdhci.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/of_gpio.h>
 
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
@@ -182,6 +184,7 @@ static struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
         struct device_node *np = dev->of_node;
         u32 bus_width;
         u32 clk_delay_cycles;
+        enum of_gpio_flags gpio_flags;
 
         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
@@ -198,6 +201,10 @@ static struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
         if (clk_delay_cycles > 0)
                 pdata->clk_delay_cycles = clk_delay_cycles;
 
+        pdata->ext_cd_gpio = of_get_named_gpio_flags(np, "cd-gpios", 0, &gpio_flags);
+        if (gpio_flags != OF_GPIO_ACTIVE_LOW)
+                pdata->host_caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
+
         return pdata;
 }
 #else
@@ -231,14 +238,14 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         pltfm_host = sdhci_priv(host);
         pltfm_host->priv = pxa;
 
-        clk = clk_get(dev, "PXA-SDHCLK");
+        clk = clk_get(dev, NULL);
         if (IS_ERR(clk)) {
                 dev_err(dev, "failed to get io clock\n");
                 ret = PTR_ERR(clk);
                 goto err_clk_get;
         }
         pltfm_host->clk = clk;
-        clk_enable(clk);
+        clk_prepare_enable(clk);
 
         host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
                 | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
@@ -266,12 +273,25 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
                         host->quirks |= pdata->quirks;
                 if (pdata->host_caps)
                         host->mmc->caps |= pdata->host_caps;
+                if (pdata->host_caps2)
+                        host->mmc->caps2 |= pdata->host_caps2;
                 if (pdata->pm_caps)
                         host->mmc->pm_caps |= pdata->pm_caps;
+
+                if (gpio_is_valid(pdata->ext_cd_gpio)) {
+                        ret = mmc_gpio_request_cd(host->mmc, pdata->ext_cd_gpio);
+                        if (ret) {
+                                dev_err(mmc_dev(host->mmc),
+                                        "failed to allocate card detect gpio\n");
+                                goto err_cd_req;
+                        }
+                }
         }
 
         host->ops = &pxav3_sdhci_ops;
 
+        sdhci_get_of_property(pdev);
+
         ret = sdhci_add_host(host);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add host\n");
@@ -283,8 +303,10 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         return 0;
 
 err_add_host:
-        clk_disable(clk);
+        clk_disable_unprepare(clk);
         clk_put(clk);
+        mmc_gpio_free_cd(host->mmc);
+err_cd_req:
 err_clk_get:
         sdhci_pltfm_free(pdev);
         kfree(pxa);
@@ -296,11 +318,16 @@ static int __devexit sdhci_pxav3_remove(struct platform_device *pdev)
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct sdhci_pxa *pxa = pltfm_host->priv;
+        struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
 
         sdhci_remove_host(host, 1);
 
-        clk_disable(pltfm_host->clk);
+        clk_disable_unprepare(pltfm_host->clk);
         clk_put(pltfm_host->clk);
+
+        if (gpio_is_valid(pdata->ext_cd_gpio))
+                mmc_gpio_free_cd(host->mmc);
+
         sdhci_pltfm_free(pdev);
         kfree(pxa);
 
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index a50c205ea208..2903949594c6 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -34,6 +34,9 @@
 
 #define MAX_BUS_CLK     (4)
 
+/* Number of gpio's used is max data bus width + command and clock lines */
+#define NUM_GPIOS(x)    (x + 2)
+
 /**
  * struct sdhci_s3c - S3C SDHCI instance
  * @host: The SDHCI host created
@@ -41,6 +44,7 @@
  * @ioarea: The resource created when we claimed the IO area.
  * @pdata: The platform data for this controller.
  * @cur_clk: The index of the current bus clock.
+ * @gpios: List of gpio numbers parsed from device tree.
  * @clk_io: The clock for the internal bus interface.
  * @clk_bus: The clocks that are available for the SD/MMC bus clock.
  */
@@ -52,6 +56,7 @@ struct sdhci_s3c {
         unsigned int            cur_clk;
         int                     ext_cd_irq;
         int                     ext_cd_gpio;
+        int                     *gpios;
 
         struct clk              *clk_io;
         struct clk              *clk_bus[MAX_BUS_CLK];
@@ -166,7 +171,7 @@ static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c *ourhost,
         dev_dbg(&ourhost->pdev->dev, "clk %d: rate %ld, want %d, got %ld\n",
                 src, rate, wanted, rate / div);
 
-        return (wanted - (rate / div));
+        return wanted - (rate / div);
 }
 
 /**
@@ -203,10 +208,12 @@ static void sdhci_s3c_set_clock(struct sdhci_host *host, unsigned int clock)
                  best_src, clock, best);
 
         /* select the new clock source */
-
         if (ourhost->cur_clk != best_src) {
                 struct clk *clk = ourhost->clk_bus[best_src];
 
+                clk_enable(clk);
+                clk_disable(ourhost->clk_bus[ourhost->cur_clk]);
+
                 /* turn clock off to card before changing clock source */
                 writew(0, host->ioaddr + SDHCI_CLOCK_CONTROL);
 
@@ -288,6 +295,7 @@ static unsigned int sdhci_cmu_get_min_clock(struct sdhci_host *host)
 static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
 {
         struct sdhci_s3c *ourhost = to_s3c(host);
+        struct device *dev = &ourhost->pdev->dev;
         unsigned long timeout;
         u16 clk = 0;
 
@@ -309,8 +317,8 @@ static void sdhci_cmu_set_clock(struct sdhci_host *host, unsigned int clock)
         while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
                 & SDHCI_CLOCK_INT_STABLE)) {
                 if (timeout == 0) {
-                        printk(KERN_ERR "%s: Internal clock never "
-                                "stabilised.\n", mmc_hostname(host->mmc));
+                        dev_err(dev, "%s: Internal clock never stabilised.\n",
+                                mmc_hostname(host->mmc));
                         return;
                 }
                 timeout--;
@@ -404,7 +412,9 @@ static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc)
                 if (sc->ext_cd_irq &&
                     request_threaded_irq(sc->ext_cd_irq, NULL,
                                          sdhci_s3c_gpio_card_detect_thread,
-                                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                         IRQF_TRIGGER_RISING |
+                                         IRQF_TRIGGER_FALLING |
+                                         IRQF_ONESHOT,
                                          dev_name(dev), sc) == 0) {
                         int status = gpio_get_value(sc->ext_cd_gpio);
                         if (pdata->ext_cd_gpio_invert)
@@ -419,9 +429,121 @@ static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc)
         }
 }
 
+#ifdef CONFIG_OF
+static int __devinit sdhci_s3c_parse_dt(struct device *dev,
+                struct sdhci_host *host, struct s3c_sdhci_platdata *pdata)
+{
+        struct device_node *node = dev->of_node;
+        struct sdhci_s3c *ourhost = to_s3c(host);
+        u32 max_width;
+        int gpio, cnt, ret;
+
+        /* if the bus-width property is not specified, assume width as 1 */
+        if (of_property_read_u32(node, "bus-width", &max_width))
+                max_width = 1;
+        pdata->max_width = max_width;
+
+        ourhost->gpios = devm_kzalloc(dev, NUM_GPIOS(pdata->max_width) *
+                                sizeof(int), GFP_KERNEL);
+        if (!ourhost->gpios)
+                return -ENOMEM;
+
+        /* get the card detection method */
+        if (of_get_property(node, "broken-cd", 0)) {
+                pdata->cd_type = S3C_SDHCI_CD_NONE;
+                goto setup_bus;
+        }
+
+        if (of_get_property(node, "non-removable", 0)) {
+                pdata->cd_type = S3C_SDHCI_CD_PERMANENT;
+                goto setup_bus;
+        }
+
+        gpio = of_get_named_gpio(node, "cd-gpios", 0);
+        if (gpio_is_valid(gpio)) {
+                pdata->cd_type = S3C_SDHCI_CD_GPIO;
+                goto found_cd;
+        } else if (gpio != -ENOENT) {
+                dev_err(dev, "invalid card detect gpio specified\n");
+                return -EINVAL;
+        }
+
+        gpio = of_get_named_gpio(node, "samsung,cd-pinmux-gpio", 0);
+        if (gpio_is_valid(gpio)) {
+                pdata->cd_type = S3C_SDHCI_CD_INTERNAL;
+                goto found_cd;
+        } else if (gpio != -ENOENT) {
+                dev_err(dev, "invalid card detect gpio specified\n");
+                return -EINVAL;
+        }
+
+        dev_info(dev, "assuming no card detect line available\n");
+        pdata->cd_type = S3C_SDHCI_CD_NONE;
+
+ found_cd:
+        if (pdata->cd_type == S3C_SDHCI_CD_GPIO) {
+                pdata->ext_cd_gpio = gpio;
+                ourhost->ext_cd_gpio = -1;
+                if (of_get_property(node, "cd-inverted", NULL))
+                        pdata->ext_cd_gpio_invert = 1;
+        } else if (pdata->cd_type == S3C_SDHCI_CD_INTERNAL) {
+                ret = gpio_request(gpio, "sdhci-cd");
+                if (ret) {
+                        dev_err(dev, "card detect gpio request failed\n");
+                        return -EINVAL;
+                }
+                ourhost->ext_cd_gpio = gpio;
+        }
+
+ setup_bus:
+        /* get the gpios for command, clock and data lines */
+        for (cnt = 0; cnt < NUM_GPIOS(pdata->max_width); cnt++) {
+                gpio = of_get_gpio(node, cnt);
+                if (!gpio_is_valid(gpio)) {
+                        dev_err(dev, "invalid gpio[%d]\n", cnt);
+                        goto err_free_dt_cd_gpio;
+                }
+                ourhost->gpios[cnt] = gpio;
+        }
+
+        for (cnt = 0; cnt < NUM_GPIOS(pdata->max_width); cnt++) {
+                ret = gpio_request(ourhost->gpios[cnt], "sdhci-gpio");
+                if (ret) {
+                        dev_err(dev, "gpio[%d] request failed\n", cnt);
+                        goto err_free_dt_gpios;
+                }
+        }
+
+        return 0;
+
+ err_free_dt_gpios:
+        while (--cnt >= 0)
+                gpio_free(ourhost->gpios[cnt]);
+ err_free_dt_cd_gpio:
+        if (pdata->cd_type == S3C_SDHCI_CD_INTERNAL)
+                gpio_free(ourhost->ext_cd_gpio);
+        return -EINVAL;
+}
+#else
+static int __devinit sdhci_s3c_parse_dt(struct device *dev,
+                struct sdhci_host *host, struct s3c_sdhci_platdata *pdata)
+{
+        return -EINVAL;
+}
+#endif
+
+static const struct of_device_id sdhci_s3c_dt_match[];
+
 static inline struct sdhci_s3c_drv_data *sdhci_s3c_get_driver_data(
                         struct platform_device *pdev)
 {
+#ifdef CONFIG_OF
+        if (pdev->dev.of_node) {
+                const struct of_device_id *match;
+                match = of_match_node(sdhci_s3c_dt_match, pdev->dev.of_node);
+                return (struct sdhci_s3c_drv_data *)match->data;
+        }
+#endif
         return (struct sdhci_s3c_drv_data *)
                         platform_get_device_id(pdev)->driver_data;
 }
@@ -436,7 +558,7 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         struct resource *res;
         int ret, irq, ptr, clks;
 
-        if (!pdev->dev.platform_data) {
+        if (!pdev->dev.platform_data && !pdev->dev.of_node) {
                 dev_err(dev, "no device data specified\n");
                 return -ENOENT;
         }
@@ -452,21 +574,28 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
                 dev_err(dev, "sdhci_alloc_host() failed\n");
                 return PTR_ERR(host);
         }
+        sc = sdhci_priv(host);
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata) {
                 ret = -ENOMEM;
-                goto err_io_clk;
+                goto err_pdata;
+        }
+
+        if (pdev->dev.of_node) {
+                ret = sdhci_s3c_parse_dt(&pdev->dev, host, pdata);
+                if (ret)
+                        goto err_pdata;
+        } else {
+                memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
+                sc->ext_cd_gpio = -1; /* invalid gpio number */
         }
-        memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
 
         drv_data = sdhci_s3c_get_driver_data(pdev);
-        sc = sdhci_priv(host);
 
         sc->host = host;
         sc->pdev = pdev;
         sc->pdata = pdata;
-        sc->ext_cd_gpio = -1; /* invalid gpio number */
 
         platform_set_drvdata(pdev, host);
 
@@ -486,9 +615,8 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
                 snprintf(name, 14, "mmc_busclk.%d", ptr);
                 clk = clk_get(dev, name);
-                if (IS_ERR(clk)) {
+                if (IS_ERR(clk))
                         continue;
-                }
 
                 clks++;
                 sc->clk_bus[ptr] = clk;
@@ -499,8 +627,6 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
                  */
                 sc->cur_clk = ptr;
 
-                clk_enable(clk);
-
                 dev_info(dev, "clock source %d: %s (%ld Hz)\n",
                          ptr, name, clk_get_rate(clk));
         }
@@ -511,6 +637,10 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
                 goto err_no_busclks;
         }
 
+#ifndef CONFIG_PM_RUNTIME
+        clk_enable(sc->clk_bus[sc->cur_clk]);
+#endif
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         host->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
         if (!host->ioaddr) {
@@ -616,12 +746,17 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
             gpio_is_valid(pdata->ext_cd_gpio))
                 sdhci_s3c_setup_card_detect_gpio(sc);
 
+#ifdef CONFIG_PM_RUNTIME
+        clk_disable(sc->clk_io);
+#endif
         return 0;
 
  err_req_regs:
+#ifndef CONFIG_PM_RUNTIME
+        clk_disable(sc->clk_bus[sc->cur_clk]);
+#endif
         for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
                 if (sc->clk_bus[ptr]) {
-                        clk_disable(sc->clk_bus[ptr]);
                         clk_put(sc->clk_bus[ptr]);
                 }
         }
@@ -631,6 +766,12 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         clk_put(sc->clk_io);
 
  err_io_clk:
+        for (ptr = 0; ptr < NUM_GPIOS(sc->pdata->max_width); ptr++)
+                gpio_free(sc->gpios[ptr]);
+        if (pdata->cd_type == S3C_SDHCI_CD_INTERNAL)
+                gpio_free(sc->ext_cd_gpio);
+
+ err_pdata:
         sdhci_free_host(host);
 
         return ret;
@@ -638,9 +779,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
 static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
 {
-        struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data;
         struct sdhci_host *host =  platform_get_drvdata(pdev);
         struct sdhci_s3c *sc = sdhci_priv(host);
+        struct s3c_sdhci_platdata *pdata = sc->pdata;
         int ptr;
 
         if (pdata->cd_type == S3C_SDHCI_CD_EXTERNAL && pdata->ext_cd_cleanup)
@@ -652,19 +793,30 @@ static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
         if (gpio_is_valid(sc->ext_cd_gpio))
                 gpio_free(sc->ext_cd_gpio);
 
+#ifdef CONFIG_PM_RUNTIME
+        clk_enable(sc->clk_io);
+#endif
         sdhci_remove_host(host, 1);
 
+        pm_runtime_dont_use_autosuspend(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
-        for (ptr = 0; ptr < 3; ptr++) {
+#ifndef CONFIG_PM_RUNTIME
+        clk_disable(sc->clk_bus[sc->cur_clk]);
+#endif
+        for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
                 if (sc->clk_bus[ptr]) {
-                        clk_disable(sc->clk_bus[ptr]);
                         clk_put(sc->clk_bus[ptr]);
                 }
         }
         clk_disable(sc->clk_io);
         clk_put(sc->clk_io);
 
+        if (pdev->dev.of_node) {
+                for (ptr = 0; ptr < NUM_GPIOS(sc->pdata->max_width); ptr++)
+                        gpio_free(sc->gpios[ptr]);
+        }
+
         sdhci_free_host(host);
         platform_set_drvdata(pdev, NULL);
 
@@ -691,15 +843,28 @@ static int sdhci_s3c_resume(struct device *dev)
 static int sdhci_s3c_runtime_suspend(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
+        struct sdhci_s3c *ourhost = to_s3c(host);
+        struct clk *busclk = ourhost->clk_io;
+        int ret;
+
+        ret = sdhci_runtime_suspend_host(host);
 
-        return sdhci_runtime_suspend_host(host);
+        clk_disable(ourhost->clk_bus[ourhost->cur_clk]);
+        clk_disable(busclk);
+        return ret;
 }
 
 static int sdhci_s3c_runtime_resume(struct device *dev)
 {
         struct sdhci_host *host = dev_get_drvdata(dev);
+        struct sdhci_s3c *ourhost = to_s3c(host);
+        struct clk *busclk = ourhost->clk_io;
+        int ret;
 
-        return sdhci_runtime_resume_host(host);
+        clk_enable(busclk);
+        clk_enable(ourhost->clk_bus[ourhost->cur_clk]);
+        ret = sdhci_runtime_resume_host(host);
+        return ret;
 }
 #endif
 
@@ -737,6 +902,16 @@ static struct platform_device_id sdhci_s3c_driver_ids[] = {
 };
 MODULE_DEVICE_TABLE(platform, sdhci_s3c_driver_ids);
 
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_s3c_dt_match[] = {
+        { .compatible = "samsung,s3c6410-sdhci", },
+        { .compatible = "samsung,exynos4210-sdhci",
+                .data = (void *)EXYNOS4_SDHCI_DRV_DATA },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sdhci_s3c_dt_match);
+#endif
+
 static struct platform_driver sdhci_s3c_driver = {
         .probe          = sdhci_s3c_probe,
         .remove         = __devexit_p(sdhci_s3c_remove),
@@ -744,6 +919,7 @@ static struct platform_driver sdhci_s3c_driver = {
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = "s3c-sdhci",
+                .of_match_table = of_match_ptr(sdhci_s3c_dt_match),
                 .pm     = SDHCI_S3C_PMOPS,
         },
 };
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index 423da8194cd8..6be89c032deb 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -20,6 +20,8 @@
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
@@ -68,8 +70,42 @@ static irqreturn_t sdhci_gpio_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+#ifdef CONFIG_OF
+static struct sdhci_plat_data * __devinit
+sdhci_probe_config_dt(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct sdhci_plat_data *pdata = NULL;
+        int cd_gpio;
+
+        cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
+        if (!gpio_is_valid(cd_gpio))
+                cd_gpio = -1;
+
+        /* If pdata is required */
+        if (cd_gpio != -1) {
+                pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+                if (!pdata) {
+                        dev_err(&pdev->dev, "DT: kzalloc failed\n");
+                        return ERR_PTR(-ENOMEM);
+                }
+        }
+
+        pdata->card_int_gpio = cd_gpio;
+
+        return pdata;
+}
+#else
+static struct sdhci_plat_data * __devinit
+sdhci_probe_config_dt(struct platform_device *pdev)
+{
+        return ERR_PTR(-ENOSYS);
+}
+#endif
+
 static int __devinit sdhci_probe(struct platform_device *pdev)
 {
+        struct device_node *np = pdev->dev.of_node;
         struct sdhci_host *host;
         struct resource *iomem;
         struct spear_sdhci *sdhci;
@@ -104,14 +140,22 @@ static int __devinit sdhci_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        ret = clk_enable(sdhci->clk);
+        ret = clk_prepare_enable(sdhci->clk);
         if (ret) {
                 dev_dbg(&pdev->dev, "Error enabling clock\n");
                 goto put_clk;
         }
 
-        /* overwrite platform_data */
-        sdhci->data = dev_get_platdata(&pdev->dev);
+        if (np) {
+                sdhci->data = sdhci_probe_config_dt(pdev);
+                if (IS_ERR(sdhci->data)) {
+                        dev_err(&pdev->dev, "DT: Failed to get pdata\n");
+                        return -ENODEV;
+                }
+        } else {
+                sdhci->data = dev_get_platdata(&pdev->dev);
+        }
+
         pdev->dev.platform_data = sdhci;
 
         if (pdev->dev.parent)
@@ -216,7 +260,7 @@ set_drvdata:
 free_host:
         sdhci_free_host(host);
 disable_clk:
-        clk_disable(sdhci->clk);
+        clk_disable_unprepare(sdhci->clk);
 put_clk:
         clk_put(sdhci->clk);
 err:
@@ -238,7 +282,7 @@ static int __devexit sdhci_remove(struct platform_device *pdev)
 
         sdhci_remove_host(host, dead);
         sdhci_free_host(host);
-        clk_disable(sdhci->clk);
+        clk_disable_unprepare(sdhci->clk);
         clk_put(sdhci->clk);
 
         return 0;
@@ -253,7 +297,7 @@ static int sdhci_suspend(struct device *dev)
 
         ret = sdhci_suspend_host(host);
         if (!ret)
-                clk_disable(sdhci->clk);
+                clk_disable_unprepare(sdhci->clk);
 
         return ret;
 }
@@ -264,7 +308,7 @@ static int sdhci_resume(struct device *dev)
         struct spear_sdhci *sdhci = dev_get_platdata(dev);
         int ret;
 
-        ret = clk_enable(sdhci->clk);
+        ret = clk_prepare_enable(sdhci->clk);
         if (ret) {
                 dev_dbg(dev, "Resume: Error enabling clock\n");
                 return ret;
@@ -276,11 +320,20 @@ static int sdhci_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(sdhci_pm_ops, sdhci_suspend, sdhci_resume);
 
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_spear_id_table[] = {
+        { .compatible = "st,spear300-sdhci" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, sdhci_spear_id_table);
+#endif
+
 static struct platform_driver sdhci_driver = {
         .driver = {
                 .name   = "sdhci",
                 .owner  = THIS_MODULE,
                 .pm     = &sdhci_pm_ops,
+                .of_match_table = of_match_ptr(sdhci_spear_id_table),
         },
         .probe          = sdhci_probe,
         .remove         = __devexit_p(sdhci_remove),
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index d43e7462941f..84e8d0c59ee5 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -257,10 +257,9 @@ static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
         int rc;
 
         match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
-        if (match)
-                soc_data = match->data;
-        else
-                soc_data = &soc_data_tegra20;
+        if (!match)
+                return -EINVAL;
+        soc_data = match->data;
 
         host = sdhci_pltfm_init(pdev, soc_data->pdata);
         if (IS_ERR(host))
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 9a11dc39921c..7922adb42386 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -28,6 +28,7 @@
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
+#include <linux/mmc/slot-gpio.h>
 
 #include "sdhci.h"
 
@@ -1293,6 +1294,13 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
                                 SDHCI_CARD_PRESENT;
 
+        /* If we're using a cd-gpio, testing the presence bit might fail. */
+        if (!present) {
+                int ret = mmc_gpio_get_cd(host->mmc);
+                if (ret > 0)
+                        present = true;
+        }
+
         if (!present || host->flags & SDHCI_DEVICE_DEAD) {
                 host->mrq->cmd->error = -ENOMEDIUM;
                 tasklet_schedule(&host->finish_tasklet);
@@ -1597,57 +1605,65 @@ static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
-                                                struct mmc_ios *ios)
+static int sdhci_do_3_3v_signal_voltage_switch(struct sdhci_host *host,
+                                                u16 ctrl)
 {
-        u8 pwr;
-        u16 clk, ctrl;
-        u32 present_state;
+        int ret;
 
-        /*
-         * Signal Voltage Switching is only applicable for Host Controllers
-         * v3.00 and above.
-         */
-        if (host->version < SDHCI_SPEC_300)
-                return 0;
+        /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
+        ctrl &= ~SDHCI_CTRL_VDD_180;
+        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
 
-        /*
-         * We first check whether the request is to set signalling voltage
-         * to 3.3V. If so, we change the voltage to 3.3V and return quickly.
-         */
+        if (host->vqmmc) {
+                ret = regulator_set_voltage(host->vqmmc, 3300000, 3300000);
+                if (ret) {
+                        pr_warning("%s: Switching to 3.3V signalling voltage "
+                                   " failed\n", mmc_hostname(host->mmc));
+                        return -EIO;
+                }
+        }
+        /* Wait for 5ms */
+        usleep_range(5000, 5500);
+
+        /* 3.3V regulator output should be stable within 5 ms */
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-        if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
-                /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
-                ctrl &= ~SDHCI_CTRL_VDD_180;
-                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
+        if (!(ctrl & SDHCI_CTRL_VDD_180))
+                return 0;
 
-                /* Wait for 5ms */
-                usleep_range(5000, 5500);
+        pr_warning("%s: 3.3V regulator output did not became stable\n",
+                   mmc_hostname(host->mmc));
 
-                /* 3.3V regulator output should be stable within 5 ms */
-                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
-                if (!(ctrl & SDHCI_CTRL_VDD_180))
-                        return 0;
-                else {
-                        pr_info(DRIVER_NAME ": Switching to 3.3V "
-                                "signalling voltage failed\n");
-                        return -EIO;
-                }
-        } else if (!(ctrl & SDHCI_CTRL_VDD_180) &&
-                  (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180)) {
-                /* Stop SDCLK */
-                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
-                clk &= ~SDHCI_CLOCK_CARD_EN;
-                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+        return -EIO;
+}
 
-                /* Check whether DAT[3:0] is 0000 */
-                present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
-                if (!((present_state & SDHCI_DATA_LVL_MASK) >>
-                       SDHCI_DATA_LVL_SHIFT)) {
-                        /*
-                         * Enable 1.8V Signal Enable in the Host Control2
-                         * register
-                         */
+static int sdhci_do_1_8v_signal_voltage_switch(struct sdhci_host *host,
+                                                u16 ctrl)
+{
+        u8 pwr;
+        u16 clk;
+        u32 present_state;
+        int ret;
+
+        /* Stop SDCLK */
+        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
+        clk &= ~SDHCI_CLOCK_CARD_EN;
+        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
+
+        /* Check whether DAT[3:0] is 0000 */
+        present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
+        if (!((present_state & SDHCI_DATA_LVL_MASK) >>
+               SDHCI_DATA_LVL_SHIFT)) {
+                /*
+                 * Enable 1.8V Signal Enable in the Host Control2
+                 * register
+                 */
+                if (host->vqmmc)
+                        ret = regulator_set_voltage(host->vqmmc,
+                                1800000, 1800000);
+                else
+                        ret = 0;
+
+                if (!ret) {
                         ctrl |= SDHCI_CTRL_VDD_180;
                         sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
 
@@ -1656,7 +1672,7 @@ static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
 
                         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
                         if (ctrl & SDHCI_CTRL_VDD_180) {
-                                /* Provide SDCLK again and wait for 1ms*/
+                                /* Provide SDCLK again and wait for 1ms */
                                 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
                                 clk |= SDHCI_CLOCK_CARD_EN;
                                 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
@@ -1673,29 +1689,55 @@ static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
                                         return 0;
                         }
                 }
+        }
 
-                /*
-                 * If we are here, that means the switch to 1.8V signaling
-                 * failed. We power cycle the card, and retry initialization
-                 * sequence by setting S18R to 0.
-                 */
-                pwr = sdhci_readb(host, SDHCI_POWER_CONTROL);
-                pwr &= ~SDHCI_POWER_ON;
-                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
-                if (host->vmmc)
-                        regulator_disable(host->vmmc);
+        /*
+         * If we are here, that means the switch to 1.8V signaling
+         * failed. We power cycle the card, and retry initialization
+         * sequence by setting S18R to 0.
+         */
+        pwr = sdhci_readb(host, SDHCI_POWER_CONTROL);
+        pwr &= ~SDHCI_POWER_ON;
+        sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+        if (host->vmmc)
+                regulator_disable(host->vmmc);
 
-                /* Wait for 1ms as per the spec */
-                usleep_range(1000, 1500);
-                pwr |= SDHCI_POWER_ON;
-                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
-                if (host->vmmc)
-                        regulator_enable(host->vmmc);
+        /* Wait for 1ms as per the spec */
+        usleep_range(1000, 1500);
+        pwr |= SDHCI_POWER_ON;
+        sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+        if (host->vmmc)
+                regulator_enable(host->vmmc);
 
-                pr_info(DRIVER_NAME ": Switching to 1.8V signalling "
-                        "voltage failed, retrying with S18R set to 0\n");
-                return -EAGAIN;
-        } else
+        pr_warning("%s: Switching to 1.8V signalling voltage failed, "
+                   "retrying with S18R set to 0\n", mmc_hostname(host->mmc));
+
+        return -EAGAIN;
+}
+
+static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
+                                                struct mmc_ios *ios)
+{
+        u16 ctrl;
+
+        /*
+         * Signal Voltage Switching is only applicable for Host Controllers
+         * v3.00 and above.
+         */
+        if (host->version < SDHCI_SPEC_300)
+                return 0;
+
+        /*
+         * We first check whether the request is to set signalling voltage
+         * to 3.3V. If so, we change the voltage to 3.3V and return quickly.
+         */
+        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
+        if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330)
+                return sdhci_do_3_3v_signal_voltage_switch(host, ctrl);
+        else if (!(ctrl & SDHCI_CTRL_VDD_180) &&
+                        (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180))
+                return sdhci_do_1_8v_signal_voltage_switch(host, ctrl);
+        else
                 /* No signal voltage switch required */
                 return 0;
 }
@@ -2802,6 +2844,18 @@ int sdhci_add_host(struct sdhci_host *host)
             !(host->mmc->caps & MMC_CAP_NONREMOVABLE))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
+        /* If vqmmc regulator and no 1.8V signalling, then there's no UHS */
+        host->vqmmc = regulator_get(mmc_dev(mmc), "vqmmc");
+        if (IS_ERR(host->vqmmc)) {
+                pr_info("%s: no vqmmc regulator found\n", mmc_hostname(mmc));
+                host->vqmmc = NULL;
+        }
+        else if (regulator_is_supported_voltage(host->vqmmc, 1800000, 1800000))
+                regulator_enable(host->vqmmc);
+        else
+                caps[1] &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
+                       SDHCI_SUPPORT_DDR50);
+
         /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
         if (caps[1] & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
                        SDHCI_SUPPORT_DDR50))
@@ -2832,15 +2886,6 @@ int sdhci_add_host(struct sdhci_host *host)
         if (caps[1] & SDHCI_DRIVER_TYPE_D)
                 mmc->caps |= MMC_CAP_DRIVER_TYPE_D;
 
-        /*
-         * If Power Off Notify capability is enabled by the host,
-         * set notify to short power off notify timeout value.
-         */
-        if (mmc->caps2 & MMC_CAP2_POWEROFF_NOTIFY)
-                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
-        else
-                mmc->power_notify_type = MMC_HOST_PW_NOTIFY_NONE;
-
         /* Initial value for re-tuning timer count */
         host->tuning_count = (caps[1] & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
                               SDHCI_RETUNING_TIMER_COUNT_SHIFT;
@@ -2862,7 +2907,8 @@ int sdhci_add_host(struct sdhci_host *host)
         if (IS_ERR(host->vmmc)) {
                 pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
                 host->vmmc = NULL;
-        }
+        } else
+                regulator_enable(host->vmmc);
 
 #ifdef CONFIG_REGULATOR
         if (host->vmmc) {
@@ -3119,8 +3165,15 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
         tasklet_kill(&host->card_tasklet);
         tasklet_kill(&host->finish_tasklet);
 
-        if (host->vmmc)
+        if (host->vmmc) {
+                regulator_disable(host->vmmc);
                 regulator_put(host->vmmc);
+        }
+
+        if (host->vqmmc) {
+                regulator_disable(host->vqmmc);
+                regulator_put(host->vqmmc);
+        }
 
         kfree(host->adma_desc);
         kfree(host->align_buffer);
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 5d8142773fac..11d2bc3b51d5 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -1213,7 +1213,9 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_BUFRE);
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
         } else if (state & INT_DTRANE) {
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~INT_DTRANE);
+                sh_mmcif_writel(host->addr, MMCIF_CE_INT,
+                        ~(INT_CMD12DRE | INT_CMD12RBE |
+                          INT_CMD12CRE | INT_DTRANE));
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
         } else if (state & INT_CMD12RBE) {
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT,
@@ -1229,6 +1231,10 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
                 host->sd_error = true;
                 dev_dbg(&host->pd->dev, "int err state = %08x\n", state);
         }
+        if (host->state == STATE_IDLE) {
+                dev_info(&host->pd->dev, "Spurious IRQ status 0x%x", state);
+                return IRQ_HANDLED;
+        }
         if (state & ~(INT_CMD12RBE | INT_CMD12CRE)) {
                 if (!host->dma_active)
                         return IRQ_WAKE_THREAD;
diff --git a/drivers/mmc/host/via-sdmmc.c b/drivers/mmc/host/via-sdmmc.c
index 4b83c43f950d..f18becef156d 100644
--- a/drivers/mmc/host/via-sdmmc.c
+++ b/drivers/mmc/host/via-sdmmc.c
@@ -1337,21 +1337,7 @@ static struct pci_driver via_sd_driver = {
         .resume = via_sd_resume,
 };
 
-static int __init via_sd_drv_init(void)
-{
-        pr_info(DRV_NAME ": VIA SD/MMC Card Reader driver "
-                "(C) 2008 VIA Technologies, Inc.\n");
-
-        return pci_register_driver(&via_sd_driver);
-}
-
-static void __exit via_sd_drv_exit(void)
-{
-        pci_unregister_driver(&via_sd_driver);
-}
-
-module_init(via_sd_drv_init);
-module_exit(via_sd_drv_exit);
+module_pci_driver(via_sd_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("VIA Technologies Inc.");
diff --git a/drivers/mmc/host/vub300.c b/drivers/mmc/host/vub300.c
index 58eab9ac1d01..d5655a63eda4 100644
--- a/drivers/mmc/host/vub300.c
+++ b/drivers/mmc/host/vub300.c
@@ -2358,9 +2358,9 @@ error5:
          * which is contained at the end of struct mmc
          */
 error4:
-        usb_free_urb(command_out_urb);
-error1:
         usb_free_urb(command_res_urb);
+error1:
+        usb_free_urb(command_out_urb);
 error0:
         return retval;
 }
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 27143e042af5..73fcbbeb78d0 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -148,6 +148,13 @@ config MTD_BCM63XX_PARTS
           This provides partions parsing for BCM63xx devices with CFE
           bootloaders.
 
+config MTD_BCM47XX_PARTS
+        tristate "BCM47XX partitioning support"
+        depends on BCM47XX
+        help
+          This provides partitions parser for devices based on BCM47xx
+          boards.
+
 comment "User Modules And Translation Layers"
 
 config MTD_CHAR
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index f90135429dc7..18a38e55b2f0 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_MTD_CMDLINE_PARTS) += cmdlinepart.o
 obj-$(CONFIG_MTD_AFS_PARTS)     += afs.o
 obj-$(CONFIG_MTD_AR7_PARTS)     += ar7part.o
 obj-$(CONFIG_MTD_BCM63XX_PARTS) += bcm63xxpart.o
+obj-$(CONFIG_MTD_BCM47XX_PARTS) += bcm47xxpart.o
 
 # 'Users' - code which presents functionality to userspace.
 obj-$(CONFIG_MTD_CHAR)          += mtdchar.o
diff --git a/drivers/mtd/bcm47xxpart.c b/drivers/mtd/bcm47xxpart.c
new file mode 100644
index 000000000000..e06d782489a6
--- /dev/null
+++ b/drivers/mtd/bcm47xxpart.c
@@ -0,0 +1,202 @@
+/*
+ * BCM47XX MTD partitioning
+ *
+ * Copyright © 2012 Rafał Miłecki <zajec5@gmail.com>
+ *
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <asm/mach-bcm47xx/nvram.h>
+
+/* 10 parts were found on sflash on Netgear WNDR4500 */
+#define BCM47XXPART_MAX_PARTS           12
+
+/*
+ * Amount of bytes we read when analyzing each block of flash memory.
+ * Set it big enough to allow detecting partition and reading important data.
+ */
+#define BCM47XXPART_BYTES_TO_READ       0x404
+
+/* Magics */
+#define BOARD_DATA_MAGIC                0x5246504D      /* MPFR */
+#define POT_MAGIC1                      0x54544f50      /* POTT */
+#define POT_MAGIC2                      0x504f          /* OP */
+#define ML_MAGIC1                       0x39685a42
+#define ML_MAGIC2                       0x26594131
+#define TRX_MAGIC                       0x30524448
+
+struct trx_header {
+        uint32_t magic;
+        uint32_t length;
+        uint32_t crc32;
+        uint16_t flags;
+        uint16_t version;
+        uint32_t offset[3];
+} __packed;
+
+static void bcm47xxpart_add_part(struct mtd_partition *part, char *name,
+                                 u64 offset, uint32_t mask_flags)
+{
+        part->name = name;
+        part->offset = offset;
+        part->mask_flags = mask_flags;
+}
+
+static int bcm47xxpart_parse(struct mtd_info *master,
+                             struct mtd_partition **pparts,
+                             struct mtd_part_parser_data *data)
+{
+        struct mtd_partition *parts;
+        uint8_t i, curr_part = 0;
+        uint32_t *buf;
+        size_t bytes_read;
+        uint32_t offset;
+        uint32_t blocksize = 0x10000;
+        struct trx_header *trx;
+
+        /* Alloc */
+        parts = kzalloc(sizeof(struct mtd_partition) * BCM47XXPART_MAX_PARTS,
+                        GFP_KERNEL);
+        buf = kzalloc(BCM47XXPART_BYTES_TO_READ, GFP_KERNEL);
+
+        /* Parse block by block looking for magics */
+        for (offset = 0; offset <= master->size - blocksize;
+             offset += blocksize) {
+                /* Nothing more in higher memory */
+                if (offset >= 0x2000000)
+                        break;
+
+                if (curr_part > BCM47XXPART_MAX_PARTS) {
+                        pr_warn("Reached maximum number of partitions, scanning stopped!\n");
+                        break;
+                }
+
+                /* Read beginning of the block */
+                if (mtd_read(master, offset, BCM47XXPART_BYTES_TO_READ,
+                             &bytes_read, (uint8_t *)buf) < 0) {
+                        pr_err("mtd_read error while parsing (offset: 0x%X)!\n",
+                               offset);
+                        continue;
+                }
+
+                /* CFE has small NVRAM at 0x400 */
+                if (buf[0x400 / 4] == NVRAM_HEADER) {
+                        bcm47xxpart_add_part(&parts[curr_part++], "boot",
+                                             offset, MTD_WRITEABLE);
+                        continue;
+                }
+
+                /* Standard NVRAM */
+                if (buf[0x000 / 4] == NVRAM_HEADER) {
+                        bcm47xxpart_add_part(&parts[curr_part++], "nvram",
+                                             offset, 0);
+                        continue;
+                }
+
+                /*
+                 * board_data starts with board_id which differs across boards,
+                 * but we can use 'MPFR' (hopefully) magic at 0x100
+                 */
+                if (buf[0x100 / 4] == BOARD_DATA_MAGIC) {
+                        bcm47xxpart_add_part(&parts[curr_part++], "board_data",
+                                             offset, MTD_WRITEABLE);
+                        continue;
+                }
+
+                /* POT(TOP) */
+                if (buf[0x000 / 4] == POT_MAGIC1 &&
+                    (buf[0x004 / 4] & 0xFFFF) == POT_MAGIC2) {
+                        bcm47xxpart_add_part(&parts[curr_part++], "POT", offset,
+                                             MTD_WRITEABLE);
+                        continue;
+                }
+
+                /* ML */
+                if (buf[0x010 / 4] == ML_MAGIC1 &&
+                    buf[0x014 / 4] == ML_MAGIC2) {
+                        bcm47xxpart_add_part(&parts[curr_part++], "ML", offset,
+                                             MTD_WRITEABLE);
+                        continue;
+                }
+
+                /* TRX */
+                if (buf[0x000 / 4] == TRX_MAGIC) {
+                        trx = (struct trx_header *)buf;
+
+                        i = 0;
+                        /* We have LZMA loader if offset[2] points to sth */
+                        if (trx->offset[2]) {
+                                bcm47xxpart_add_part(&parts[curr_part++],
+                                                     "loader",
+                                                     offset + trx->offset[i],
+                                                     0);
+                                i++;
+                        }
+
+                        bcm47xxpart_add_part(&parts[curr_part++], "linux",
+                                             offset + trx->offset[i], 0);
+                        i++;
+
+                        /*
+                         * Pure rootfs size is known and can be calculated as:
+                         * trx->length - trx->offset[i]. We don't fill it as
+                         * we want to have jffs2 (overlay) in the same mtd.
+                         */
+                        bcm47xxpart_add_part(&parts[curr_part++], "rootfs",
+                                             offset + trx->offset[i], 0);
+                        i++;
+
+                        /*
+                         * We have whole TRX scanned, skip to the next part. Use
+                         * roundown (not roundup), as the loop will increase
+                         * offset in next step.
+                         */
+                        offset = rounddown(offset + trx->length, blocksize);
+                        continue;
+                }
+        }
+        kfree(buf);
+
+        /*
+         * Assume that partitions end at the beginning of the one they are
+         * followed by.
+         */
+        for (i = 0; i < curr_part - 1; i++)
+                parts[i].size = parts[i + 1].offset - parts[i].offset;
+        if (curr_part > 0)
+                parts[curr_part - 1].size =
+                                master->size - parts[curr_part - 1].offset;
+
+        *pparts = parts;
+        return curr_part;
+};
+
+static struct mtd_part_parser bcm47xxpart_mtd_parser = {
+        .owner = THIS_MODULE,
+        .parse_fn = bcm47xxpart_parse,
+        .name = "bcm47xxpart",
+};
+
+static int __init bcm47xxpart_init(void)
+{
+        return register_mtd_parser(&bcm47xxpart_mtd_parser);
+}
+
+static void __exit bcm47xxpart_exit(void)
+{
+        deregister_mtd_parser(&bcm47xxpart_mtd_parser);
+}
+
+module_init(bcm47xxpart_init);
+module_exit(bcm47xxpart_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("MTD partitioning for BCM47XX flash memories");
diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index b1e3c26edd6d..e469b01d40d2 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -43,9 +43,6 @@ choice
         prompt "Flash cmd/query data swapping"
         depends on MTD_CFI_ADV_OPTIONS
         default MTD_CFI_NOSWAP
-
-config MTD_CFI_NOSWAP
-        bool "NO"
         ---help---
           This option defines the way in which the CPU attempts to arrange
           data bits when writing the 'magic' commands to the chips. Saying
@@ -55,12 +52,8 @@ config MTD_CFI_NOSWAP
           Specific arrangements are possible with the BIG_ENDIAN_BYTE and
           LITTLE_ENDIAN_BYTE, if the bytes are reversed.
 
-          If you have a LART, on which the data (and address) lines were
-          connected in a fashion which ensured that the nets were as short
-          as possible, resulting in a bit-shuffling which seems utterly
-          random to the untrained eye, you need the LART_ENDIAN_BYTE option.
-
-          Yes, there really exists something sicker than PDP-endian :)
+config MTD_CFI_NOSWAP
+        bool "NO"
 
 config MTD_CFI_BE_BYTE_SWAP
         bool "BIG_ENDIAN_BYTE"
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index dbbd2edfb812..77514430f1fe 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -2043,7 +2043,7 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
 {
         struct cfi_private *cfi = map->fldrv_priv;
         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
-        int udelay;
+        int mdelay;
         int ret;
 
         adr += chip->start;
@@ -2072,9 +2072,17 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
          * If Instant Individual Block Locking supported then no need
          * to delay.
          */
-        udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
+        /*
+         * Unlocking may take up to 1.4 seconds on some Intel flashes. So
+         * lets use a max of 1.5 seconds (1500ms) as timeout.
+         *
+         * See "Clear Block Lock-Bits Time" on page 40 in
+         * "3 Volt Intel StrataFlash Memory" 28F128J3,28F640J3,28F320J3 manual
+         * from February 2003
+         */
+        mdelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1500 : 0;
 
-        ret = WAIT_TIMEOUT(map, chip, adr, udelay, udelay * 100);
+        ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000);
         if (ret) {
                 map_write(map, CMD(0x70), adr);
                 chip->state = FL_STATUS;
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index 22d0493a026f..5ff5c4a16943 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -431,6 +431,68 @@ static void cfi_fixup_major_minor(struct cfi_private *cfi,
         }
 }
 
+static int is_m29ew(struct cfi_private *cfi)
+{
+        if (cfi->mfr == CFI_MFR_INTEL &&
+            ((cfi->device_type == CFI_DEVICETYPE_X8 && (cfi->id & 0xff) == 0x7e) ||
+             (cfi->device_type == CFI_DEVICETYPE_X16 && cfi->id == 0x227e)))
+                return 1;
+        return 0;
+}
+
+/*
+ * From TN-13-07: Patching the Linux Kernel and U-Boot for M29 Flash, page 20:
+ * Some revisions of the M29EW suffer from erase suspend hang ups. In
+ * particular, it can occur when the sequence
+ * Erase Confirm -> Suspend -> Program -> Resume
+ * causes a lockup due to internal timing issues. The consequence is that the
+ * erase cannot be resumed without inserting a dummy command after programming
+ * and prior to resuming. [...] The work-around is to issue a dummy write cycle
+ * that writes an F0 command code before the RESUME command.
+ */
+static void cfi_fixup_m29ew_erase_suspend(struct map_info *map,
+                                          unsigned long adr)
+{
+        struct cfi_private *cfi = map->fldrv_priv;
+        /* before resume, insert a dummy 0xF0 cycle for Micron M29EW devices */
+        if (is_m29ew(cfi))
+                map_write(map, CMD(0xF0), adr);
+}
+
+/*
+ * From TN-13-07: Patching the Linux Kernel and U-Boot for M29 Flash, page 22:
+ *
+ * Some revisions of the M29EW (for example, A1 and A2 step revisions)
+ * are affected by a problem that could cause a hang up when an ERASE SUSPEND
+ * command is issued after an ERASE RESUME operation without waiting for a
+ * minimum delay.  The result is that once the ERASE seems to be completed
+ * (no bits are toggling), the contents of the Flash memory block on which
+ * the erase was ongoing could be inconsistent with the expected values
+ * (typically, the array value is stuck to the 0xC0, 0xC4, 0x80, or 0x84
+ * values), causing a consequent failure of the ERASE operation.
+ * The occurrence of this issue could be high, especially when file system
+ * operations on the Flash are intensive.  As a result, it is recommended
+ * that a patch be applied.  Intensive file system operations can cause many
+ * calls to the garbage routine to free Flash space (also by erasing physical
+ * Flash blocks) and as a result, many consecutive SUSPEND and RESUME
+ * commands can occur.  The problem disappears when a delay is inserted after
+ * the RESUME command by using the udelay() function available in Linux.
+ * The DELAY value must be tuned based on the customer's platform.
+ * The maximum value that fixes the problem in all cases is 500us.
+ * But, in our experience, a delay of 30 µs to 50 µs is sufficient
+ * in most cases.
+ * We have chosen 500µs because this latency is acceptable.
+ */
+static void cfi_fixup_m29ew_delay_after_resume(struct cfi_private *cfi)
+{
+        /*
+         * Resolving the Delay After Resume Issue see Micron TN-13-07
+         * Worst case delay must be 500µs but 30-50µs should be ok as well
+         */
+        if (is_m29ew(cfi))
+                cfi_udelay(500);
+}
+
 struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
 {
         struct cfi_private *cfi = map->fldrv_priv;
@@ -776,7 +838,10 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
 
         switch(chip->oldstate) {
         case FL_ERASING:
+                cfi_fixup_m29ew_erase_suspend(map,
+                        chip->in_progress_block_addr);
                 map_write(map, cfi->sector_erase_cmd, chip->in_progress_block_addr);
+                cfi_fixup_m29ew_delay_after_resume(cfi);
                 chip->oldstate = FL_READY;
                 chip->state = FL_ERASING;
                 break;
@@ -916,6 +981,8 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
                         /* Disallow XIP again */
                         local_irq_disable();
 
+                        /* Correct Erase Suspend Hangups for M29EW */
+                        cfi_fixup_m29ew_erase_suspend(map, adr);
                         /* Resume the write or erase operation */
                         map_write(map, cfi->sector_erase_cmd, adr);
                         chip->state = oldstate;
diff --git a/drivers/mtd/cmdlinepart.c b/drivers/mtd/cmdlinepart.c
index 4558e0f4d07f..aed1b8a63c9f 100644
--- a/drivers/mtd/cmdlinepart.c
+++ b/drivers/mtd/cmdlinepart.c
@@ -39,11 +39,10 @@
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
-
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
-#include <linux/bootmem.h>
 #include <linux/module.h>
+#include <linux/err.h>
 
 /* error message prefix */
 #define ERRP "mtd: "
@@ -72,7 +71,7 @@ static struct cmdline_mtd_partition *partitions;
 
 /* the command line passed to mtdpart_setup() */
 static char *cmdline;
-static int cmdline_parsed = 0;
+static int cmdline_parsed;
 
 /*
  * Parse one partition definition for an MTD. Since there can be many
@@ -83,15 +82,14 @@ static int cmdline_parsed = 0;
  * syntax has been verified ok.
  */
 static struct mtd_partition * newpart(char *s,
-                                      char **retptr,
-                                      int *num_parts,
-                                      int this_part,
-                                      unsigned char **extra_mem_ptr,
-                                      int extra_mem_size)
+                                      char **retptr,
+                                      int *num_parts,
+                                      int this_part,
+                                      unsigned char **extra_mem_ptr,
+                                      int extra_mem_size)
 {
         struct mtd_partition *parts;
-        unsigned long size;
-        unsigned long offset = OFFSET_CONTINUOUS;
+        unsigned long size, offset = OFFSET_CONTINUOUS;
         char *name;
         int name_len;
         unsigned char *extra_mem;
@@ -99,124 +97,106 @@ static struct mtd_partition * newpart(char *s,
         unsigned int mask_flags;
 
         /* fetch the partition size */
-        if (*s == '-')
-        {       /* assign all remaining space to this partition */
+        if (*s == '-') {
+                /* assign all remaining space to this partition */
                 size = SIZE_REMAINING;
                 s++;
-        }
-        else
-        {
+        } else {
                 size = memparse(s, &s);
-                if (size < PAGE_SIZE)
-                {
+                if (size < PAGE_SIZE) {
                         printk(KERN_ERR ERRP "partition size too small (%lx)\n", size);
-                        return NULL;
+                        return ERR_PTR(-EINVAL);
                 }
         }
 
         /* fetch partition name and flags */
         mask_flags = 0; /* this is going to be a regular partition */
         delim = 0;
-        /* check for offset */
-        if (*s == '@')
-        {
-                s++;
-                offset = memparse(s, &s);
-        }
-        /* now look for name */
+
+        /* check for offset */
+        if (*s == '@') {
+                s++;
+                offset = memparse(s, &s);
+        }
+
+        /* now look for name */
         if (*s == '(')
-        {
                 delim = ')';
-        }
 
-        if (delim)
-        {
+        if (delim) {
                 char *p;
 
-                name = ++s;
+                name = ++s;
                 p = strchr(name, delim);
-                if (!p)
-                {
+                if (!p) {
                         printk(KERN_ERR ERRP "no closing %c found in partition name\n", delim);
-                        return NULL;
+                        return ERR_PTR(-EINVAL);
                 }
                 name_len = p - name;
                 s = p + 1;
-        }
-        else
-        {
-                name = NULL;
+        } else {
+                name = NULL;
                 name_len = 13; /* Partition_000 */
         }
 
         /* record name length for memory allocation later */
         extra_mem_size += name_len + 1;
 
-        /* test for options */
-        if (strncmp(s, "ro", 2) == 0)
-        {
+        /* test for options */
+        if (strncmp(s, "ro", 2) == 0) {
                 mask_flags |= MTD_WRITEABLE;
                 s += 2;
-        }
+        }
 
-        /* if lk is found do NOT unlock the MTD partition*/
-        if (strncmp(s, "lk", 2) == 0)
-        {
+        /* if lk is found do NOT unlock the MTD partition*/
+        if (strncmp(s, "lk", 2) == 0) {
                 mask_flags |= MTD_POWERUP_LOCK;
                 s += 2;
-        }
+        }
 
         /* test if more partitions are following */
-        if (*s == ',')
-        {
-                if (size == SIZE_REMAINING)
-                {
+        if (*s == ',') {
+                if (size == SIZE_REMAINING) {
                         printk(KERN_ERR ERRP "no partitions allowed after a fill-up partition\n");
-                        return NULL;
+                        return ERR_PTR(-EINVAL);
                 }
                 /* more partitions follow, parse them */
                 parts = newpart(s + 1, &s, num_parts, this_part + 1,
                                 &extra_mem, extra_mem_size);
-                if (!parts)
-                        return NULL;
-        }
-        else
-        {       /* this is the last partition: allocate space for all */
+                if (IS_ERR(parts))
+                        return parts;
+        } else {
+                /* this is the last partition: allocate space for all */
                 int alloc_size;
 
                 *num_parts = this_part + 1;
                 alloc_size = *num_parts * sizeof(struct mtd_partition) +
                              extra_mem_size;
+
                 parts = kzalloc(alloc_size, GFP_KERNEL);
                 if (!parts)
-                        return NULL;
+                        return ERR_PTR(-ENOMEM);
                 extra_mem = (unsigned char *)(parts + *num_parts);
         }
+
         /* enter this partition (offset will be calculated later if it is zero at this point) */
         parts[this_part].size = size;
         parts[this_part].offset = offset;
         parts[this_part].mask_flags = mask_flags;
         if (name)
-        {
                 strlcpy(extra_mem, name, name_len + 1);
-        }
         else
-        {
                 sprintf(extra_mem, "Partition_%03d", this_part);
-        }
         parts[this_part].name = extra_mem;
         extra_mem += name_len + 1;
 
         dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n",
-             this_part,
-             parts[this_part].name,
-             parts[this_part].offset,
-             parts[this_part].size,
-             parts[this_part].mask_flags));
+             this_part, parts[this_part].name, parts[this_part].offset,
+             parts[this_part].size, parts[this_part].mask_flags));
 
         /* return (updated) pointer to extra_mem memory */
         if (extra_mem_ptr)
-          *extra_mem_ptr = extra_mem;
+                *extra_mem_ptr = extra_mem;
 
         /* return (updated) pointer command line string */
         *retptr = s;
@@ -236,16 +216,16 @@ static int mtdpart_setup_real(char *s)
         {
                 struct cmdline_mtd_partition *this_mtd;
                 struct mtd_partition *parts;
-                int mtd_id_len;
-                int num_parts;
+                int mtd_id_len, num_parts;
                 char *p, *mtd_id;
 
-                mtd_id = s;
+                mtd_id = s;
+
                 /* fetch <mtd-id> */
-                if (!(p = strchr(s, ':')))
-                {
+                p = strchr(s, ':');
+                if (!p) {
                         printk(KERN_ERR ERRP "no mtd-id\n");
-                        return 0;
+                        return -EINVAL;
                 }
                 mtd_id_len = p - mtd_id;
 
@@ -262,8 +242,7 @@ static int mtdpart_setup_real(char *s)
                                 (unsigned char**)&this_mtd, /* out: extra mem */
                                 mtd_id_len + 1 + sizeof(*this_mtd) +
                                 sizeof(void*)-1 /*alignment*/);
-                if(!parts)
-                {
+                if (IS_ERR(parts)) {
                         /*
                          * An error occurred. We're either:
                          * a) out of memory, or
@@ -271,12 +250,12 @@ static int mtdpart_setup_real(char *s)
                          * Either way, this mtd is hosed and we're
                          * unlikely to succeed in parsing any more
                          */
-                         return 0;
+                         return PTR_ERR(parts);
                  }
 
                 /* align this_mtd */
                 this_mtd = (struct cmdline_mtd_partition *)
-                        ALIGN((unsigned long)this_mtd, sizeof(void*));
+                                ALIGN((unsigned long)this_mtd, sizeof(void *));
                 /* enter results */
                 this_mtd->parts = parts;
                 this_mtd->num_parts = num_parts;
@@ -296,14 +275,14 @@ static int mtdpart_setup_real(char *s)
                         break;
 
                 /* does another spec follow? */
-                if (*s != ';')
-                {
+                if (*s != ';') {
                         printk(KERN_ERR ERRP "bad character after partition (%c)\n", *s);
-                        return 0;
+                        return -EINVAL;
                 }
                 s++;
         }
-        return 1;
+
+        return 0;
 }
 
 /*
@@ -318,44 +297,58 @@ static int parse_cmdline_partitions(struct mtd_info *master,
                                     struct mtd_part_parser_data *data)
 {
         unsigned long offset;
-        int i;
+        int i, err;
         struct cmdline_mtd_partition *part;
         const char *mtd_id = master->name;
 
         /* parse command line */
-        if (!cmdline_parsed)
-                mtdpart_setup_real(cmdline);
+        if (!cmdline_parsed) {
+                err = mtdpart_setup_real(cmdline);
+                if (err)
+                        return err;
+        }
 
-        for(part = partitions; part; part = part->next)
-        {
-                if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id)))
-                {
-                        for(i = 0, offset = 0; i < part->num_parts; i++)
-                        {
+        for (part = partitions; part; part = part->next) {
+                if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id))) {
+                        for (i = 0, offset = 0; i < part->num_parts; i++) {
                                 if (part->parts[i].offset == OFFSET_CONTINUOUS)
-                                  part->parts[i].offset = offset;
+                                        part->parts[i].offset = offset;
                                 else
-                                  offset = part->parts[i].offset;
+                                        offset = part->parts[i].offset;
+
                                 if (part->parts[i].size == SIZE_REMAINING)
-                                  part->parts[i].size = master->size - offset;
-                                if (offset + part->parts[i].size > master->size)
-                                {
+                                        part->parts[i].size = master->size - offset;
+
+                                if (part->parts[i].size == 0) {
+                                        printk(KERN_WARNING ERRP
+                                               "%s: skipping zero sized partition\n",
+                                               part->mtd_id);
+                                        part->num_parts--;
+                                        memmove(&part->parts[i],
+                                                &part->parts[i + 1],
+                                                sizeof(*part->parts) * (part->num_parts - i));
+                                        continue;
+                                }
+
+                                if (offset + part->parts[i].size > master->size) {
                                         printk(KERN_WARNING ERRP
                                                "%s: partitioning exceeds flash size, truncating\n",
                                                part->mtd_id);
                                         part->parts[i].size = master->size - offset;
-                                        part->num_parts = i;
                                 }
                                 offset += part->parts[i].size;
                         }
+
                         *pparts = kmemdup(part->parts,
                                         sizeof(*part->parts) * part->num_parts,
                                         GFP_KERNEL);
                         if (!*pparts)
                                 return -ENOMEM;
+
                         return part->num_parts;
                 }
         }
+
         return 0;
 }
 
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index 4cdb2af7bf44..27f80cd8aef3 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -97,7 +97,7 @@ config MTD_M25P80
           doesn't support the JEDEC ID instruction.
 
 config M25PXX_USE_FAST_READ
-        bool "Use FAST_READ OPCode allowing SPI CLK <= 50MHz"
+        bool "Use FAST_READ OPCode allowing SPI CLK >= 50MHz"
         depends on MTD_M25P80
         default y
         help
@@ -120,6 +120,14 @@ config MTD_SST25L
           Set up your spi devices with the right board-specific platform data,
           if you want to specify device partitioning.
 
+config MTD_BCM47XXSFLASH
+        tristate "R/O support for serial flash on BCMA bus"
+        depends on BCMA_SFLASH
+        help
+          BCMA bus can have various flash memories attached, they are
+          registered by bcma as platform devices. This enables driver for
+          serial flash memories (only read-only mode is implemented).
+
 config MTD_SLRAM
         tristate "Uncached system RAM"
         help
diff --git a/drivers/mtd/devices/Makefile b/drivers/mtd/devices/Makefile
index a4dd1d822b6c..395733a30ef4 100644
--- a/drivers/mtd/devices/Makefile
+++ b/drivers/mtd/devices/Makefile
@@ -19,5 +19,6 @@ obj-$(CONFIG_MTD_DATAFLASH)	+= mtd_dataflash.o
 obj-$(CONFIG_MTD_M25P80)        += m25p80.o
 obj-$(CONFIG_MTD_SPEAR_SMI)     += spear_smi.o
 obj-$(CONFIG_MTD_SST25L)        += sst25l.o
+obj-$(CONFIG_MTD_BCM47XXSFLASH) += bcm47xxsflash.o
 
 CFLAGS_docg3.o                  += -I$(src)
\ No newline at end of file
diff --git a/drivers/mtd/devices/bcm47xxsflash.c b/drivers/mtd/devices/bcm47xxsflash.c
new file mode 100644
index 000000000000..2dc5a6f3fd57
--- /dev/null
+++ b/drivers/mtd/devices/bcm47xxsflash.c
@@ -0,0 +1,105 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/mtd/mtd.h>
+#include <linux/platform_device.h>
+#include <linux/bcma/bcma.h>
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
+
+static const char *probes[] = { "bcm47xxpart", NULL };
+
+static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
+                              size_t *retlen, u_char *buf)
+{
+        struct bcma_sflash *sflash = mtd->priv;
+
+        /* Check address range */
+        if ((from + len) > mtd->size)
+                return -EINVAL;
+
+        memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(sflash->window + from),
+                      len);
+
+        return len;
+}
+
+static void bcm47xxsflash_fill_mtd(struct bcma_sflash *sflash,
+                                   struct mtd_info *mtd)
+{
+        mtd->priv = sflash;
+        mtd->name = "bcm47xxsflash";
+        mtd->owner = THIS_MODULE;
+        mtd->type = MTD_ROM;
+        mtd->size = sflash->size;
+        mtd->_read = bcm47xxsflash_read;
+
+        /* TODO: implement writing support and verify/change following code */
+        mtd->flags = MTD_CAP_ROM;
+        mtd->writebufsize = mtd->writesize = 1;
+}
+
+static int bcm47xxsflash_probe(struct platform_device *pdev)
+{
+        struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
+        int err;
+
+        sflash->mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
+        if (!sflash->mtd) {
+                err = -ENOMEM;
+                goto out;
+        }
+        bcm47xxsflash_fill_mtd(sflash, sflash->mtd);
+
+        err = mtd_device_parse_register(sflash->mtd, probes, NULL, NULL, 0);
+        if (err) {
+                pr_err("Failed to register MTD device: %d\n", err);
+                goto err_dev_reg;
+        }
+
+        return 0;
+
+err_dev_reg:
+        kfree(sflash->mtd);
+out:
+        return err;
+}
+
+static int __devexit bcm47xxsflash_remove(struct platform_device *pdev)
+{
+        struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
+
+        mtd_device_unregister(sflash->mtd);
+        kfree(sflash->mtd);
+
+        return 0;
+}
+
+static struct platform_driver bcma_sflash_driver = {
+        .remove = __devexit_p(bcm47xxsflash_remove),
+        .driver = {
+                .name = "bcma_sflash",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init bcm47xxsflash_init(void)
+{
+        int err;
+
+        err = platform_driver_probe(&bcma_sflash_driver, bcm47xxsflash_probe);
+        if (err)
+                pr_err("Failed to register BCMA serial flash driver: %d\n",
+                       err);
+
+        return err;
+}
+
+static void __exit bcm47xxsflash_exit(void)
+{
+        platform_driver_unregister(&bcma_sflash_driver);
+}
+
+module_init(bcm47xxsflash_init);
+module_exit(bcm47xxsflash_exit);
diff --git a/drivers/mtd/devices/doc2001plus.c b/drivers/mtd/devices/doc2001plus.c
index 04eb2e4aa50f..4f2220ad8924 100644
--- a/drivers/mtd/devices/doc2001plus.c
+++ b/drivers/mtd/devices/doc2001plus.c
@@ -659,23 +659,15 @@ static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
 #ifdef ECC_DEBUG
                         printk("%s(%d): Millennium Plus ECC error (from=0x%x:\n",
                                 __FILE__, __LINE__, (int)from);
-                        printk("        syndrome= %02x:%02x:%02x:%02x:%02x:"
-                                "%02x\n",
-                                syndrome[0], syndrome[1], syndrome[2],
-                                syndrome[3], syndrome[4], syndrome[5]);
-                        printk("          eccbuf= %02x:%02x:%02x:%02x:%02x:"
-                                "%02x\n",
-                                eccbuf[0], eccbuf[1], eccbuf[2],
-                                eccbuf[3], eccbuf[4], eccbuf[5]);
+                        printk("        syndrome= %*phC\n", 6, syndrome);
+                        printk("        eccbuf= %*phC\n", 6, eccbuf);
 #endif
                                 ret = -EIO;
                 }
         }
 
 #ifdef PSYCHO_DEBUG
-        printk("ECC DATA at %lx: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
-               (long)from, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
-               eccbuf[4], eccbuf[5]);
+        printk("ECC DATA at %lx: %*ph\n", (long)from, 6, eccbuf);
 #endif
         /* disable the ECC engine */
         WriteDOC(DOC_ECC_DIS, docptr , Mplus_ECCConf);
diff --git a/drivers/mtd/devices/docg3.c b/drivers/mtd/devices/docg3.c
index f70854d728fe..d34d83b8f9c2 100644
--- a/drivers/mtd/devices/docg3.c
+++ b/drivers/mtd/devices/docg3.c
@@ -919,19 +919,13 @@ static int doc_read_oob(struct mtd_info *mtd, loff_t from,
                 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);
 
                 if (nboob >= DOC_LAYOUT_OOB_SIZE) {
-                        doc_dbg("OOB - INFO: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
-                                oobbuf[0], oobbuf[1], oobbuf[2], oobbuf[3],
-                                oobbuf[4], oobbuf[5], oobbuf[6]);
+                        doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf);
                         doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]);
-                        doc_dbg("OOB - BCH_ECC: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
-                                oobbuf[8], oobbuf[9], oobbuf[10], oobbuf[11],
-                                oobbuf[12], oobbuf[13], oobbuf[14]);
+                        doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8);
                         doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]);
                 }
                 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1);
-                doc_dbg("ECC HW_ECC: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
-                        hwecc[0], hwecc[1], hwecc[2], hwecc[3], hwecc[4],
-                        hwecc[5], hwecc[6]);
+                doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc);
 
                 ret = -EIO;
                 if (is_prot_seq_error(docg3))
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 5d0d68c3fe27..03838bab1f59 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -633,11 +633,14 @@ static const struct spi_device_id m25p_ids[] = {
         { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
         { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
 
+        { "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
+
         /* EON -- en25xxx */
         { "en25f32", INFO(0x1c3116, 0, 64 * 1024,  64, SECT_4K) },
         { "en25p32", INFO(0x1c2016, 0, 64 * 1024,  64, 0) },
         { "en25q32b", INFO(0x1c3016, 0, 64 * 1024,  64, 0) },
         { "en25p64", INFO(0x1c2017, 0, 64 * 1024, 128, 0) },
+        { "en25q64", INFO(0x1c3017, 0, 64 * 1024, 128, SECT_4K) },
 
         /* Everspin */
         { "mr25h256", CAT25_INFO(  32 * 1024, 1, 256, 2) },
@@ -646,6 +649,7 @@ static const struct spi_device_id m25p_ids[] = {
         { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },
         { "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, 0) },
         { "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, 0) },
+        { "n25q064",  INFO(0x20ba17, 0, 64 * 1024, 128, 0) },
 
         /* Macronix */
         { "mx25l2005a",  INFO(0xc22012, 0, 64 * 1024,   4, SECT_4K) },
@@ -659,15 +663,15 @@ static const struct spi_device_id m25p_ids[] = {
         { "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, 0) },
         { "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
 
+        /* Micron */
+        { "n25q128",  INFO(0x20ba18, 0, 64 * 1024, 256, 0) },
+        { "n25q256a", INFO(0x20ba19, 0, 64 * 1024, 512, SECT_4K) },
+
         /* Spansion -- single (large) sector size only, at least
          * for the chips listed here (without boot sectors).
          */
-        { "s25sl004a",  INFO(0x010212,      0,  64 * 1024,   8, 0) },
-        { "s25sl008a",  INFO(0x010213,      0,  64 * 1024,  16, 0) },
-        { "s25sl016a",  INFO(0x010214,      0,  64 * 1024,  32, 0) },
-        { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
-        { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, SECT_4K) },
-        { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
+        { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, 0) },
+        { "s25sl064p",  INFO(0x010216, 0x4d00,  64 * 1024, 128, 0) },
         { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, 0) },
         { "s25fl256s1", INFO(0x010219, 0x4d01,  64 * 1024, 512, 0) },
         { "s25fl512s",  INFO(0x010220, 0x4d00, 256 * 1024, 256, 0) },
@@ -676,6 +680,11 @@ static const struct spi_device_id m25p_ids[] = {
         { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256, 0) },
         { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64, 0) },
         { "s25fl129p1", INFO(0x012018, 0x4d01,  64 * 1024, 256, 0) },
+        { "s25sl004a",  INFO(0x010212,      0,  64 * 1024,   8, 0) },
+        { "s25sl008a",  INFO(0x010213,      0,  64 * 1024,  16, 0) },
+        { "s25sl016a",  INFO(0x010214,      0,  64 * 1024,  32, 0) },
+        { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
+        { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
         { "s25fl016k",  INFO(0xef4015,      0,  64 * 1024,  32, SECT_4K) },
         { "s25fl064k",  INFO(0xef4017,      0,  64 * 1024, 128, SECT_4K) },
 
@@ -699,6 +708,7 @@ static const struct spi_device_id m25p_ids[] = {
         { "m25p32",  INFO(0x202016,  0,  64 * 1024,  64, 0) },
         { "m25p64",  INFO(0x202017,  0,  64 * 1024, 128, 0) },
         { "m25p128", INFO(0x202018,  0, 256 * 1024,  64, 0) },
+        { "n25q032", INFO(0x20ba16,  0,  64 * 1024,  64, 0) },
 
         { "m25p05-nonjedec",  INFO(0, 0,  32 * 1024,   2, 0) },
         { "m25p10-nonjedec",  INFO(0, 0,  32 * 1024,   4, 0) },
@@ -714,6 +724,7 @@ static const struct spi_device_id m25p_ids[] = {
         { "m45pe80", INFO(0x204014,  0, 64 * 1024,   16, 0) },
         { "m45pe16", INFO(0x204015,  0, 64 * 1024,   32, 0) },
 
+        { "m25pe20", INFO(0x208012,  0, 64 * 1024,  4,       0) },
         { "m25pe80", INFO(0x208014,  0, 64 * 1024, 16,       0) },
         { "m25pe16", INFO(0x208015,  0, 64 * 1024, 32, SECT_4K) },
 
@@ -730,6 +741,7 @@ static const struct spi_device_id m25p_ids[] = {
         { "w25x16", INFO(0xef3015, 0, 64 * 1024,  32, SECT_4K) },
         { "w25x32", INFO(0xef3016, 0, 64 * 1024,  64, SECT_4K) },
         { "w25q32", INFO(0xef4016, 0, 64 * 1024,  64, SECT_4K) },
+        { "w25q32dw", INFO(0xef6016, 0, 64 * 1024,  64, SECT_4K) },
         { "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
         { "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
         { "w25q80", INFO(0xef5014, 0, 64 * 1024,  16, SECT_4K) },
diff --git a/drivers/mtd/devices/spear_smi.c b/drivers/mtd/devices/spear_smi.c
index 67960362681e..dcc3c9511530 100644
--- a/drivers/mtd/devices/spear_smi.c
+++ b/drivers/mtd/devices/spear_smi.c
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/param.h>
 #include <linux/platform_device.h>
+#include <linux/pm.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/spear_smi.h>
@@ -240,8 +241,8 @@ static int spear_smi_read_sr(struct spear_smi *dev, u32 bank)
         /* copy dev->status (lower 16 bits) in order to release lock */
         if (ret > 0)
                 ret = dev->status & 0xffff;
-        else
-                ret = -EIO;
+        else if (ret == 0)
+                ret = -ETIMEDOUT;
 
         /* restore the ctrl regs state */
         writel(ctrlreg1, dev->io_base + SMI_CR1);
@@ -269,16 +270,19 @@ static int spear_smi_wait_till_ready(struct spear_smi *dev, u32 bank,
         finish = jiffies + timeout;
         do {
                 status = spear_smi_read_sr(dev, bank);
-                if (status < 0)
-                        continue; /* try till timeout */
-                else if (!(status & SR_WIP))
+                if (status < 0) {
+                        if (status == -ETIMEDOUT)
+                                continue; /* try till finish */
+                        return status;
+                } else if (!(status & SR_WIP)) {
                         return 0;
+                }
 
                 cond_resched();
         } while (!time_after_eq(jiffies, finish));
 
         dev_err(&dev->pdev->dev, "smi controller is busy, timeout\n");
-        return status;
+        return -EBUSY;
 }
 
 /**
@@ -335,6 +339,9 @@ static void spear_smi_hw_init(struct spear_smi *dev)
         val = HOLD1 | BANK_EN | DSEL_TIME | (prescale << 8);
 
         mutex_lock(&dev->lock);
+        /* clear all interrupt conditions */
+        writel(0, dev->io_base + SMI_SR);
+
         writel(val, dev->io_base + SMI_CR1);
         mutex_unlock(&dev->lock);
 }
@@ -391,11 +398,11 @@ static int spear_smi_write_enable(struct spear_smi *dev, u32 bank)
         writel(ctrlreg1, dev->io_base + SMI_CR1);
         writel(0, dev->io_base + SMI_CR2);
 
-        if (ret <= 0) {
+        if (ret == 0) {
                 ret = -EIO;
                 dev_err(&dev->pdev->dev,
                         "smi controller failed on write enable\n");
-        } else {
+        } else if (ret > 0) {
                 /* check whether write mode status is set for required bank */
                 if (dev->status & (1 << (bank + WM_SHIFT)))
                         ret = 0;
@@ -462,10 +469,10 @@ static int spear_smi_erase_sector(struct spear_smi *dev,
         ret = wait_event_interruptible_timeout(dev->cmd_complete,
                         dev->status & TFF, SMI_CMD_TIMEOUT);
 
-        if (ret <= 0) {
+        if (ret == 0) {
                 ret = -EIO;
                 dev_err(&dev->pdev->dev, "sector erase failed\n");
-        } else
+        } else if (ret > 0)
                 ret = 0; /* success */
 
         /* restore ctrl regs */
@@ -820,7 +827,7 @@ static int spear_smi_setup_banks(struct platform_device *pdev,
         if (!flash_info)
                 return -ENODEV;
 
-        flash = kzalloc(sizeof(*flash), GFP_ATOMIC);
+        flash = devm_kzalloc(&pdev->dev, sizeof(*flash), GFP_ATOMIC);
         if (!flash)
                 return -ENOMEM;
         flash->bank = bank;
@@ -831,15 +838,13 @@ static int spear_smi_setup_banks(struct platform_device *pdev,
         flash_index = spear_smi_probe_flash(dev, bank);
         if (flash_index < 0) {
                 dev_info(&dev->pdev->dev, "smi-nor%d not found\n", bank);
-                ret = flash_index;
-                goto err_probe;
+                return flash_index;
         }
         /* map the memory for nor flash chip */
-        flash->base_addr = ioremap(flash_info->mem_base, flash_info->size);
-        if (!flash->base_addr) {
-                ret = -EIO;
-                goto err_probe;
-        }
+        flash->base_addr = devm_ioremap(&pdev->dev, flash_info->mem_base,
+                                        flash_info->size);
+        if (!flash->base_addr)
+                return -EIO;
 
         dev->flash[bank] = flash;
         flash->mtd.priv = dev;
@@ -881,17 +886,10 @@ static int spear_smi_setup_banks(struct platform_device *pdev,
                                         count);
         if (ret) {
                 dev_err(&dev->pdev->dev, "Err MTD partition=%d\n", ret);
-                goto err_map;
+                return ret;
         }
 
         return 0;
-
-err_map:
-        iounmap(flash->base_addr);
-
-err_probe:
-        kfree(flash);
-        return ret;
 }
 
 /**
@@ -928,20 +926,13 @@ static int __devinit spear_smi_probe(struct platform_device *pdev)
                 }
         } else {
                 pdata = dev_get_platdata(&pdev->dev);
-                if (pdata < 0) {
+                if (!pdata) {
                         ret = -ENODEV;
                         dev_err(&pdev->dev, "no platform data\n");
                         goto err;
                 }
         }
 
-        smi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!smi_base) {
-                ret = -ENODEV;
-                dev_err(&pdev->dev, "invalid smi base address\n");
-                goto err;
-        }
-
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
                 ret = -ENODEV;
@@ -949,32 +940,26 @@ static int __devinit spear_smi_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        dev = kzalloc(sizeof(*dev), GFP_ATOMIC);
+        dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_ATOMIC);
         if (!dev) {
                 ret = -ENOMEM;
                 dev_err(&pdev->dev, "mem alloc fail\n");
                 goto err;
         }
 
-        smi_base = request_mem_region(smi_base->start, resource_size(smi_base),
-                        pdev->name);
-        if (!smi_base) {
-                ret = -EBUSY;
-                dev_err(&pdev->dev, "request mem region fail\n");
-                goto err_mem;
-        }
+        smi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
-        dev->io_base = ioremap(smi_base->start, resource_size(smi_base));
+        dev->io_base = devm_request_and_ioremap(&pdev->dev, smi_base);
         if (!dev->io_base) {
                 ret = -EIO;
-                dev_err(&pdev->dev, "ioremap fail\n");
-                goto err_ioremap;
+                dev_err(&pdev->dev, "devm_request_and_ioremap fail\n");
+                goto err;
         }
 
         dev->pdev = pdev;
         dev->clk_rate = pdata->clk_rate;
 
-        if (dev->clk_rate < 0 || dev->clk_rate > SMI_MAX_CLOCK_FREQ)
+        if (dev->clk_rate > SMI_MAX_CLOCK_FREQ)
                 dev->clk_rate = SMI_MAX_CLOCK_FREQ;
 
         dev->num_flashes = pdata->num_flashes;
@@ -984,17 +969,18 @@ static int __devinit spear_smi_probe(struct platform_device *pdev)
                 dev->num_flashes = MAX_NUM_FLASH_CHIP;
         }
 
-        dev->clk = clk_get(&pdev->dev, NULL);
+        dev->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(dev->clk)) {
                 ret = PTR_ERR(dev->clk);
-                goto err_clk;
+                goto err;
         }
 
         ret = clk_prepare_enable(dev->clk);
         if (ret)
-                goto err_clk_prepare_enable;
+                goto err;
 
-        ret = request_irq(irq, spear_smi_int_handler, 0, pdev->name, dev);
+        ret = devm_request_irq(&pdev->dev, irq, spear_smi_int_handler, 0,
+                               pdev->name, dev);
         if (ret) {
                 dev_err(&dev->pdev->dev, "SMI IRQ allocation failed\n");
                 goto err_irq;
@@ -1017,18 +1003,9 @@ static int __devinit spear_smi_probe(struct platform_device *pdev)
         return 0;
 
 err_bank_setup:
-        free_irq(irq, dev);
         platform_set_drvdata(pdev, NULL);
 err_irq:
         clk_disable_unprepare(dev->clk);
-err_clk_prepare_enable:
-        clk_put(dev->clk);
-err_clk:
-        iounmap(dev->io_base);
-err_ioremap:
-        release_mem_region(smi_base->start, resource_size(smi_base));
-err_mem:
-        kfree(dev);
 err:
         return ret;
 }
@@ -1042,11 +1019,8 @@ err:
 static int __devexit spear_smi_remove(struct platform_device *pdev)
 {
         struct spear_smi *dev;
-        struct spear_smi_plat_data *pdata;
         struct spear_snor_flash *flash;
-        struct resource *smi_base;
-        int ret;
-        int i, irq;
+        int ret, i;
 
         dev = platform_get_drvdata(pdev);
         if (!dev) {
@@ -1054,8 +1028,6 @@ static int __devexit spear_smi_remove(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        pdata = dev_get_platdata(&pdev->dev);
-
         /* clean up for all nor flash */
         for (i = 0; i < dev->num_flashes; i++) {
                 flash = dev->flash[i];
@@ -1066,49 +1038,41 @@ static int __devexit spear_smi_remove(struct platform_device *pdev)
                 ret = mtd_device_unregister(&flash->mtd);
                 if (ret)
                         dev_err(&pdev->dev, "error removing mtd\n");
-
-                iounmap(flash->base_addr);
-                kfree(flash);
         }
 
-        irq = platform_get_irq(pdev, 0);
-        free_irq(irq, dev);
-
         clk_disable_unprepare(dev->clk);
-        clk_put(dev->clk);
-        iounmap(dev->io_base);
-        kfree(dev);
-
-        smi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(smi_base->start, resource_size(smi_base));
         platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
-int spear_smi_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM
+static int spear_smi_suspend(struct device *dev)
 {
-        struct spear_smi *dev = platform_get_drvdata(pdev);
+        struct spear_smi *sdev = dev_get_drvdata(dev);
 
-        if (dev && dev->clk)
-                clk_disable_unprepare(dev->clk);
+        if (sdev && sdev->clk)
+                clk_disable_unprepare(sdev->clk);
 
         return 0;
 }
 
-int spear_smi_resume(struct platform_device *pdev)
+static int spear_smi_resume(struct device *dev)
 {
-        struct spear_smi *dev = platform_get_drvdata(pdev);
+        struct spear_smi *sdev = dev_get_drvdata(dev);
         int ret = -EPERM;
 
-        if (dev && dev->clk)
-                ret = clk_prepare_enable(dev->clk);
+        if (sdev && sdev->clk)
+                ret = clk_prepare_enable(sdev->clk);
 
         if (!ret)
-                spear_smi_hw_init(dev);
+                spear_smi_hw_init(sdev);
         return ret;
 }
 
+static SIMPLE_DEV_PM_OPS(spear_smi_pm_ops, spear_smi_suspend, spear_smi_resume);
+#endif
+
 #ifdef CONFIG_OF
 static const struct of_device_id spear_smi_id_table[] = {
         { .compatible = "st,spear600-smi" },
@@ -1123,11 +1087,12 @@ static struct platform_driver spear_smi_driver = {
                 .bus = &platform_bus_type,
                 .owner = THIS_MODULE,
                 .of_match_table = of_match_ptr(spear_smi_id_table),
+#ifdef CONFIG_PM
+                .pm = &spear_smi_pm_ops,
+#endif
         },
         .probe = spear_smi_probe,
         .remove = __devexit_p(spear_smi_remove),
-        .suspend = spear_smi_suspend,
-        .resume = spear_smi_resume,
 };
 
 static int spear_smi_init(void)
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 5ba2458e799a..2e47c2ed0a2d 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -373,7 +373,7 @@ config MTD_FORTUNET
           have such a board, say 'Y'.
 
 config MTD_AUTCPU12
-        tristate "NV-RAM mapping AUTCPU12 board"
+        bool "NV-RAM mapping AUTCPU12 board"
         depends on ARCH_AUTCPU12
         help
           This enables access to the NV-RAM on autronix autcpu12 board.
@@ -443,22 +443,10 @@ config MTD_GPIO_ADDR
 
 config MTD_UCLINUX
         bool "Generic uClinux RAM/ROM filesystem support"
-        depends on MTD_RAM=y && !MMU
+        depends on MTD_RAM=y && (!MMU || COLDFIRE)
         help
           Map driver to support image based filesystems for uClinux.
 
-config MTD_WRSBC8260
-        tristate "Map driver for WindRiver PowerQUICC II MPC82xx board"
-        depends on (SBC82xx || SBC8560)
-        select MTD_MAP_BANK_WIDTH_4
-        select MTD_MAP_BANK_WIDTH_1
-        select MTD_CFI_I1
-        select MTD_CFI_I4
-        help
-          Map driver for WindRiver PowerQUICC II MPC82xx board. Drives
-          all three flash regions on CS0, CS1 and CS6 if they are configured
-          correctly by the boot loader.
-
 config MTD_DMV182
         tristate "Map driver for Dy-4 SVME/DMV-182 board."
         depends on DMV182
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile
index 68a9a91d344f..deb43e9a1e7f 100644
--- a/drivers/mtd/maps/Makefile
+++ b/drivers/mtd/maps/Makefile
@@ -47,7 +47,6 @@ obj-$(CONFIG_MTD_SCB2_FLASH)	+= scb2_flash.o
 obj-$(CONFIG_MTD_H720X)         += h720x-flash.o
 obj-$(CONFIG_MTD_IXP4XX)        += ixp4xx.o
 obj-$(CONFIG_MTD_IXP2000)       += ixp2000.o
-obj-$(CONFIG_MTD_WRSBC8260)     += wr_sbc82xx_flash.o
 obj-$(CONFIG_MTD_DMV182)        += dmv182.o
 obj-$(CONFIG_MTD_PLATRAM)       += plat-ram.o
 obj-$(CONFIG_MTD_INTEL_VR_NOR)  += intel_vr_nor.o
diff --git a/drivers/mtd/maps/autcpu12-nvram.c b/drivers/mtd/maps/autcpu12-nvram.c
index e5bfd0e093bb..76fb594bb1d9 100644
--- a/drivers/mtd/maps/autcpu12-nvram.c
+++ b/drivers/mtd/maps/autcpu12-nvram.c
@@ -15,43 +15,54 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
  */
+#include <linux/sizes.h>
 
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/ioport.h>
 #include <linux/init.h>
-#include <asm/io.h>
-#include <asm/sizes.h>
-#include <mach/hardware.h>
-#include <mach/autcpu12.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-
-static struct mtd_info *sram_mtd;
 
-struct map_info autcpu12_sram_map = {
-        .name = "SRAM",
-        .size = 32768,
-        .bankwidth = 4,
-        .phys = 0x12000000,
+struct autcpu12_nvram_priv {
+        struct mtd_info *mtd;
+        struct map_info map;
 };
 
-static int __init init_autcpu12_sram (void)
+static int __devinit autcpu12_nvram_probe(struct platform_device *pdev)
 {
-        int err, save0, save1;
+        map_word tmp, save0, save1;
+        struct resource *res;
+        struct autcpu12_nvram_priv *priv;
 
-        autcpu12_sram_map.virt = ioremap(0x12000000, SZ_128K);
-        if (!autcpu12_sram_map.virt) {
-                printk("Failed to ioremap autcpu12 NV-RAM space\n");
-                err = -EIO;
-                goto out;
+        priv = devm_kzalloc(&pdev->dev,
+                            sizeof(struct autcpu12_nvram_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, priv);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get memory resource\n");
+                return -ENOENT;
+        }
+
+        priv->map.bankwidth     = 4;
+        priv->map.phys          = res->start;
+        priv->map.size          = resource_size(res);
+        priv->map.virt          = devm_request_and_ioremap(&pdev->dev, res);
+        strcpy((char *)priv->map.name, res->name);
+        if (!priv->map.virt) {
+                dev_err(&pdev->dev, "failed to remap mem resource\n");
+                return -EBUSY;
         }
-        simple_map_init(&autcpu_sram_map);
+
+        simple_map_init(&priv->map);
 
         /*
          * Check for 32K/128K
@@ -61,65 +72,59 @@ static int __init init_autcpu12_sram (void)
          * Read and check result on ofs 0x0
          * Restore contents
          */
-        save0 = map_read32(&autcpu12_sram_map,0);
-        save1 = map_read32(&autcpu12_sram_map,0x10000);
-        map_write32(&autcpu12_sram_map,~save0,0x10000);
-        /* if we find this pattern on 0x0, we have 32K size
-         * restore contents and exit
-         */
-        if ( map_read32(&autcpu12_sram_map,0) != save0) {
-                map_write32(&autcpu12_sram_map,save0,0x0);
-                goto map;
+        save0 = map_read(&priv->map, 0);
+        save1 = map_read(&priv->map, 0x10000);
+        tmp.x[0] = ~save0.x[0];
+        map_write(&priv->map, tmp, 0x10000);
+        tmp = map_read(&priv->map, 0);
+        /* if we find this pattern on 0x0, we have 32K size */
+        if (!map_word_equal(&priv->map, tmp, save0)) {
+                map_write(&priv->map, save0, 0x0);
+                priv->map.size = SZ_32K;
+        } else
+                map_write(&priv->map, save1, 0x10000);
+
+        priv->mtd = do_map_probe("map_ram", &priv->map);
+        if (!priv->mtd) {
+                dev_err(&pdev->dev, "probing failed\n");
+                return -ENXIO;
         }
-        /* We have a 128K found, restore 0x10000 and set size
-         * to 128K
-         */
-        map_write32(&autcpu12_sram_map,save1,0x10000);
-        autcpu12_sram_map.size = SZ_128K;
-
-map:
-        sram_mtd = do_map_probe("map_ram", &autcpu12_sram_map);
-        if (!sram_mtd) {
-                printk("NV-RAM probe failed\n");
-                err = -ENXIO;
-                goto out_ioremap;
-        }
-
-        sram_mtd->owner = THIS_MODULE;
-        sram_mtd->erasesize = 16;
 
-        if (mtd_device_register(sram_mtd, NULL, 0)) {
-                printk("NV-RAM device addition failed\n");
-                err = -ENOMEM;
-                goto out_probe;
+        priv->mtd->owner        = THIS_MODULE;
+        priv->mtd->erasesize    = 16;
+        priv->mtd->dev.parent   = &pdev->dev;
+        if (!mtd_device_register(priv->mtd, NULL, 0)) {
+                dev_info(&pdev->dev,
+                         "NV-RAM device size %ldKiB registered on AUTCPU12\n",
+                         priv->map.size / SZ_1K);
+                return 0;
         }
 
-        printk("NV-RAM device size %ldKiB registered on AUTCPU12\n",autcpu12_sram_map.size/SZ_1K);
-
-        return 0;
-
-out_probe:
-        map_destroy(sram_mtd);
-        sram_mtd = 0;
-
-out_ioremap:
-        iounmap((void *)autcpu12_sram_map.virt);
-out:
-        return err;
+        map_destroy(priv->mtd);
+        dev_err(&pdev->dev, "NV-RAM device addition failed\n");
+        return -ENOMEM;
 }
 
-static void __exit cleanup_autcpu12_maps(void)
+static int __devexit autcpu12_nvram_remove(struct platform_device *pdev)
 {
-        if (sram_mtd) {
-                mtd_device_unregister(sram_mtd);
-                map_destroy(sram_mtd);
-                iounmap((void *)autcpu12_sram_map.virt);
-        }
+        struct autcpu12_nvram_priv *priv = platform_get_drvdata(pdev);
+
+        mtd_device_unregister(priv->mtd);
+        map_destroy(priv->mtd);
+
+        return 0;
 }
 
-module_init(init_autcpu12_sram);
-module_exit(cleanup_autcpu12_maps);
+static struct platform_driver autcpu12_nvram_driver = {
+        .driver         = {
+                .name   = "autcpu12_nvram",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = autcpu12_nvram_probe,
+        .remove         = __devexit_p(autcpu12_nvram_remove),
+};
+module_platform_driver(autcpu12_nvram_driver);
 
 MODULE_AUTHOR("Thomas Gleixner");
-MODULE_DESCRIPTION("autcpu12 NV-RAM map driver");
+MODULE_DESCRIPTION("autcpu12 NVRAM map driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c
index f14ce0af763f..1c30c1a307f4 100644
--- a/drivers/mtd/maps/pci.c
+++ b/drivers/mtd/maps/pci.c
@@ -43,26 +43,14 @@ static map_word mtd_pci_read8(struct map_info *_map, unsigned long ofs)
         struct map_pci_info *map = (struct map_pci_info *)_map;
         map_word val;
         val.x[0]= readb(map->base + map->translate(map, ofs));
-//      printk("read8 : %08lx => %02x\n", ofs, val.x[0]);
         return val;
 }
 
-#if 0
-static map_word mtd_pci_read16(struct map_info *_map, unsigned long ofs)
-{
-        struct map_pci_info *map = (struct map_pci_info *)_map;
-        map_word val;
-        val.x[0] = readw(map->base + map->translate(map, ofs));
-//      printk("read16: %08lx => %04x\n", ofs, val.x[0]);
-        return val;
-}
-#endif
 static map_word mtd_pci_read32(struct map_info *_map, unsigned long ofs)
 {
         struct map_pci_info *map = (struct map_pci_info *)_map;
         map_word val;
         val.x[0] = readl(map->base + map->translate(map, ofs));
-//      printk("read32: %08lx => %08x\n", ofs, val.x[0]);
         return val;
 }
 
@@ -75,22 +63,12 @@ static void mtd_pci_copyfrom(struct map_info *_map, void *to, unsigned long from
 static void mtd_pci_write8(struct map_info *_map, map_word val, unsigned long ofs)
 {
         struct map_pci_info *map = (struct map_pci_info *)_map;
-//      printk("write8 : %08lx <= %02x\n", ofs, val.x[0]);
         writeb(val.x[0], map->base + map->translate(map, ofs));
 }
 
-#if 0
-static void mtd_pci_write16(struct map_info *_map, map_word val, unsigned long ofs)
-{
-        struct map_pci_info *map = (struct map_pci_info *)_map;
-//      printk("write16: %08lx <= %04x\n", ofs, val.x[0]);
-        writew(val.x[0], map->base + map->translate(map, ofs));
-}
-#endif
 static void mtd_pci_write32(struct map_info *_map, map_word val, unsigned long ofs)
 {
         struct map_pci_info *map = (struct map_pci_info *)_map;
-//      printk("write32: %08lx <= %08x\n", ofs, val.x[0]);
         writel(val.x[0], map->base + map->translate(map, ofs));
 }
 
@@ -358,4 +336,3 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 MODULE_DESCRIPTION("Generic PCI map driver");
 MODULE_DEVICE_TABLE(pci, mtd_pci_ids);
-
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index 2e6fb6831d55..6f19acadb06c 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -169,6 +169,7 @@ static int __devinit of_flash_probe(struct platform_device *dev)
         struct mtd_info **mtd_list = NULL;
         resource_size_t res_size;
         struct mtd_part_parser_data ppdata;
+        bool map_indirect;
 
         match = of_match_device(of_flash_match, &dev->dev);
         if (!match)
@@ -192,6 +193,8 @@ static int __devinit of_flash_probe(struct platform_device *dev)
         }
         count /= reg_tuple_size;
 
+        map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
+
         err = -ENOMEM;
         info = kzalloc(sizeof(struct of_flash) +
                        sizeof(struct of_flash_list) * count, GFP_KERNEL);
@@ -247,6 +250,17 @@ static int __devinit of_flash_probe(struct platform_device *dev)
 
                 simple_map_init(&info->list[i].map);
 
+                /*
+                 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
+                 * may cause problems with JFFS2 usage, as the local bus (LPB)
+                 * doesn't support unaligned accesses as implemented in the
+                 * JFFS2 code via memcpy(). By setting NO_XIP, the
+                 * flash will not be exposed directly to the MTD users
+                 * (e.g. JFFS2) any more.
+                 */
+                if (map_indirect)
+                        info->list[i].map.phys = NO_XIP;
+
                 if (probe_type) {
                         info->list[i].mtd = do_map_probe(probe_type,
                                                          &info->list[i].map);
diff --git a/drivers/mtd/maps/rbtx4939-flash.c b/drivers/mtd/maps/rbtx4939-flash.c
index 6f52e1f288b6..49c3fe715eee 100644
--- a/drivers/mtd/maps/rbtx4939-flash.c
+++ b/drivers/mtd/maps/rbtx4939-flash.c
@@ -100,8 +100,6 @@ static int rbtx4939_flash_probe(struct platform_device *dev)
                 goto err_out;
         }
         info->mtd->owner = THIS_MODULE;
-        if (err)
-                goto err_out;
         err = mtd_device_parse_register(info->mtd, NULL, NULL, pdata->parts,
                                         pdata->nr_parts);
 
diff --git a/drivers/mtd/maps/uclinux.c b/drivers/mtd/maps/uclinux.c
index c3bb304eca07..299bf88a6f41 100644
--- a/drivers/mtd/maps/uclinux.c
+++ b/drivers/mtd/maps/uclinux.c
@@ -67,10 +67,16 @@ static int __init uclinux_mtd_init(void)
         printk("uclinux[mtd]: RAM probe address=0x%x size=0x%x\n",
                 (int) mapp->phys, (int) mapp->size);
 
-        mapp->virt = ioremap_nocache(mapp->phys, mapp->size);
+        /*
+         * The filesystem is guaranteed to be in direct mapped memory. It is
+         * directly following the kernels own bss region. Following the same
+         * mechanism used by architectures setting up traditional initrds we
+         * use phys_to_virt to get the virtual address of its start.
+         */
+        mapp->virt = phys_to_virt(mapp->phys);
 
         if (mapp->virt == 0) {
-                printk("uclinux[mtd]: ioremap_nocache() failed\n");
+                printk("uclinux[mtd]: no virtual mapping?\n");
                 return(-EIO);
         }
 
@@ -79,7 +85,6 @@ static int __init uclinux_mtd_init(void)
         mtd = do_map_probe("map_ram", mapp);
         if (!mtd) {
                 printk("uclinux[mtd]: failed to find a mapping?\n");
-                iounmap(mapp->virt);
                 return(-ENXIO);
         }
 
@@ -102,10 +107,8 @@ static void __exit uclinux_mtd_cleanup(void)
                 map_destroy(uclinux_ram_mtdinfo);
                 uclinux_ram_mtdinfo = NULL;
         }
-        if (uclinux_ram_map.virt) {
-                iounmap((void *) uclinux_ram_map.virt);
+        if (uclinux_ram_map.virt)
                 uclinux_ram_map.virt = 0;
-        }
 }
 
 /****************************************************************************/
diff --git a/drivers/mtd/maps/wr_sbc82xx_flash.c b/drivers/mtd/maps/wr_sbc82xx_flash.c
deleted file mode 100644
index e7534c82f93a..000000000000
--- a/drivers/mtd/maps/wr_sbc82xx_flash.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Map for flash chips on Wind River PowerQUICC II SBC82xx board.
- *
- * Copyright (C) 2004 Red Hat, Inc.
- *
- * Author: David Woodhouse <dwmw2@infradead.org>
- *
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <asm/io.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#include <asm/immap_cpm2.h>
-
-static struct mtd_info *sbcmtd[3];
-
-struct map_info sbc82xx_flash_map[3] = {
-        {.name = "Boot flash"},
-        {.name = "Alternate boot flash"},
-        {.name = "User flash"}
-};
-
-static struct mtd_partition smallflash_parts[] = {
-        {
-                .name =         "space",
-                .size =         0x100000,
-                .offset =       0,
-        }, {
-                .name =         "bootloader",
-                .size =         MTDPART_SIZ_FULL,
-                .offset =       MTDPART_OFS_APPEND,
-        }
-};
-
-static struct mtd_partition bigflash_parts[] = {
-        {
-                .name =         "bootloader",
-                .size =         0x00100000,
-                .offset =       0,
-        }, {
-                .name =         "file system",
-                .size =         0x01f00000,
-                .offset =       MTDPART_OFS_APPEND,
-        }, {
-                .name =         "boot config",
-                .size =         0x00100000,
-                .offset =       MTDPART_OFS_APPEND,
-        }, {
-                .name =         "space",
-                .size =         0x01f00000,
-                .offset =       MTDPART_OFS_APPEND,
-        }
-};
-
-static const char *part_probes[] __initconst = {"cmdlinepart", "RedBoot", NULL};
-
-#define init_sbc82xx_one_flash(map, br, or)                     \
-do {                                                            \
-        (map).phys = (br & 1) ? (br & 0xffff8000) : 0;          \
-        (map).size = (br & 1) ? (~(or & 0xffff8000) + 1) : 0;   \
-        switch (br & 0x00001800) {                              \
-        case 0x00000000:                                        \
-        case 0x00000800:        (map).bankwidth = 1;    break;  \
-        case 0x00001000:        (map).bankwidth = 2;    break;  \
-        case 0x00001800:        (map).bankwidth = 4;    break;  \
-        }                                                       \
-} while (0);
-
-static int __init init_sbc82xx_flash(void)
-{
-        volatile memctl_cpm2_t *mc = &cpm2_immr->im_memctl;
-        int bigflash;
-        int i;
-
-#ifdef CONFIG_SBC8560
-        mc = ioremap(0xff700000 + 0x5000, sizeof(memctl_cpm2_t));
-#else
-        mc = &cpm2_immr->im_memctl;
-#endif
-
-        bigflash = 1;
-        if ((mc->memc_br0 & 0x00001800) == 0x00001800)
-                bigflash = 0;
-
-        init_sbc82xx_one_flash(sbc82xx_flash_map[0], mc->memc_br0, mc->memc_or0);
-        init_sbc82xx_one_flash(sbc82xx_flash_map[1], mc->memc_br6, mc->memc_or6);
-        init_sbc82xx_one_flash(sbc82xx_flash_map[2], mc->memc_br1, mc->memc_or1);
-
-#ifdef CONFIG_SBC8560
-        iounmap((void *) mc);
-#endif
-
-        for (i=0; i<3; i++) {
-                int8_t flashcs[3] = { 0, 6, 1 };
-                int nr_parts;
-                struct mtd_partition *defparts;
-
-                printk(KERN_NOTICE "PowerQUICC II %s (%ld MiB on CS%d",
-                       sbc82xx_flash_map[i].name,
-                       (sbc82xx_flash_map[i].size >> 20),
-                       flashcs[i]);
-                if (!sbc82xx_flash_map[i].phys) {
-                        /* We know it can't be at zero. */
-                        printk("): disabled by bootloader.\n");
-                        continue;
-                }
-                printk(" at %08lx)\n",  sbc82xx_flash_map[i].phys);
-
-                sbc82xx_flash_map[i].virt = ioremap(sbc82xx_flash_map[i].phys,
-                                                    sbc82xx_flash_map[i].size);
-
-                if (!sbc82xx_flash_map[i].virt) {
-                        printk("Failed to ioremap\n");
-                        continue;
-                }
-
-                simple_map_init(&sbc82xx_flash_map[i]);
-
-                sbcmtd[i] = do_map_probe("cfi_probe", &sbc82xx_flash_map[i]);
-
-                if (!sbcmtd[i])
-                        continue;
-
-                sbcmtd[i]->owner = THIS_MODULE;
-
-                /* No partitioning detected. Use default */
-                if (i == 2) {
-                        defparts = NULL;
-                        nr_parts = 0;
-                } else if (i == bigflash) {
-                        defparts = bigflash_parts;
-                        nr_parts = ARRAY_SIZE(bigflash_parts);
-                } else {
-                        defparts = smallflash_parts;
-                        nr_parts = ARRAY_SIZE(smallflash_parts);
-                }
-
-                mtd_device_parse_register(sbcmtd[i], part_probes, NULL,
-                                          defparts, nr_parts);
-        }
-        return 0;
-}
-
-static void __exit cleanup_sbc82xx_flash(void)
-{
-        int i;
-
-        for (i=0; i<3; i++) {
-                if (!sbcmtd[i])
-                        continue;
-
-                mtd_device_unregister(sbcmtd[i]);
-
-                map_destroy(sbcmtd[i]);
-
-                iounmap((void *)sbc82xx_flash_map[i].virt);
-                sbc82xx_flash_map[i].virt = 0;
-        }
-}
-
-module_init(init_sbc82xx_flash);
-module_exit(cleanup_sbc82xx_flash);
-
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
-MODULE_DESCRIPTION("Flash map driver for WindRiver PowerQUICC II");
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 73ae81a629f2..82c06165d3d2 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -1162,7 +1162,11 @@ static int mtdchar_mmap(struct file *file, struct vm_area_struct *vma)
         resource_size_t start, off;
         unsigned long len, vma_len;
 
-        if (mtd->type == MTD_RAM || mtd->type == MTD_ROM) {
+        /* This is broken because it assumes the MTD device is map-based
+           and that mtd->priv is a valid struct map_info.  It should be
+           replaced with something that uses the mtd_get_unmapped_area()
+           operation properly. */
+        if (0 /*mtd->type == MTD_RAM || mtd->type == MTD_ROM*/) {
                 off = get_vm_offset(vma);
                 start = map->phys;
                 len = PAGE_ALIGN((start & ~PAGE_MASK) + map->size);
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index b9adff543f5f..374c46dff7dd 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -858,6 +858,27 @@ int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
 }
 EXPORT_SYMBOL_GPL(mtd_panic_write);
 
+int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
+{
+        int ret_code;
+        ops->retlen = ops->oobretlen = 0;
+        if (!mtd->_read_oob)
+                return -EOPNOTSUPP;
+        /*
+         * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
+         * similar to mtd->_read(), returning a non-negative integer
+         * representing max bitflips. In other cases, mtd->_read_oob() may
+         * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
+         */
+        ret_code = mtd->_read_oob(mtd, from, ops);
+        if (unlikely(ret_code < 0))
+                return ret_code;
+        if (mtd->ecc_strength == 0)
+                return 0;       /* device lacks ecc */
+        return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
+}
+EXPORT_SYMBOL_GPL(mtd_read_oob);
+
 /*
  * Method to access the protection register area, present in some flash
  * devices. The user data is one time programmable but the factory data is read
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index 438737a1f59a..f5b3f91fa1cc 100644
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -169,14 +169,7 @@ static void mtdoops_workfunc_erase(struct work_struct *work)
                         cxt->nextpage = 0;
         }
 
-        while (1) {
-                ret = mtd_block_isbad(mtd, cxt->nextpage * record_size);
-                if (!ret)
-                        break;
-                if (ret < 0) {
-                        printk(KERN_ERR "mtdoops: block_isbad failed, aborting\n");
-                        return;
-                }
+        while ((ret = mtd_block_isbad(mtd, cxt->nextpage * record_size)) > 0) {
 badblock:
                 printk(KERN_WARNING "mtdoops: bad block at %08lx\n",
                        cxt->nextpage * record_size);
@@ -190,6 +183,11 @@ badblock:
                 }
         }
 
+        if (ret < 0) {
+                printk(KERN_ERR "mtdoops: mtd_block_isbad failed, aborting\n");
+                return;
+        }
+
         for (j = 0, ret = -1; (j < 3) && (ret < 0); j++)
                 ret = mtdoops_erase_block(cxt, cxt->nextpage * record_size);
 
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 3a49e6de5e60..70fa70a8318f 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -711,6 +711,8 @@ static const char *default_mtd_part_types[] = {
  * partition parsers, specified in @types. However, if @types is %NULL, then
  * the default list of parsers is used. The default list contains only the
  * "cmdlinepart" and "ofpart" parsers ATM.
+ * Note: If there are more then one parser in @types, the kernel only takes the
+ * partitions parsed out by the first parser.
  *
  * This function may return:
  * o a negative error code in case of failure
@@ -735,11 +737,12 @@ int parse_mtd_partitions(struct mtd_info *master, const char **types,
                 if (!parser)
                         continue;
                 ret = (*parser->parse_fn)(master, pparts, data);
+                put_partition_parser(parser);
                 if (ret > 0) {
                         printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
                                ret, parser->name, master->name);
+                        break;
                 }
-                put_partition_parser(parser);
         }
         return ret;
 }
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 598cd0a3adee..4883139460be 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -22,15 +22,6 @@ menuconfig MTD_NAND
 
 if MTD_NAND
 
-config MTD_NAND_VERIFY_WRITE
-        bool "Verify NAND page writes"
-        help
-          This adds an extra check when data is written to the flash. The
-          NAND flash device internally checks only bits transitioning
-          from 1 to 0. There is a rare possibility that even though the
-          device thinks the write was successful, a bit could have been
-          flipped accidentally due to device wear or something else.
-
 config MTD_NAND_BCH
         tristate
         select BCH
@@ -267,22 +258,6 @@ config MTD_NAND_S3C2410_CLKSTOP
           when the is NAND chip selected or released, but will save
           approximately 5mA of power when there is nothing happening.
 
-config MTD_NAND_BCM_UMI
-        tristate "NAND Flash support for BCM Reference Boards"
-        depends on ARCH_BCMRING
-        help
-          This enables the NAND flash controller on the BCM UMI block.
-
-          No board specific support is done by this driver, each board
-          must advertise a platform_device for the driver to attach.
-
-config MTD_NAND_BCM_UMI_HWCS
-        bool "BCM UMI NAND Hardware CS"
-        depends on MTD_NAND_BCM_UMI
-        help
-          Enable the use of the BCM UMI block's internal CS using NAND.
-          This should only be used if you know the external NAND CS can toggle.
-
 config MTD_NAND_DISKONCHIP
         tristate "DiskOnChip 2000, Millennium and Millennium Plus (NAND reimplementation) (EXPERIMENTAL)"
         depends on EXPERIMENTAL
@@ -356,7 +331,7 @@ config MTD_NAND_DISKONCHIP_BBTWRITE
 
 config MTD_NAND_DOCG4
         tristate "Support for DiskOnChip G4 (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        depends on EXPERIMENTAL && HAS_IOMEM
         select BCH
         select BITREVERSE
         help
@@ -414,6 +389,28 @@ config MTD_NAND_PXA3xx
           This enables the driver for the NAND flash device found on
           PXA3xx processors
 
+config MTD_NAND_SLC_LPC32XX
+        tristate "NXP LPC32xx SLC Controller"
+        depends on ARCH_LPC32XX
+        help
+          Enables support for NXP's LPC32XX SLC (i.e. for Single Level Cell
+          chips) NAND controller. This is the default for the PHYTEC 3250
+          reference board which contains a NAND256R3A2CZA6 chip.
+
+          Please check the actual NAND chip connected and its support
+          by the SLC NAND controller.
+
+config MTD_NAND_MLC_LPC32XX
+        tristate "NXP LPC32xx MLC Controller"
+        depends on ARCH_LPC32XX
+        help
+          Uses the LPC32XX MLC (i.e. for Multi Level Cell chips) NAND
+          controller. This is the default for the WORK92105 controller
+          board.
+
+          Please check the actual NAND chip connected and its support
+          by the MLC NAND controller.
+
 config MTD_NAND_CM_X270
         tristate "Support for NAND Flash on CM-X270 modules"
         depends on MACH_ARMCORE
@@ -439,10 +436,10 @@ config MTD_NAND_NANDSIM
           MTD nand layer.
 
 config MTD_NAND_GPMI_NAND
-        bool "GPMI NAND Flash Controller driver"
+        tristate "GPMI NAND Flash Controller driver"
         depends on MTD_NAND && MXS_DMA
         help
-         Enables NAND Flash support for IMX23 or IMX28.
+         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
@@ -510,7 +507,7 @@ config MTD_NAND_MPC5121_NFC
 
 config MTD_NAND_MXC
         tristate "MXC NAND support"
-        depends on IMX_HAVE_PLATFORM_MXC_NAND
+        depends on ARCH_MXC
         help
           This enables the driver for the NAND flash controller on the
           MXC processors.
@@ -567,4 +564,12 @@ config MTD_NAND_FSMC
           Enables support for NAND Flash chips on the ST Microelectronics
           Flexible Static Memory Controller (FSMC)
 
+config MTD_NAND_XWAY
+        tristate "Support for NAND on Lantiq XWAY SoC"
+        depends on LANTIQ && SOC_TYPE_XWAY
+        select MTD_NAND_PLATFORM
+        help
+          Enables support for NAND Flash chips on Lantiq XWAY SoCs. NAND is attached
+          to the External Bus Unit (EBU).
+
 endif # MTD_NAND
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index d4b4d8739bd8..2cbd0916b733 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -40,16 +40,18 @@ obj-$(CONFIG_MTD_NAND_ORION)		+= orion_nand.o
 obj-$(CONFIG_MTD_NAND_FSL_ELBC)         += fsl_elbc_nand.o
 obj-$(CONFIG_MTD_NAND_FSL_IFC)          += fsl_ifc_nand.o
 obj-$(CONFIG_MTD_NAND_FSL_UPM)          += fsl_upm.o
+obj-$(CONFIG_MTD_NAND_SLC_LPC32XX)      += lpc32xx_slc.o
+obj-$(CONFIG_MTD_NAND_MLC_LPC32XX)      += lpc32xx_mlc.o
 obj-$(CONFIG_MTD_NAND_SH_FLCTL)         += sh_flctl.o
 obj-$(CONFIG_MTD_NAND_MXC)              += mxc_nand.o
 obj-$(CONFIG_MTD_NAND_SOCRATES)         += socrates_nand.o
 obj-$(CONFIG_MTD_NAND_TXX9NDFMC)        += txx9ndfmc.o
 obj-$(CONFIG_MTD_NAND_NUC900)           += nuc900_nand.o
 obj-$(CONFIG_MTD_NAND_NOMADIK)          += nomadik_nand.o
-obj-$(CONFIG_MTD_NAND_BCM_UMI)          += bcm_umi_nand.o nand_bcm_umi.o
 obj-$(CONFIG_MTD_NAND_MPC5121_NFC)      += mpc5121_nfc.o
 obj-$(CONFIG_MTD_NAND_RICOH)            += r852.o
 obj-$(CONFIG_MTD_NAND_JZ4740)           += jz4740_nand.o
 obj-$(CONFIG_MTD_NAND_GPMI_NAND)        += gpmi-nand/
+obj-$(CONFIG_MTD_NAND_XWAY)             += xway_nand.o
 
 nand-objs := nand_base.o nand_bbt.o
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index a7040af08536..9e7723aa7acc 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -107,18 +107,6 @@ static void ams_delta_read_buf(struct mtd_info *mtd, u_char *buf, int len)
                 buf[i] = ams_delta_read_byte(mtd);
 }
 
-static int ams_delta_verify_buf(struct mtd_info *mtd, const u_char *buf,
-                                int len)
-{
-        int i;
-
-        for (i=0; i<len; i++)
-                if (buf[i] != ams_delta_read_byte(mtd))
-                        return -EFAULT;
-
-        return 0;
-}
-
 /*
  * Command control function
  *
@@ -237,7 +225,6 @@ static int __devinit ams_delta_init(struct platform_device *pdev)
         this->read_byte = ams_delta_read_byte;
         this->write_buf = ams_delta_write_buf;
         this->read_buf = ams_delta_read_buf;
-        this->verify_buf = ams_delta_verify_buf;
         this->cmd_ctrl = ams_delta_hwcontrol;
         if (gpio_request(AMS_DELTA_GPIO_PIN_NAND_RB, "nand_rdy") == 0) {
                 this->dev_ready = ams_delta_nand_ready;
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index 97ac6712bb19..914455783302 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -1,20 +1,22 @@
 /*
- *  Copyright (C) 2003 Rick Bronson
+ *  Copyright © 2003 Rick Bronson
  *
  *  Derived from drivers/mtd/nand/autcpu12.c
- *       Copyright (c) 2001 Thomas Gleixner (gleixner@autronix.de)
+ *       Copyright © 2001 Thomas Gleixner (gleixner@autronix.de)
  *
  *  Derived from drivers/mtd/spia.c
- *       Copyright (C) 2000 Steven J. Hill (sjhill@cotw.com)
+ *       Copyright © 2000 Steven J. Hill (sjhill@cotw.com)
  *
  *
  *  Add Hardware ECC support for AT91SAM9260 / AT91SAM9263
- *     Richard Genoud (richard.genoud@gmail.com), Adeneo Copyright (C) 2007
+ *     Richard Genoud (richard.genoud@gmail.com), Adeneo Copyright © 2007
  *
  *     Derived from Das U-Boot source code
  *              (u-boot-1.1.5/board/atmel/at91sam9263ek/nand.c)
- *     (C) Copyright 2006 ATMEL Rousset, Lacressonniere Nicolas
+ *     © Copyright 2006 ATMEL Rousset, Lacressonniere Nicolas
  *
+ *  Add Programmable Multibit ECC support for various AT91 SoC
+ *     © Copyright 2012 ATMEL, Hong Xu
  *
  * 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
@@ -93,8 +95,36 @@ struct atmel_nand_host {
 
         struct completion       comp;
         struct dma_chan         *dma_chan;
+
+        bool                    has_pmecc;
+        u8                      pmecc_corr_cap;
+        u16                     pmecc_sector_size;
+        u32                     pmecc_lookup_table_offset;
+
+        int                     pmecc_bytes_per_sector;
+        int                     pmecc_sector_number;
+        int                     pmecc_degree;   /* Degree of remainders */
+        int                     pmecc_cw_len;   /* Length of codeword */
+
+        void __iomem            *pmerrloc_base;
+        void __iomem            *pmecc_rom_base;
+
+        /* lookup table for alpha_to and index_of */
+        void __iomem            *pmecc_alpha_to;
+        void __iomem            *pmecc_index_of;
+
+        /* data for pmecc computation */
+        int16_t                 *pmecc_partial_syn;
+        int16_t                 *pmecc_si;
+        int16_t                 *pmecc_smu;     /* Sigma table */
+        int16_t                 *pmecc_lmu;     /* polynomal order */
+        int                     *pmecc_mu;
+        int                     *pmecc_dmu;
+        int                     *pmecc_delta;
 };
 
+static struct nand_ecclayout atmel_pmecc_oobinfo;
+
 static int cpu_has_dma(void)
 {
         return cpu_is_at91sam9rl() || cpu_is_at91sam9g45();
@@ -288,6 +318,703 @@ static void atmel_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
 }
 
 /*
+ * Return number of ecc bytes per sector according to sector size and
+ * correction capability
+ *
+ * Following table shows what at91 PMECC supported:
+ * Correction Capability        Sector_512_bytes        Sector_1024_bytes
+ * =====================        ================        =================
+ *                2-bits                 4-bytes                  4-bytes
+ *                4-bits                 7-bytes                  7-bytes
+ *                8-bits                13-bytes                 14-bytes
+ *               12-bits                20-bytes                 21-bytes
+ *               24-bits                39-bytes                 42-bytes
+ */
+static int __devinit pmecc_get_ecc_bytes(int cap, int sector_size)
+{
+        int m = 12 + sector_size / 512;
+        return (m * cap + 7) / 8;
+}
+
+static void __devinit pmecc_config_ecc_layout(struct nand_ecclayout *layout,
+        int oobsize, int ecc_len)
+{
+        int i;
+
+        layout->eccbytes = ecc_len;
+
+        /* ECC will occupy the last ecc_len bytes continuously */
+        for (i = 0; i < ecc_len; i++)
+                layout->eccpos[i] = oobsize - ecc_len + i;
+
+        layout->oobfree[0].offset = 2;
+        layout->oobfree[0].length =
+                oobsize - ecc_len - layout->oobfree[0].offset;
+}
+
+static void __devinit __iomem *pmecc_get_alpha_to(struct atmel_nand_host *host)
+{
+        int table_size;
+
+        table_size = host->pmecc_sector_size == 512 ?
+                PMECC_LOOKUP_TABLE_SIZE_512 : PMECC_LOOKUP_TABLE_SIZE_1024;
+
+        return host->pmecc_rom_base + host->pmecc_lookup_table_offset +
+                        table_size * sizeof(int16_t);
+}
+
+static void pmecc_data_free(struct atmel_nand_host *host)
+{
+        kfree(host->pmecc_partial_syn);
+        kfree(host->pmecc_si);
+        kfree(host->pmecc_lmu);
+        kfree(host->pmecc_smu);
+        kfree(host->pmecc_mu);
+        kfree(host->pmecc_dmu);
+        kfree(host->pmecc_delta);
+}
+
+static int __devinit pmecc_data_alloc(struct atmel_nand_host *host)
+{
+        const int cap = host->pmecc_corr_cap;
+
+        host->pmecc_partial_syn = kzalloc((2 * cap + 1) * sizeof(int16_t),
+                                        GFP_KERNEL);
+        host->pmecc_si = kzalloc((2 * cap + 1) * sizeof(int16_t), GFP_KERNEL);
+        host->pmecc_lmu = kzalloc((cap + 1) * sizeof(int16_t), GFP_KERNEL);
+        host->pmecc_smu = kzalloc((cap + 2) * (2 * cap + 1) * sizeof(int16_t),
+                                        GFP_KERNEL);
+        host->pmecc_mu = kzalloc((cap + 1) * sizeof(int), GFP_KERNEL);
+        host->pmecc_dmu = kzalloc((cap + 1) * sizeof(int), GFP_KERNEL);
+        host->pmecc_delta = kzalloc((cap + 1) * sizeof(int), GFP_KERNEL);
+
+        if (host->pmecc_partial_syn &&
+                        host->pmecc_si &&
+                        host->pmecc_lmu &&
+                        host->pmecc_smu &&
+                        host->pmecc_mu &&
+                        host->pmecc_dmu &&
+                        host->pmecc_delta)
+                return 0;
+
+        /* error happened */
+        pmecc_data_free(host);
+        return -ENOMEM;
+}
+
+static void pmecc_gen_syndrome(struct mtd_info *mtd, int sector)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        int i;
+        uint32_t value;
+
+        /* Fill odd syndromes */
+        for (i = 0; i < host->pmecc_corr_cap; i++) {
+                value = pmecc_readl_rem_relaxed(host->ecc, sector, i / 2);
+                if (i & 1)
+                        value >>= 16;
+                value &= 0xffff;
+                host->pmecc_partial_syn[(2 * i) + 1] = (int16_t)value;
+        }
+}
+
+static void pmecc_substitute(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        int16_t __iomem *alpha_to = host->pmecc_alpha_to;
+        int16_t __iomem *index_of = host->pmecc_index_of;
+        int16_t *partial_syn = host->pmecc_partial_syn;
+        const int cap = host->pmecc_corr_cap;
+        int16_t *si;
+        int i, j;
+
+        /* si[] is a table that holds the current syndrome value,
+         * an element of that table belongs to the field
+         */
+        si = host->pmecc_si;
+
+        memset(&si[1], 0, sizeof(int16_t) * (2 * cap - 1));
+
+        /* Computation 2t syndromes based on S(x) */
+        /* Odd syndromes */
+        for (i = 1; i < 2 * cap; i += 2) {
+                for (j = 0; j < host->pmecc_degree; j++) {
+                        if (partial_syn[i] & ((unsigned short)0x1 << j))
+                                si[i] = readw_relaxed(alpha_to + i * j) ^ si[i];
+                }
+        }
+        /* Even syndrome = (Odd syndrome) ** 2 */
+        for (i = 2, j = 1; j <= cap; i = ++j << 1) {
+                if (si[j] == 0) {
+                        si[i] = 0;
+                } else {
+                        int16_t tmp;
+
+                        tmp = readw_relaxed(index_of + si[j]);
+                        tmp = (tmp * 2) % host->pmecc_cw_len;
+                        si[i] = readw_relaxed(alpha_to + tmp);
+                }
+        }
+
+        return;
+}
+
+static void pmecc_get_sigma(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+
+        int16_t *lmu = host->pmecc_lmu;
+        int16_t *si = host->pmecc_si;
+        int *mu = host->pmecc_mu;
+        int *dmu = host->pmecc_dmu;     /* Discrepancy */
+        int *delta = host->pmecc_delta; /* Delta order */
+        int cw_len = host->pmecc_cw_len;
+        const int16_t cap = host->pmecc_corr_cap;
+        const int num = 2 * cap + 1;
+        int16_t __iomem *index_of = host->pmecc_index_of;
+        int16_t __iomem *alpha_to = host->pmecc_alpha_to;
+        int i, j, k;
+        uint32_t dmu_0_count, tmp;
+        int16_t *smu = host->pmecc_smu;
+
+        /* index of largest delta */
+        int ro;
+        int largest;
+        int diff;
+
+        dmu_0_count = 0;
+
+        /* First Row */
+
+        /* Mu */
+        mu[0] = -1;
+
+        memset(smu, 0, sizeof(int16_t) * num);
+        smu[0] = 1;
+
+        /* discrepancy set to 1 */
+        dmu[0] = 1;
+        /* polynom order set to 0 */
+        lmu[0] = 0;
+        delta[0] = (mu[0] * 2 - lmu[0]) >> 1;
+
+        /* Second Row */
+
+        /* Mu */
+        mu[1] = 0;
+        /* Sigma(x) set to 1 */
+        memset(&smu[num], 0, sizeof(int16_t) * num);
+        smu[num] = 1;
+
+        /* discrepancy set to S1 */
+        dmu[1] = si[1];
+
+        /* polynom order set to 0 */
+        lmu[1] = 0;
+
+        delta[1] = (mu[1] * 2 - lmu[1]) >> 1;
+
+        /* Init the Sigma(x) last row */
+        memset(&smu[(cap + 1) * num], 0, sizeof(int16_t) * num);
+
+        for (i = 1; i <= cap; i++) {
+                mu[i + 1] = i << 1;
+                /* Begin Computing Sigma (Mu+1) and L(mu) */
+                /* check if discrepancy is set to 0 */
+                if (dmu[i] == 0) {
+                        dmu_0_count++;
+
+                        tmp = ((cap - (lmu[i] >> 1) - 1) / 2);
+                        if ((cap - (lmu[i] >> 1) - 1) & 0x1)
+                                tmp += 2;
+                        else
+                                tmp += 1;
+
+                        if (dmu_0_count == tmp) {
+                                for (j = 0; j <= (lmu[i] >> 1) + 1; j++)
+                                        smu[(cap + 1) * num + j] =
+                                                        smu[i * num + j];
+
+                                lmu[cap + 1] = lmu[i];
+                                return;
+                        }
+
+                        /* copy polynom */
+                        for (j = 0; j <= lmu[i] >> 1; j++)
+                                smu[(i + 1) * num + j] = smu[i * num + j];
+
+                        /* copy previous polynom order to the next */
+                        lmu[i + 1] = lmu[i];
+                } else {
+                        ro = 0;
+                        largest = -1;
+                        /* find largest delta with dmu != 0 */
+                        for (j = 0; j < i; j++) {
+                                if ((dmu[j]) && (delta[j] > largest)) {
+                                        largest = delta[j];
+                                        ro = j;
+                                }
+                        }
+
+                        /* compute difference */
+                        diff = (mu[i] - mu[ro]);
+
+                        /* Compute degree of the new smu polynomial */
+                        if ((lmu[i] >> 1) > ((lmu[ro] >> 1) + diff))
+                                lmu[i + 1] = lmu[i];
+                        else
+                                lmu[i + 1] = ((lmu[ro] >> 1) + diff) * 2;
+
+                        /* Init smu[i+1] with 0 */
+                        for (k = 0; k < num; k++)
+                                smu[(i + 1) * num + k] = 0;
+
+                        /* Compute smu[i+1] */
+                        for (k = 0; k <= lmu[ro] >> 1; k++) {
+                                int16_t a, b, c;
+
+                                if (!(smu[ro * num + k] && dmu[i]))
+                                        continue;
+                                a = readw_relaxed(index_of + dmu[i]);
+                                b = readw_relaxed(index_of + dmu[ro]);
+                                c = readw_relaxed(index_of + smu[ro * num + k]);
+                                tmp = a + (cw_len - b) + c;
+                                a = readw_relaxed(alpha_to + tmp % cw_len);
+                                smu[(i + 1) * num + (k + diff)] = a;
+                        }
+
+                        for (k = 0; k <= lmu[i] >> 1; k++)
+                                smu[(i + 1) * num + k] ^= smu[i * num + k];
+                }
+
+                /* End Computing Sigma (Mu+1) and L(mu) */
+                /* In either case compute delta */
+                delta[i + 1] = (mu[i + 1] * 2 - lmu[i + 1]) >> 1;
+
+                /* Do not compute discrepancy for the last iteration */
+                if (i >= cap)
+                        continue;
+
+                for (k = 0; k <= (lmu[i + 1] >> 1); k++) {
+                        tmp = 2 * (i - 1);
+                        if (k == 0) {
+                                dmu[i + 1] = si[tmp + 3];
+                        } else if (smu[(i + 1) * num + k] && si[tmp + 3 - k]) {
+                                int16_t a, b, c;
+                                a = readw_relaxed(index_of +
+                                                smu[(i + 1) * num + k]);
+                                b = si[2 * (i - 1) + 3 - k];
+                                c = readw_relaxed(index_of + b);
+                                tmp = a + c;
+                                tmp %= cw_len;
+                                dmu[i + 1] = readw_relaxed(alpha_to + tmp) ^
+                                        dmu[i + 1];
+                        }
+                }
+        }
+
+        return;
+}
+
+static int pmecc_err_location(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        unsigned long end_time;
+        const int cap = host->pmecc_corr_cap;
+        const int num = 2 * cap + 1;
+        int sector_size = host->pmecc_sector_size;
+        int err_nbr = 0;        /* number of error */
+        int roots_nbr;          /* number of roots */
+        int i;
+        uint32_t val;
+        int16_t *smu = host->pmecc_smu;
+
+        pmerrloc_writel(host->pmerrloc_base, ELDIS, PMERRLOC_DISABLE);
+
+        for (i = 0; i <= host->pmecc_lmu[cap + 1] >> 1; i++) {
+                pmerrloc_writel_sigma_relaxed(host->pmerrloc_base, i,
+                                      smu[(cap + 1) * num + i]);
+                err_nbr++;
+        }
+
+        val = (err_nbr - 1) << 16;
+        if (sector_size == 1024)
+                val |= 1;
+
+        pmerrloc_writel(host->pmerrloc_base, ELCFG, val);
+        pmerrloc_writel(host->pmerrloc_base, ELEN,
+                        sector_size * 8 + host->pmecc_degree * cap);
+
+        end_time = jiffies + msecs_to_jiffies(PMECC_MAX_TIMEOUT_MS);
+        while (!(pmerrloc_readl_relaxed(host->pmerrloc_base, ELISR)
+                 & PMERRLOC_CALC_DONE)) {
+                if (unlikely(time_after(jiffies, end_time))) {
+                        dev_err(host->dev, "PMECC: Timeout to calculate error location.\n");
+                        return -1;
+                }
+                cpu_relax();
+        }
+
+        roots_nbr = (pmerrloc_readl_relaxed(host->pmerrloc_base, ELISR)
+                & PMERRLOC_ERR_NUM_MASK) >> 8;
+        /* Number of roots == degree of smu hence <= cap */
+        if (roots_nbr == host->pmecc_lmu[cap + 1] >> 1)
+                return err_nbr - 1;
+
+        /* Number of roots does not match the degree of smu
+         * unable to correct error */
+        return -1;
+}
+
+static void pmecc_correct_data(struct mtd_info *mtd, uint8_t *buf, uint8_t *ecc,
+                int sector_num, int extra_bytes, int err_nbr)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        int i = 0;
+        int byte_pos, bit_pos, sector_size, pos;
+        uint32_t tmp;
+        uint8_t err_byte;
+
+        sector_size = host->pmecc_sector_size;
+
+        while (err_nbr) {
+                tmp = pmerrloc_readl_el_relaxed(host->pmerrloc_base, i) - 1;
+                byte_pos = tmp / 8;
+                bit_pos  = tmp % 8;
+
+                if (byte_pos >= (sector_size + extra_bytes))
+                        BUG();  /* should never happen */
+
+                if (byte_pos < sector_size) {
+                        err_byte = *(buf + byte_pos);
+                        *(buf + byte_pos) ^= (1 << bit_pos);
+
+                        pos = sector_num * host->pmecc_sector_size + byte_pos;
+                        dev_info(host->dev, "Bit flip in data area, byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
+                                pos, bit_pos, err_byte, *(buf + byte_pos));
+                } else {
+                        /* Bit flip in OOB area */
+                        tmp = sector_num * host->pmecc_bytes_per_sector
+                                        + (byte_pos - sector_size);
+                        err_byte = ecc[tmp];
+                        ecc[tmp] ^= (1 << bit_pos);
+
+                        pos = tmp + nand_chip->ecc.layout->eccpos[0];
+                        dev_info(host->dev, "Bit flip in OOB, oob_byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
+                                pos, bit_pos, err_byte, ecc[tmp]);
+                }
+
+                i++;
+                err_nbr--;
+        }
+
+        return;
+}
+
+static int pmecc_correction(struct mtd_info *mtd, u32 pmecc_stat, uint8_t *buf,
+        u8 *ecc)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        int i, err_nbr, eccbytes;
+        uint8_t *buf_pos;
+
+        eccbytes = nand_chip->ecc.bytes;
+        for (i = 0; i < eccbytes; i++)
+                if (ecc[i] != 0xff)
+                        goto normal_check;
+        /* Erased page, return OK */
+        return 0;
+
+normal_check:
+        for (i = 0; i < host->pmecc_sector_number; i++) {
+                err_nbr = 0;
+                if (pmecc_stat & 0x1) {
+                        buf_pos = buf + i * host->pmecc_sector_size;
+
+                        pmecc_gen_syndrome(mtd, i);
+                        pmecc_substitute(mtd);
+                        pmecc_get_sigma(mtd);
+
+                        err_nbr = pmecc_err_location(mtd);
+                        if (err_nbr == -1) {
+                                dev_err(host->dev, "PMECC: Too many errors\n");
+                                mtd->ecc_stats.failed++;
+                                return -EIO;
+                        } else {
+                                pmecc_correct_data(mtd, buf_pos, ecc, i,
+                                        host->pmecc_bytes_per_sector, err_nbr);
+                                mtd->ecc_stats.corrected += err_nbr;
+                        }
+                }
+                pmecc_stat >>= 1;
+        }
+
+        return 0;
+}
+
+static int atmel_nand_pmecc_read_page(struct mtd_info *mtd,
+        struct nand_chip *chip, uint8_t *buf, int oob_required, int page)
+{
+        struct atmel_nand_host *host = chip->priv;
+        int eccsize = chip->ecc.size;
+        uint8_t *oob = chip->oob_poi;
+        uint32_t *eccpos = chip->ecc.layout->eccpos;
+        uint32_t stat;
+        unsigned long end_time;
+
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_RST);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DISABLE);
+        pmecc_writel(host->ecc, CFG, (pmecc_readl_relaxed(host->ecc, CFG)
+                & ~PMECC_CFG_WRITE_OP) | PMECC_CFG_AUTO_ENABLE);
+
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_ENABLE);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DATA);
+
+        chip->read_buf(mtd, buf, eccsize);
+        chip->read_buf(mtd, oob, mtd->oobsize);
+
+        end_time = jiffies + msecs_to_jiffies(PMECC_MAX_TIMEOUT_MS);
+        while ((pmecc_readl_relaxed(host->ecc, SR) & PMECC_SR_BUSY)) {
+                if (unlikely(time_after(jiffies, end_time))) {
+                        dev_err(host->dev, "PMECC: Timeout to get error status.\n");
+                        return -EIO;
+                }
+                cpu_relax();
+        }
+
+        stat = pmecc_readl_relaxed(host->ecc, ISR);
+        if (stat != 0)
+                if (pmecc_correction(mtd, stat, buf, &oob[eccpos[0]]) != 0)
+                        return -EIO;
+
+        return 0;
+}
+
+static int atmel_nand_pmecc_write_page(struct mtd_info *mtd,
+                struct nand_chip *chip, const uint8_t *buf, int oob_required)
+{
+        struct atmel_nand_host *host = chip->priv;
+        uint32_t *eccpos = chip->ecc.layout->eccpos;
+        int i, j;
+        unsigned long end_time;
+
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_RST);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DISABLE);
+
+        pmecc_writel(host->ecc, CFG, (pmecc_readl_relaxed(host->ecc, CFG) |
+                PMECC_CFG_WRITE_OP) & ~PMECC_CFG_AUTO_ENABLE);
+
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_ENABLE);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DATA);
+
+        chip->write_buf(mtd, (u8 *)buf, mtd->writesize);
+
+        end_time = jiffies + msecs_to_jiffies(PMECC_MAX_TIMEOUT_MS);
+        while ((pmecc_readl_relaxed(host->ecc, SR) & PMECC_SR_BUSY)) {
+                if (unlikely(time_after(jiffies, end_time))) {
+                        dev_err(host->dev, "PMECC: Timeout to get ECC value.\n");
+                        return -EIO;
+                }
+                cpu_relax();
+        }
+
+        for (i = 0; i < host->pmecc_sector_number; i++) {
+                for (j = 0; j < host->pmecc_bytes_per_sector; j++) {
+                        int pos;
+
+                        pos = i * host->pmecc_bytes_per_sector + j;
+                        chip->oob_poi[eccpos[pos]] =
+                                pmecc_readb_ecc_relaxed(host->ecc, i, j);
+                }
+        }
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
+}
+
+static void atmel_pmecc_core_init(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct atmel_nand_host *host = nand_chip->priv;
+        uint32_t val = 0;
+        struct nand_ecclayout *ecc_layout;
+
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_RST);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DISABLE);
+
+        switch (host->pmecc_corr_cap) {
+        case 2:
+                val = PMECC_CFG_BCH_ERR2;
+                break;
+        case 4:
+                val = PMECC_CFG_BCH_ERR4;
+                break;
+        case 8:
+                val = PMECC_CFG_BCH_ERR8;
+                break;
+        case 12:
+                val = PMECC_CFG_BCH_ERR12;
+                break;
+        case 24:
+                val = PMECC_CFG_BCH_ERR24;
+                break;
+        }
+
+        if (host->pmecc_sector_size == 512)
+                val |= PMECC_CFG_SECTOR512;
+        else if (host->pmecc_sector_size == 1024)
+                val |= PMECC_CFG_SECTOR1024;
+
+        switch (host->pmecc_sector_number) {
+        case 1:
+                val |= PMECC_CFG_PAGE_1SECTOR;
+                break;
+        case 2:
+                val |= PMECC_CFG_PAGE_2SECTORS;
+                break;
+        case 4:
+                val |= PMECC_CFG_PAGE_4SECTORS;
+                break;
+        case 8:
+                val |= PMECC_CFG_PAGE_8SECTORS;
+                break;
+        }
+
+        val |= (PMECC_CFG_READ_OP | PMECC_CFG_SPARE_DISABLE
+                | PMECC_CFG_AUTO_DISABLE);
+        pmecc_writel(host->ecc, CFG, val);
+
+        ecc_layout = nand_chip->ecc.layout;
+        pmecc_writel(host->ecc, SAREA, mtd->oobsize - 1);
+        pmecc_writel(host->ecc, SADDR, ecc_layout->eccpos[0]);
+        pmecc_writel(host->ecc, EADDR,
+                        ecc_layout->eccpos[ecc_layout->eccbytes - 1]);
+        /* See datasheet about PMECC Clock Control Register */
+        pmecc_writel(host->ecc, CLK, 2);
+        pmecc_writel(host->ecc, IDR, 0xff);
+        pmecc_writel(host->ecc, CTRL, PMECC_CTRL_ENABLE);
+}
+
+static int __init atmel_pmecc_nand_init_params(struct platform_device *pdev,
+                                         struct atmel_nand_host *host)
+{
+        struct mtd_info *mtd = &host->mtd;
+        struct nand_chip *nand_chip = &host->nand_chip;
+        struct resource *regs, *regs_pmerr, *regs_rom;
+        int cap, sector_size, err_no;
+
+        cap = host->pmecc_corr_cap;
+        sector_size = host->pmecc_sector_size;
+        dev_info(host->dev, "Initialize PMECC params, cap: %d, sector: %d\n",
+                 cap, sector_size);
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!regs) {
+                dev_warn(host->dev,
+                        "Can't get I/O resource regs for PMECC controller, rolling back on software ECC\n");
+                nand_chip->ecc.mode = NAND_ECC_SOFT;
+                return 0;
+        }
+
+        host->ecc = ioremap(regs->start, resource_size(regs));
+        if (host->ecc == NULL) {
+                dev_err(host->dev, "ioremap failed\n");
+                err_no = -EIO;
+                goto err_pmecc_ioremap;
+        }
+
+        regs_pmerr = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        regs_rom = platform_get_resource(pdev, IORESOURCE_MEM, 3);
+        if (regs_pmerr && regs_rom) {
+                host->pmerrloc_base = ioremap(regs_pmerr->start,
+                        resource_size(regs_pmerr));
+                host->pmecc_rom_base = ioremap(regs_rom->start,
+                        resource_size(regs_rom));
+        }
+
+        if (!host->pmerrloc_base || !host->pmecc_rom_base) {
+                dev_err(host->dev,
+                        "Can not get I/O resource for PMECC ERRLOC controller or ROM!\n");
+                err_no = -EIO;
+                goto err_pmloc_ioremap;
+        }
+
+        /* ECC is calculated for the whole page (1 step) */
+        nand_chip->ecc.size = mtd->writesize;
+
+        /* set ECC page size and oob layout */
+        switch (mtd->writesize) {
+        case 2048:
+                host->pmecc_degree = PMECC_GF_DIMENSION_13;
+                host->pmecc_cw_len = (1 << host->pmecc_degree) - 1;
+                host->pmecc_sector_number = mtd->writesize / sector_size;
+                host->pmecc_bytes_per_sector = pmecc_get_ecc_bytes(
+                        cap, sector_size);
+                host->pmecc_alpha_to = pmecc_get_alpha_to(host);
+                host->pmecc_index_of = host->pmecc_rom_base +
+                        host->pmecc_lookup_table_offset;
+
+                nand_chip->ecc.steps = 1;
+                nand_chip->ecc.strength = cap;
+                nand_chip->ecc.bytes = host->pmecc_bytes_per_sector *
+                                       host->pmecc_sector_number;
+                if (nand_chip->ecc.bytes > mtd->oobsize - 2) {
+                        dev_err(host->dev, "No room for ECC bytes\n");
+                        err_no = -EINVAL;
+                        goto err_no_ecc_room;
+                }
+                pmecc_config_ecc_layout(&atmel_pmecc_oobinfo,
+                                        mtd->oobsize,
+                                        nand_chip->ecc.bytes);
+                nand_chip->ecc.layout = &atmel_pmecc_oobinfo;
+                break;
+        case 512:
+        case 1024:
+        case 4096:
+                /* TODO */
+                dev_warn(host->dev,
+                        "Unsupported page size for PMECC, use Software ECC\n");
+        default:
+                /* page size not handled by HW ECC */
+                /* switching back to soft ECC */
+                nand_chip->ecc.mode = NAND_ECC_SOFT;
+                return 0;
+        }
+
+        /* Allocate data for PMECC computation */
+        err_no = pmecc_data_alloc(host);
+        if (err_no) {
+                dev_err(host->dev,
+                                "Cannot allocate memory for PMECC computation!\n");
+                goto err_pmecc_data_alloc;
+        }
+
+        nand_chip->ecc.read_page = atmel_nand_pmecc_read_page;
+        nand_chip->ecc.write_page = atmel_nand_pmecc_write_page;
+
+        atmel_pmecc_core_init(mtd);
+
+        return 0;
+
+err_pmecc_data_alloc:
+err_no_ecc_room:
+err_pmloc_ioremap:
+        iounmap(host->ecc);
+        if (host->pmerrloc_base)
+                iounmap(host->pmerrloc_base);
+        if (host->pmecc_rom_base)
+                iounmap(host->pmecc_rom_base);
+err_pmecc_ioremap:
+        return err_no;
+}
+
+/*
  * Calculate HW ECC
  *
  * function called after a write
@@ -481,7 +1208,8 @@ static void atmel_nand_hwctl(struct mtd_info *mtd, int mode)
 static int __devinit atmel_of_init_port(struct atmel_nand_host *host,
                                          struct device_node *np)
 {
-        u32 val;
+        u32 val, table_offset;
+        u32 offset[2];
         int ecc_mode;
         struct atmel_nand_data *board = &host->board;
         enum of_gpio_flags flags;
@@ -517,6 +1245,50 @@ static int __devinit atmel_of_init_port(struct atmel_nand_host *host,
         board->enable_pin = of_get_gpio(np, 1);
         board->det_pin = of_get_gpio(np, 2);
 
+        host->has_pmecc = of_property_read_bool(np, "atmel,has-pmecc");
+
+        if (!(board->ecc_mode == NAND_ECC_HW) || !host->has_pmecc)
+                return 0;       /* Not using PMECC */
+
+        /* use PMECC, get correction capability, sector size and lookup
+         * table offset.
+         */
+        if (of_property_read_u32(np, "atmel,pmecc-cap", &val) != 0) {
+                dev_err(host->dev, "Cannot decide PMECC Capability\n");
+                return -EINVAL;
+        } else if ((val != 2) && (val != 4) && (val != 8) && (val != 12) &&
+            (val != 24)) {
+                dev_err(host->dev,
+                        "Unsupported PMECC correction capability: %d; should be 2, 4, 8, 12 or 24\n",
+                        val);
+                return -EINVAL;
+        }
+        host->pmecc_corr_cap = (u8)val;
+
+        if (of_property_read_u32(np, "atmel,pmecc-sector-size", &val) != 0) {
+                dev_err(host->dev, "Cannot decide PMECC Sector Size\n");
+                return -EINVAL;
+        } else if ((val != 512) && (val != 1024)) {
+                dev_err(host->dev,
+                        "Unsupported PMECC sector size: %d; should be 512 or 1024 bytes\n",
+                        val);
+                return -EINVAL;
+        }
+        host->pmecc_sector_size = (u16)val;
+
+        if (of_property_read_u32_array(np, "atmel,pmecc-lookup-table-offset",
+                        offset, 2) != 0) {
+                dev_err(host->dev, "Cannot get PMECC lookup table offset\n");
+                return -EINVAL;
+        }
+        table_offset = host->pmecc_sector_size == 512 ? offset[0] : offset[1];
+
+        if (!table_offset) {
+                dev_err(host->dev, "Invalid PMECC lookup table offset\n");
+                return -EINVAL;
+        }
+        host->pmecc_lookup_table_offset = table_offset;
+
         return 0;
 }
 #else
@@ -527,6 +1299,66 @@ static int __devinit atmel_of_init_port(struct atmel_nand_host *host,
 }
 #endif
 
+static int __init atmel_hw_nand_init_params(struct platform_device *pdev,
+                                         struct atmel_nand_host *host)
+{
+        struct mtd_info *mtd = &host->mtd;
+        struct nand_chip *nand_chip = &host->nand_chip;
+        struct resource         *regs;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!regs) {
+                dev_err(host->dev,
+                        "Can't get I/O resource regs, use software ECC\n");
+                nand_chip->ecc.mode = NAND_ECC_SOFT;
+                return 0;
+        }
+
+        host->ecc = ioremap(regs->start, resource_size(regs));
+        if (host->ecc == NULL) {
+                dev_err(host->dev, "ioremap failed\n");
+                return -EIO;
+        }
+
+        /* ECC is calculated for the whole page (1 step) */
+        nand_chip->ecc.size = mtd->writesize;
+
+        /* set ECC page size and oob layout */
+        switch (mtd->writesize) {
+        case 512:
+                nand_chip->ecc.layout = &atmel_oobinfo_small;
+                ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_528);
+                break;
+        case 1024:
+                nand_chip->ecc.layout = &atmel_oobinfo_large;
+                ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_1056);
+                break;
+        case 2048:
+                nand_chip->ecc.layout = &atmel_oobinfo_large;
+                ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_2112);
+                break;
+        case 4096:
+                nand_chip->ecc.layout = &atmel_oobinfo_large;
+                ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_4224);
+                break;
+        default:
+                /* page size not handled by HW ECC */
+                /* switching back to soft ECC */
+                nand_chip->ecc.mode = NAND_ECC_SOFT;
+                return 0;
+        }
+
+        /* set up for HW ECC */
+        nand_chip->ecc.calculate = atmel_nand_calculate;
+        nand_chip->ecc.correct = atmel_nand_correct;
+        nand_chip->ecc.hwctl = atmel_nand_hwctl;
+        nand_chip->ecc.read_page = atmel_nand_read_page;
+        nand_chip->ecc.bytes = 4;
+        nand_chip->ecc.strength = 1;
+
+        return 0;
+}
+
 /*
  * Probe for the NAND device.
  */
@@ -535,7 +1367,6 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         struct atmel_nand_host *host;
         struct mtd_info *mtd;
         struct nand_chip *nand_chip;
-        struct resource *regs;
         struct resource *mem;
         struct mtd_part_parser_data ppdata = {};
         int res;
@@ -568,7 +1399,7 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         if (pdev->dev.of_node) {
                 res = atmel_of_init_port(host, pdev->dev.of_node);
                 if (res)
-                        goto err_nand_ioremap;
+                        goto err_ecc_ioremap;
         } else {
                 memcpy(&host->board, pdev->dev.platform_data,
                        sizeof(struct atmel_nand_data));
@@ -583,33 +1414,45 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         nand_chip->IO_ADDR_W = host->io_base;
         nand_chip->cmd_ctrl = atmel_nand_cmd_ctrl;
 
-        if (gpio_is_valid(host->board.rdy_pin))
-                nand_chip->dev_ready = atmel_nand_device_ready;
+        if (gpio_is_valid(host->board.rdy_pin)) {
+                res = gpio_request(host->board.rdy_pin, "nand_rdy");
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request rdy gpio %d\n",
+                                host->board.rdy_pin);
+                        goto err_ecc_ioremap;
+                }
 
-        nand_chip->ecc.mode = host->board.ecc_mode;
+                res = gpio_direction_input(host->board.rdy_pin);
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request input direction rdy gpio %d\n",
+                                host->board.rdy_pin);
+                        goto err_ecc_ioremap;
+                }
 
-        regs = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!regs && nand_chip->ecc.mode == NAND_ECC_HW) {
-                printk(KERN_ERR "atmel_nand: can't get I/O resource "
-                                "regs\nFalling back on software ECC\n");
-                nand_chip->ecc.mode = NAND_ECC_SOFT;
+                nand_chip->dev_ready = atmel_nand_device_ready;
         }
 
-        if (nand_chip->ecc.mode == NAND_ECC_HW) {
-                host->ecc = ioremap(regs->start, resource_size(regs));
-                if (host->ecc == NULL) {
-                        printk(KERN_ERR "atmel_nand: ioremap failed\n");
-                        res = -EIO;
+        if (gpio_is_valid(host->board.enable_pin)) {
+                res = gpio_request(host->board.enable_pin, "nand_enable");
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request enable gpio %d\n",
+                                host->board.enable_pin);
+                        goto err_ecc_ioremap;
+                }
+
+                res = gpio_direction_output(host->board.enable_pin, 1);
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request output direction enable gpio %d\n",
+                                host->board.enable_pin);
                         goto err_ecc_ioremap;
                 }
-                nand_chip->ecc.calculate = atmel_nand_calculate;
-                nand_chip->ecc.correct = atmel_nand_correct;
-                nand_chip->ecc.hwctl = atmel_nand_hwctl;
-                nand_chip->ecc.read_page = atmel_nand_read_page;
-                nand_chip->ecc.bytes = 4;
-                nand_chip->ecc.strength = 1;
         }
 
+        nand_chip->ecc.mode = host->board.ecc_mode;
         nand_chip->chip_delay = 20;             /* 20us command delay time */
 
         if (host->board.bus_width_16)   /* 16-bit bus width */
@@ -622,6 +1465,22 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         atmel_nand_enable(host);
 
         if (gpio_is_valid(host->board.det_pin)) {
+                res = gpio_request(host->board.det_pin, "nand_det");
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request det gpio %d\n",
+                                host->board.det_pin);
+                        goto err_no_card;
+                }
+
+                res = gpio_direction_input(host->board.det_pin);
+                if (res < 0) {
+                        dev_err(&pdev->dev,
+                                "can't request input direction det gpio %d\n",
+                                host->board.det_pin);
+                        goto err_no_card;
+                }
+
                 if (gpio_get_value(host->board.det_pin)) {
                         printk(KERN_INFO "No SmartMedia card inserted.\n");
                         res = -ENXIO;
@@ -661,40 +1520,13 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         }
 
         if (nand_chip->ecc.mode == NAND_ECC_HW) {
-                /* ECC is calculated for the whole page (1 step) */
-                nand_chip->ecc.size = mtd->writesize;
-
-                /* set ECC page size and oob layout */
-                switch (mtd->writesize) {
-                case 512:
-                        nand_chip->ecc.layout = &atmel_oobinfo_small;
-                        ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_528);
-                        break;
-                case 1024:
-                        nand_chip->ecc.layout = &atmel_oobinfo_large;
-                        ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_1056);
-                        break;
-                case 2048:
-                        nand_chip->ecc.layout = &atmel_oobinfo_large;
-                        ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_2112);
-                        break;
-                case 4096:
-                        nand_chip->ecc.layout = &atmel_oobinfo_large;
-                        ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_4224);
-                        break;
-                default:
-                        /* page size not handled by HW ECC */
-                        /* switching back to soft ECC */
-                        nand_chip->ecc.mode = NAND_ECC_SOFT;
-                        nand_chip->ecc.calculate = NULL;
-                        nand_chip->ecc.correct = NULL;
-                        nand_chip->ecc.hwctl = NULL;
-                        nand_chip->ecc.read_page = NULL;
-                        nand_chip->ecc.postpad = 0;
-                        nand_chip->ecc.prepad = 0;
-                        nand_chip->ecc.bytes = 0;
-                        break;
-                }
+                if (host->has_pmecc)
+                        res = atmel_pmecc_nand_init_params(pdev, host);
+                else
+                        res = atmel_hw_nand_init_params(pdev, host);
+
+                if (res != 0)
+                        goto err_hw_ecc;
         }
 
         /* second phase scan */
@@ -711,14 +1543,23 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                 return res;
 
 err_scan_tail:
+        if (host->has_pmecc && host->nand_chip.ecc.mode == NAND_ECC_HW) {
+                pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DISABLE);
+                pmecc_data_free(host);
+        }
+        if (host->ecc)
+                iounmap(host->ecc);
+        if (host->pmerrloc_base)
+                iounmap(host->pmerrloc_base);
+        if (host->pmecc_rom_base)
+                iounmap(host->pmecc_rom_base);
+err_hw_ecc:
 err_scan_ident:
 err_no_card:
         atmel_nand_disable(host);
         platform_set_drvdata(pdev, NULL);
         if (host->dma_chan)
                 dma_release_channel(host->dma_chan);
-        if (host->ecc)
-                iounmap(host->ecc);
 err_ecc_ioremap:
         iounmap(host->io_base);
 err_nand_ioremap:
@@ -738,8 +1579,28 @@ static int __exit atmel_nand_remove(struct platform_device *pdev)
 
         atmel_nand_disable(host);
 
+        if (host->has_pmecc && host->nand_chip.ecc.mode == NAND_ECC_HW) {
+                pmecc_writel(host->ecc, CTRL, PMECC_CTRL_DISABLE);
+                pmerrloc_writel(host->pmerrloc_base, ELDIS,
+                                PMERRLOC_DISABLE);
+                pmecc_data_free(host);
+        }
+
+        if (gpio_is_valid(host->board.det_pin))
+                gpio_free(host->board.det_pin);
+
+        if (gpio_is_valid(host->board.enable_pin))
+                gpio_free(host->board.enable_pin);
+
+        if (gpio_is_valid(host->board.rdy_pin))
+                gpio_free(host->board.rdy_pin);
+
         if (host->ecc)
                 iounmap(host->ecc);
+        if (host->pmecc_rom_base)
+                iounmap(host->pmecc_rom_base);
+        if (host->pmerrloc_base)
+                iounmap(host->pmerrloc_base);
 
         if (host->dma_chan)
                 dma_release_channel(host->dma_chan);
diff --git a/drivers/mtd/nand/atmel_nand_ecc.h b/drivers/mtd/nand/atmel_nand_ecc.h
index 578c776e1356..8a1e9a686759 100644
--- a/drivers/mtd/nand/atmel_nand_ecc.h
+++ b/drivers/mtd/nand/atmel_nand_ecc.h
@@ -3,7 +3,7 @@
  * Based on AT91SAM9260 datasheet revision B.
  *
  * Copyright (C) 2007 Andrew Victor
- * Copyright (C) 2007 Atmel Corporation.
+ * Copyright (C) 2007 - 2012 Atmel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -36,4 +36,116 @@
 #define ATMEL_ECC_NPR           0x10                    /* NParity register */
 #define         ATMEL_ECC_NPARITY       (0xffff << 0)           /* NParity */
 
+/* PMECC Register Definitions */
+#define ATMEL_PMECC_CFG                 0x000   /* Configuration Register */
+#define         PMECC_CFG_BCH_ERR2              (0 << 0)
+#define         PMECC_CFG_BCH_ERR4              (1 << 0)
+#define         PMECC_CFG_BCH_ERR8              (2 << 0)
+#define         PMECC_CFG_BCH_ERR12             (3 << 0)
+#define         PMECC_CFG_BCH_ERR24             (4 << 0)
+
+#define         PMECC_CFG_SECTOR512             (0 << 4)
+#define         PMECC_CFG_SECTOR1024            (1 << 4)
+
+#define         PMECC_CFG_PAGE_1SECTOR          (0 << 8)
+#define         PMECC_CFG_PAGE_2SECTORS         (1 << 8)
+#define         PMECC_CFG_PAGE_4SECTORS         (2 << 8)
+#define         PMECC_CFG_PAGE_8SECTORS         (3 << 8)
+
+#define         PMECC_CFG_READ_OP               (0 << 12)
+#define         PMECC_CFG_WRITE_OP              (1 << 12)
+
+#define         PMECC_CFG_SPARE_ENABLE          (1 << 16)
+#define         PMECC_CFG_SPARE_DISABLE         (0 << 16)
+
+#define         PMECC_CFG_AUTO_ENABLE           (1 << 20)
+#define         PMECC_CFG_AUTO_DISABLE          (0 << 20)
+
+#define ATMEL_PMECC_SAREA               0x004   /* Spare area size */
+#define ATMEL_PMECC_SADDR               0x008   /* PMECC starting address */
+#define ATMEL_PMECC_EADDR               0x00c   /* PMECC ending address */
+#define ATMEL_PMECC_CLK                 0x010   /* PMECC clock control */
+#define         PMECC_CLK_133MHZ                (2 << 0)
+
+#define ATMEL_PMECC_CTRL                0x014   /* PMECC control register */
+#define         PMECC_CTRL_RST                  (1 << 0)
+#define         PMECC_CTRL_DATA                 (1 << 1)
+#define         PMECC_CTRL_USER                 (1 << 2)
+#define         PMECC_CTRL_ENABLE               (1 << 4)
+#define         PMECC_CTRL_DISABLE              (1 << 5)
+
+#define ATMEL_PMECC_SR                  0x018   /* PMECC status register */
+#define         PMECC_SR_BUSY                   (1 << 0)
+#define         PMECC_SR_ENABLE                 (1 << 4)
+
+#define ATMEL_PMECC_IER                 0x01c   /* PMECC interrupt enable */
+#define         PMECC_IER_ENABLE                (1 << 0)
+#define ATMEL_PMECC_IDR                 0x020   /* PMECC interrupt disable */
+#define         PMECC_IER_DISABLE               (1 << 0)
+#define ATMEL_PMECC_IMR                 0x024   /* PMECC interrupt mask */
+#define         PMECC_IER_MASK                  (1 << 0)
+#define ATMEL_PMECC_ISR                 0x028   /* PMECC interrupt status */
+#define ATMEL_PMECC_ECCx                0x040   /* PMECC ECC x */
+#define ATMEL_PMECC_REMx                0x240   /* PMECC REM x */
+
+/* PMERRLOC Register Definitions */
+#define ATMEL_PMERRLOC_ELCFG            0x000   /* Error location config */
+#define         PMERRLOC_ELCFG_SECTOR_512       (0 << 0)
+#define         PMERRLOC_ELCFG_SECTOR_1024      (1 << 0)
+#define         PMERRLOC_ELCFG_NUM_ERRORS(n)    ((n) << 16)
+
+#define ATMEL_PMERRLOC_ELPRIM           0x004   /* Error location primitive */
+#define ATMEL_PMERRLOC_ELEN             0x008   /* Error location enable */
+#define ATMEL_PMERRLOC_ELDIS            0x00c   /* Error location disable */
+#define         PMERRLOC_DISABLE                (1 << 0)
+
+#define ATMEL_PMERRLOC_ELSR             0x010   /* Error location status */
+#define         PMERRLOC_ELSR_BUSY              (1 << 0)
+#define ATMEL_PMERRLOC_ELIER            0x014   /* Error location int enable */
+#define ATMEL_PMERRLOC_ELIDR            0x018   /* Error location int disable */
+#define ATMEL_PMERRLOC_ELIMR            0x01c   /* Error location int mask */
+#define ATMEL_PMERRLOC_ELISR            0x020   /* Error location int status */
+#define         PMERRLOC_ERR_NUM_MASK           (0x1f << 8)
+#define         PMERRLOC_CALC_DONE              (1 << 0)
+#define ATMEL_PMERRLOC_SIGMAx           0x028   /* Error location SIGMA x */
+#define ATMEL_PMERRLOC_ELx              0x08c   /* Error location x */
+
+/* Register access macros for PMECC */
+#define pmecc_readl_relaxed(addr, reg) \
+        readl_relaxed((addr) + ATMEL_PMECC_##reg)
+
+#define pmecc_writel(addr, reg, value) \
+        writel((value), (addr) + ATMEL_PMECC_##reg)
+
+#define pmecc_readb_ecc_relaxed(addr, sector, n) \
+        readb_relaxed((addr) + ATMEL_PMECC_ECCx + ((sector) * 0x40) + (n))
+
+#define pmecc_readl_rem_relaxed(addr, sector, n) \
+        readl_relaxed((addr) + ATMEL_PMECC_REMx + ((sector) * 0x40) + ((n) * 4))
+
+#define pmerrloc_readl_relaxed(addr, reg) \
+        readl_relaxed((addr) + ATMEL_PMERRLOC_##reg)
+
+#define pmerrloc_writel(addr, reg, value) \
+        writel((value), (addr) + ATMEL_PMERRLOC_##reg)
+
+#define pmerrloc_writel_sigma_relaxed(addr, n, value) \
+        writel_relaxed((value), (addr) + ATMEL_PMERRLOC_SIGMAx + ((n) * 4))
+
+#define pmerrloc_readl_sigma_relaxed(addr, n) \
+        readl_relaxed((addr) + ATMEL_PMERRLOC_SIGMAx + ((n) * 4))
+
+#define pmerrloc_readl_el_relaxed(addr, n) \
+        readl_relaxed((addr) + ATMEL_PMERRLOC_ELx + ((n) * 4))
+
+/* Galois field dimension */
+#define PMECC_GF_DIMENSION_13                   13
+#define PMECC_GF_DIMENSION_14                   14
+
+#define PMECC_LOOKUP_TABLE_SIZE_512             0x2000
+#define PMECC_LOOKUP_TABLE_SIZE_1024            0x4000
+
+/* Time out value for reading PMECC status register */
+#define PMECC_MAX_TIMEOUT_MS                    100
+
 #endif
diff --git a/drivers/mtd/nand/au1550nd.c b/drivers/mtd/nand/au1550nd.c
index 9f609d2dcf62..5c47b200045a 100644
--- a/drivers/mtd/nand/au1550nd.c
+++ b/drivers/mtd/nand/au1550nd.c
@@ -141,28 +141,6 @@ static void au_read_buf(struct mtd_info *mtd, u_char *buf, int len)
 }
 
 /**
- * au_verify_buf -  Verify chip data against buffer
- * @mtd:        MTD device structure
- * @buf:        buffer containing the data to compare
- * @len:        number of bytes to compare
- *
- * verify function for 8bit buswidth
- */
-static int au_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        int i;
-        struct nand_chip *this = mtd->priv;
-
-        for (i = 0; i < len; i++) {
-                if (buf[i] != readb(this->IO_ADDR_R))
-                        return -EFAULT;
-                au_sync();
-        }
-
-        return 0;
-}
-
-/**
  * au_write_buf16 -  write buffer to chip
  * @mtd:        MTD device structure
  * @buf:        data buffer
@@ -205,29 +183,6 @@ static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
         }
 }
 
-/**
- * au_verify_buf16 -  Verify chip data against buffer
- * @mtd:        MTD device structure
- * @buf:        buffer containing the data to compare
- * @len:        number of bytes to compare
- *
- * verify function for 16bit buswidth
- */
-static int au_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        int i;
-        struct nand_chip *this = mtd->priv;
-        u16 *p = (u16 *) buf;
-        len >>= 1;
-
-        for (i = 0; i < len; i++) {
-                if (p[i] != readw(this->IO_ADDR_R))
-                        return -EFAULT;
-                au_sync();
-        }
-        return 0;
-}
-
 /* Select the chip by setting nCE to low */
 #define NAND_CTL_SETNCE         1
 /* Deselect the chip by setting nCE to high */
@@ -516,7 +471,6 @@ static int __devinit au1550nd_probe(struct platform_device *pdev)
         this->read_word = au_read_word;
         this->write_buf = (pd->devwidth) ? au_write_buf16 : au_write_buf;
         this->read_buf = (pd->devwidth) ? au_read_buf16 : au_read_buf;
-        this->verify_buf = (pd->devwidth) ? au_verify_buf16 : au_verify_buf;
 
         ret = nand_scan(&ctx->info, 1);
         if (ret) {
diff --git a/drivers/mtd/nand/bcm_umi_bch.c b/drivers/mtd/nand/bcm_umi_bch.c
deleted file mode 100644
index 5914bb32e001..000000000000
--- a/drivers/mtd/nand/bcm_umi_bch.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/*****************************************************************************
-* Copyright 2004 - 2009 Broadcom Corporation.  All rights reserved.
-*
-* Unless you and Broadcom execute a separate written software license
-* agreement governing use of this software, this software is licensed to you
-* under the terms of the GNU General Public License version 2, available at
-* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
-*
-* Notwithstanding the above, under no circumstances may you combine this
-* software in any way with any other Broadcom software provided under a
-* license other than the GPL, without Broadcom's express prior written
-* consent.
-*****************************************************************************/
-
-/* ---- Include Files ---------------------------------------------------- */
-#include "nand_bcm_umi.h"
-
-/* ---- External Variable Declarations ----------------------------------- */
-/* ---- External Function Prototypes ------------------------------------- */
-/* ---- Public Variables ------------------------------------------------- */
-/* ---- Private Constants and Types -------------------------------------- */
-
-/* ---- Private Function Prototypes -------------------------------------- */
-static int bcm_umi_bch_read_page_hwecc(struct mtd_info *mtd,
-        struct nand_chip *chip, uint8_t *buf, int oob_required, int page);
-static void bcm_umi_bch_write_page_hwecc(struct mtd_info *mtd,
-        struct nand_chip *chip, const uint8_t *buf, int oob_required);
-
-/* ---- Private Variables ------------------------------------------------ */
-
-/*
-** nand_hw_eccoob
-** New oob placement block for use with hardware ecc generation.
-*/
-static struct nand_ecclayout nand_hw_eccoob_512 = {
-        /* Reserve 5 for BI indicator */
-        .oobfree = {
-#if (NAND_ECC_NUM_BYTES > 3)
-                    {.offset = 0, .length = 2}
-#else
-                    {.offset = 0, .length = 5},
-                    {.offset = 6, .length = 7}
-#endif
-                    }
-};
-
-/*
-** We treat the OOB for a 2K page as if it were 4 512 byte oobs,
-** except the BI is at byte 0.
-*/
-static struct nand_ecclayout nand_hw_eccoob_2048 = {
-        /* Reserve 0 as BI indicator */
-        .oobfree = {
-#if (NAND_ECC_NUM_BYTES > 10)
-                    {.offset = 1, .length = 2},
-#elif (NAND_ECC_NUM_BYTES > 7)
-                    {.offset = 1, .length = 5},
-                    {.offset = 16, .length = 6},
-                    {.offset = 32, .length = 6},
-                    {.offset = 48, .length = 6}
-#else
-                    {.offset = 1, .length = 8},
-                    {.offset = 16, .length = 9},
-                    {.offset = 32, .length = 9},
-                    {.offset = 48, .length = 9}
-#endif
-                    }
-};
-
-/* We treat the OOB for a 4K page as if it were 8 512 byte oobs,
- * except the BI is at byte 0. */
-static struct nand_ecclayout nand_hw_eccoob_4096 = {
-        /* Reserve 0 as BI indicator */
-        .oobfree = {
-#if (NAND_ECC_NUM_BYTES > 10)
-                    {.offset = 1, .length = 2},
-                    {.offset = 16, .length = 3},
-                    {.offset = 32, .length = 3},
-                    {.offset = 48, .length = 3},
-                    {.offset = 64, .length = 3},
-                    {.offset = 80, .length = 3},
-                    {.offset = 96, .length = 3},
-                    {.offset = 112, .length = 3}
-#else
-                    {.offset = 1, .length = 5},
-                    {.offset = 16, .length = 6},
-                    {.offset = 32, .length = 6},
-                    {.offset = 48, .length = 6},
-                    {.offset = 64, .length = 6},
-                    {.offset = 80, .length = 6},
-                    {.offset = 96, .length = 6},
-                    {.offset = 112, .length = 6}
-#endif
-                    }
-};
-
-/* ---- Private Functions ------------------------------------------------ */
-/* ==== Public Functions ================================================= */
-
-/****************************************************************************
-*
-*  bcm_umi_bch_read_page_hwecc - hardware ecc based page read function
-*  @mtd:        mtd info structure
-*  @chip:       nand chip info structure
-*  @buf:        buffer to store read data
-*  @oob_required:       caller expects OOB data read to chip->oob_poi
-*
-***************************************************************************/
-static int bcm_umi_bch_read_page_hwecc(struct mtd_info *mtd,
-                                       struct nand_chip *chip, uint8_t * buf,
-                                       int oob_required, int page)
-{
-        int sectorIdx = 0;
-        int eccsize = chip->ecc.size;
-        int eccsteps = chip->ecc.steps;
-        uint8_t *datap = buf;
-        uint8_t eccCalc[NAND_ECC_NUM_BYTES];
-        int sectorOobSize = mtd->oobsize / eccsteps;
-        int stat;
-        unsigned int max_bitflips = 0;
-
-        for (sectorIdx = 0; sectorIdx < eccsteps;
-                        sectorIdx++, datap += eccsize) {
-                if (sectorIdx > 0) {
-                        /* Seek to page location within sector */
-                        chip->cmdfunc(mtd, NAND_CMD_RNDOUT, sectorIdx * eccsize,
-                                      -1);
-                }
-
-                /* Enable hardware ECC before reading the buf */
-                nand_bcm_umi_bch_enable_read_hwecc();
-
-                /* Read in data */
-                bcm_umi_nand_read_buf(mtd, datap, eccsize);
-
-                /* Pause hardware ECC after reading the buf */
-                nand_bcm_umi_bch_pause_read_ecc_calc();
-
-                /* Read the OOB ECC */
-                chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
-                              mtd->writesize + sectorIdx * sectorOobSize, -1);
-                nand_bcm_umi_bch_read_oobEcc(mtd->writesize, eccCalc,
-                                             NAND_ECC_NUM_BYTES,
-                                             chip->oob_poi +
-                                             sectorIdx * sectorOobSize);
-
-                /* Correct any ECC detected errors */
-                stat =
-                    nand_bcm_umi_bch_correct_page(datap, eccCalc,
-                                                  NAND_ECC_NUM_BYTES);
-
-                /* Update Stats */
-                if (stat < 0) {
-#if defined(NAND_BCM_UMI_DEBUG)
-                        printk(KERN_WARNING "%s uncorr_err sectorIdx=%d\n",
-                               __func__, sectorIdx);
-                        printk(KERN_WARNING
-                               "%s data %02x %02x %02x %02x "
-                                         "%02x %02x %02x %02x\n",
-                               __func__, datap[0], datap[1], datap[2], datap[3],
-                               datap[4], datap[5], datap[6], datap[7]);
-                        printk(KERN_WARNING
-                               "%s ecc  %02x %02x %02x %02x "
-                                         "%02x %02x %02x %02x %02x %02x "
-                                         "%02x %02x %02x\n",
-                               __func__, eccCalc[0], eccCalc[1], eccCalc[2],
-                               eccCalc[3], eccCalc[4], eccCalc[5], eccCalc[6],
-                               eccCalc[7], eccCalc[8], eccCalc[9], eccCalc[10],
-                               eccCalc[11], eccCalc[12]);
-                        BUG();
-#endif
-                        mtd->ecc_stats.failed++;
-                } else {
-#if defined(NAND_BCM_UMI_DEBUG)
-                        if (stat > 0) {
-                                printk(KERN_INFO
-                                       "%s %d correctable_errors detected\n",
-                                       __func__, stat);
-                        }
-#endif
-                        mtd->ecc_stats.corrected += stat;
-                        max_bitflips = max_t(unsigned int, max_bitflips, stat);
-                }
-        }
-        return max_bitflips;
-}
-
-/****************************************************************************
-*
-*  bcm_umi_bch_write_page_hwecc - hardware ecc based page write function
-*  @mtd:        mtd info structure
-*  @chip:       nand chip info structure
-*  @buf:        data buffer
-*  @oob_required:       must write chip->oob_poi to OOB
-*
-***************************************************************************/
-static void bcm_umi_bch_write_page_hwecc(struct mtd_info *mtd,
-        struct nand_chip *chip, const uint8_t *buf, int oob_required)
-{
-        int sectorIdx = 0;
-        int eccsize = chip->ecc.size;
-        int eccsteps = chip->ecc.steps;
-        const uint8_t *datap = buf;
-        uint8_t *oobp = chip->oob_poi;
-        int sectorOobSize = mtd->oobsize / eccsteps;
-
-        for (sectorIdx = 0; sectorIdx < eccsteps;
-             sectorIdx++, datap += eccsize, oobp += sectorOobSize) {
-                /* Enable hardware ECC before writing the buf */
-                nand_bcm_umi_bch_enable_write_hwecc();
-                bcm_umi_nand_write_buf(mtd, datap, eccsize);
-                nand_bcm_umi_bch_write_oobEcc(mtd->writesize, oobp,
-                                              NAND_ECC_NUM_BYTES);
-        }
-
-        bcm_umi_nand_write_buf(mtd, chip->oob_poi, mtd->oobsize);
-}
diff --git a/drivers/mtd/nand/bcm_umi_nand.c b/drivers/mtd/nand/bcm_umi_nand.c
deleted file mode 100644
index d0d1bd4d0e7d..000000000000
--- a/drivers/mtd/nand/bcm_umi_nand.c
+++ /dev/null
@@ -1,555 +0,0 @@
-/*****************************************************************************
-* Copyright 2004 - 2009 Broadcom Corporation.  All rights reserved.
-*
-* Unless you and Broadcom execute a separate written software license
-* agreement governing use of this software, this software is licensed to you
-* under the terms of the GNU General Public License version 2, available at
-* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
-*
-* Notwithstanding the above, under no circumstances may you combine this
-* software in any way with any other Broadcom software provided under a
-* license other than the GPL, without Broadcom's express prior written
-* consent.
-*****************************************************************************/
-
-/* ---- Include Files ---------------------------------------------------- */
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/ioport.h>
-#include <linux/device.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/platform_device.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/nand.h>
-#include <linux/mtd/nand_ecc.h>
-#include <linux/mtd/partitions.h>
-
-#include <asm/mach-types.h>
-
-#include <mach/reg_nand.h>
-#include <mach/reg_umi.h>
-
-#include "nand_bcm_umi.h"
-
-#include <mach/memory_settings.h>
-
-#define USE_DMA 1
-#include <mach/dma.h>
-#include <linux/dma-mapping.h>
-#include <linux/completion.h>
-
-/* ---- External Variable Declarations ----------------------------------- */
-/* ---- External Function Prototypes ------------------------------------- */
-/* ---- Public Variables ------------------------------------------------- */
-/* ---- Private Constants and Types -------------------------------------- */
-static const __devinitconst char gBanner[] = KERN_INFO \
-        "BCM UMI MTD NAND Driver: 1.00\n";
-
-#if NAND_ECC_BCH
-static uint8_t scan_ff_pattern[] = { 0xff };
-
-static struct nand_bbt_descr largepage_bbt = {
-        .options = 0,
-        .offs = 0,
-        .len = 1,
-        .pattern = scan_ff_pattern
-};
-#endif
-
-/*
-** Preallocate a buffer to avoid having to do this every dma operation.
-** This is the size of the preallocated coherent DMA buffer.
-*/
-#if USE_DMA
-#define DMA_MIN_BUFLEN  512
-#define DMA_MAX_BUFLEN  PAGE_SIZE
-#define USE_DIRECT_IO(len)      (((len) < DMA_MIN_BUFLEN) || \
-        ((len) > DMA_MAX_BUFLEN))
-
-/*
- * The current NAND data space goes from 0x80001900 to 0x80001FFF,
- * which is only 0x700 = 1792 bytes long. This is too small for 2K, 4K page
- * size NAND flash. Need to break the DMA down to multiple 1Ks.
- *
- * Need to make sure REG_NAND_DATA_PADDR + DMA_MAX_LEN < 0x80002000
- */
-#define DMA_MAX_LEN             1024
-
-#else /* !USE_DMA */
-#define DMA_MIN_BUFLEN          0
-#define DMA_MAX_BUFLEN          0
-#define USE_DIRECT_IO(len)      1
-#endif
-/* ---- Private Function Prototypes -------------------------------------- */
-static void bcm_umi_nand_read_buf(struct mtd_info *mtd, u_char * buf, int len);
-static void bcm_umi_nand_write_buf(struct mtd_info *mtd, const u_char * buf,
-                                   int len);
-
-/* ---- Private Variables ------------------------------------------------ */
-static struct mtd_info *board_mtd;
-static void __iomem *bcm_umi_io_base;
-static void *virtPtr;
-static dma_addr_t physPtr;
-static struct completion nand_comp;
-
-/* ---- Private Functions ------------------------------------------------ */
-#if NAND_ECC_BCH
-#include "bcm_umi_bch.c"
-#else
-#include "bcm_umi_hamming.c"
-#endif
-
-#if USE_DMA
-
-/* Handler called when the DMA finishes. */
-static void nand_dma_handler(DMA_Device_t dev, int reason, void *userData)
-{
-        complete(&nand_comp);
-}
-
-static int nand_dma_init(void)
-{
-        int rc;
-
-        rc = dma_set_device_handler(DMA_DEVICE_NAND_MEM_TO_MEM,
-                nand_dma_handler, NULL);
-        if (rc != 0) {
-                printk(KERN_ERR "dma_set_device_handler failed: %d\n", rc);
-                return rc;
-        }
-
-        virtPtr =
-            dma_alloc_coherent(NULL, DMA_MAX_BUFLEN, &physPtr, GFP_KERNEL);
-        if (virtPtr == NULL) {
-                printk(KERN_ERR "NAND - Failed to allocate memory for DMA buffer\n");
-                return -ENOMEM;
-        }
-
-        return 0;
-}
-
-static void nand_dma_term(void)
-{
-        if (virtPtr != NULL)
-                dma_free_coherent(NULL, DMA_MAX_BUFLEN, virtPtr, physPtr);
-}
-
-static void nand_dma_read(void *buf, int len)
-{
-        int offset = 0;
-        int tmp_len = 0;
-        int len_left = len;
-        DMA_Handle_t hndl;
-
-        if (virtPtr == NULL)
-                panic("nand_dma_read: virtPtr == NULL\n");
-
-        if ((void *)physPtr == NULL)
-                panic("nand_dma_read: physPtr == NULL\n");
-
-        hndl = dma_request_channel(DMA_DEVICE_NAND_MEM_TO_MEM);
-        if (hndl < 0) {
-                printk(KERN_ERR
-                       "nand_dma_read: unable to allocate dma channel: %d\n",
-                       (int)hndl);
-                panic("\n");
-        }
-
-        while (len_left > 0) {
-                if (len_left > DMA_MAX_LEN) {
-                        tmp_len = DMA_MAX_LEN;
-                        len_left -= DMA_MAX_LEN;
-                } else {
-                        tmp_len = len_left;
-                        len_left = 0;
-                }
-
-                init_completion(&nand_comp);
-                dma_transfer_mem_to_mem(hndl, REG_NAND_DATA_PADDR,
-                                        physPtr + offset, tmp_len);
-                wait_for_completion(&nand_comp);
-
-                offset += tmp_len;
-        }
-
-        dma_free_channel(hndl);
-
-        if (buf != NULL)
-                memcpy(buf, virtPtr, len);
-}
-
-static void nand_dma_write(const void *buf, int len)
-{
-        int offset = 0;
-        int tmp_len = 0;
-        int len_left = len;
-        DMA_Handle_t hndl;
-
-        if (buf == NULL)
-                panic("nand_dma_write: buf == NULL\n");
-
-        if (virtPtr == NULL)
-                panic("nand_dma_write: virtPtr == NULL\n");
-
-        if ((void *)physPtr == NULL)
-                panic("nand_dma_write: physPtr == NULL\n");
-
-        memcpy(virtPtr, buf, len);
-
-
-        hndl = dma_request_channel(DMA_DEVICE_NAND_MEM_TO_MEM);
-        if (hndl < 0) {
-                printk(KERN_ERR
-                       "nand_dma_write: unable to allocate dma channel: %d\n",
-                       (int)hndl);
-                panic("\n");
-        }
-
-        while (len_left > 0) {
-                if (len_left > DMA_MAX_LEN) {
-                        tmp_len = DMA_MAX_LEN;
-                        len_left -= DMA_MAX_LEN;
-                } else {
-                        tmp_len = len_left;
-                        len_left = 0;
-                }
-
-                init_completion(&nand_comp);
-                dma_transfer_mem_to_mem(hndl, physPtr + offset,
-                                        REG_NAND_DATA_PADDR, tmp_len);
-                wait_for_completion(&nand_comp);
-
-                offset += tmp_len;
-        }
-
-        dma_free_channel(hndl);
-}
-
-#endif
-
-static int nand_dev_ready(struct mtd_info *mtd)
-{
-        return nand_bcm_umi_dev_ready();
-}
-
-/****************************************************************************
-*
-*  bcm_umi_nand_inithw
-*
-*   This routine does the necessary hardware (board-specific)
-*   initializations.  This includes setting up the timings, etc.
-*
-***************************************************************************/
-int bcm_umi_nand_inithw(void)
-{
-        /* Configure nand timing parameters */
-        writel(readl(&REG_UMI_NAND_TCR) & ~0x7ffff, &REG_UMI_NAND_TCR);
-        writel(readl(&REG_UMI_NAND_TCR) | HW_CFG_NAND_TCR, &REG_UMI_NAND_TCR);
-
-#if !defined(CONFIG_MTD_NAND_BCM_UMI_HWCS)
-        /* enable software control of CS */
-        writel(readl(&REG_UMI_NAND_TCR) | REG_UMI_NAND_TCR_CS_SWCTRL, &REG_UMI_NAND_TCR);
-#endif
-
-        /* keep NAND chip select asserted */
-        writel(readl(&REG_UMI_NAND_RCSR) | REG_UMI_NAND_RCSR_CS_ASSERTED, &REG_UMI_NAND_RCSR);
-
-        writel(readl(&REG_UMI_NAND_TCR) & ~REG_UMI_NAND_TCR_WORD16, &REG_UMI_NAND_TCR);
-        /* enable writes to flash */
-        writel(readl(&REG_UMI_MMD_ICR) | REG_UMI_MMD_ICR_FLASH_WP, &REG_UMI_MMD_ICR);
-
-        writel(NAND_CMD_RESET, bcm_umi_io_base + REG_NAND_CMD_OFFSET);
-        nand_bcm_umi_wait_till_ready();
-
-#if NAND_ECC_BCH
-        nand_bcm_umi_bch_config_ecc(NAND_ECC_NUM_BYTES);
-#endif
-
-        return 0;
-}
-
-/* Used to turn latch the proper register for access. */
-static void bcm_umi_nand_hwcontrol(struct mtd_info *mtd, int cmd,
-                                   unsigned int ctrl)
-{
-        /* send command to hardware */
-        struct nand_chip *chip = mtd->priv;
-        if (ctrl & NAND_CTRL_CHANGE) {
-                if (ctrl & NAND_CLE) {
-                        chip->IO_ADDR_W = bcm_umi_io_base + REG_NAND_CMD_OFFSET;
-                        goto CMD;
-                }
-                if (ctrl & NAND_ALE) {
-                        chip->IO_ADDR_W =
-                            bcm_umi_io_base + REG_NAND_ADDR_OFFSET;
-                        goto CMD;
-                }
-                chip->IO_ADDR_W = bcm_umi_io_base + REG_NAND_DATA8_OFFSET;
-        }
-
-CMD:
-        /* Send command to chip directly */
-        if (cmd != NAND_CMD_NONE)
-                writeb(cmd, chip->IO_ADDR_W);
-}
-
-static void bcm_umi_nand_write_buf(struct mtd_info *mtd, const u_char * buf,
-                                   int len)
-{
-        if (USE_DIRECT_IO(len)) {
-                /* Do it the old way if the buffer is small or too large.
-                 * Probably quicker than starting and checking dma. */
-                int i;
-                struct nand_chip *this = mtd->priv;
-
-                for (i = 0; i < len; i++)
-                        writeb(buf[i], this->IO_ADDR_W);
-        }
-#if USE_DMA
-        else
-                nand_dma_write(buf, len);
-#endif
-}
-
-static void bcm_umi_nand_read_buf(struct mtd_info *mtd, u_char * buf, int len)
-{
-        if (USE_DIRECT_IO(len)) {
-                int i;
-                struct nand_chip *this = mtd->priv;
-
-                for (i = 0; i < len; i++)
-                        buf[i] = readb(this->IO_ADDR_R);
-        }
-#if USE_DMA
-        else
-                nand_dma_read(buf, len);
-#endif
-}
-
-static uint8_t readbackbuf[NAND_MAX_PAGESIZE];
-static int bcm_umi_nand_verify_buf(struct mtd_info *mtd, const u_char * buf,
-                                   int len)
-{
-        /*
-         * Try to readback page with ECC correction. This is necessary
-         * for MLC parts which may have permanently stuck bits.
-         */
-        struct nand_chip *chip = mtd->priv;
-        int ret = chip->ecc.read_page(mtd, chip, readbackbuf, 0, 0);
-        if (ret < 0)
-                return -EFAULT;
-        else {
-                if (memcmp(readbackbuf, buf, len) == 0)
-                        return 0;
-
-                return -EFAULT;
-        }
-        return 0;
-}
-
-static int __devinit bcm_umi_nand_probe(struct platform_device *pdev)
-{
-        struct nand_chip *this;
-        struct resource *r;
-        int err = 0;
-
-        printk(gBanner);
-
-        /* Allocate memory for MTD device structure and private data */
-        board_mtd =
-            kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip),
-                    GFP_KERNEL);
-        if (!board_mtd) {
-                printk(KERN_WARNING
-                       "Unable to allocate NAND MTD device structure.\n");
-                return -ENOMEM;
-        }
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-        if (!r) {
-                err = -ENXIO;
-                goto out_free;
-        }
-
-        /* map physical address */
-        bcm_umi_io_base = ioremap(r->start, resource_size(r));
-
-        if (!bcm_umi_io_base) {
-                printk(KERN_ERR "ioremap to access BCM UMI NAND chip failed\n");
-                err = -EIO;
-                goto out_free;
-        }
-
-        /* Get pointer to private data */
-        this = (struct nand_chip *)(&board_mtd[1]);
-
-        /* Initialize structures */
-        memset((char *)board_mtd, 0, sizeof(struct mtd_info));
-        memset((char *)this, 0, sizeof(struct nand_chip));
-
-        /* Link the private data with the MTD structure */
-        board_mtd->priv = this;
-
-        /* Initialize the NAND hardware.  */
-        if (bcm_umi_nand_inithw() < 0) {
-                printk(KERN_ERR "BCM UMI NAND chip could not be initialized\n");
-                err = -EIO;
-                goto out_unmap;
-        }
-
-        /* Set address of NAND IO lines */
-        this->IO_ADDR_W = bcm_umi_io_base + REG_NAND_DATA8_OFFSET;
-        this->IO_ADDR_R = bcm_umi_io_base + REG_NAND_DATA8_OFFSET;
-
-        /* Set command delay time, see datasheet for correct value */
-        this->chip_delay = 0;
-        /* Assign the device ready function, if available */
-        this->dev_ready = nand_dev_ready;
-        this->options = 0;
-
-        this->write_buf = bcm_umi_nand_write_buf;
-        this->read_buf = bcm_umi_nand_read_buf;
-        this->verify_buf = bcm_umi_nand_verify_buf;
-
-        this->cmd_ctrl = bcm_umi_nand_hwcontrol;
-        this->ecc.mode = NAND_ECC_HW;
-        this->ecc.size = 512;
-        this->ecc.bytes = NAND_ECC_NUM_BYTES;
-#if NAND_ECC_BCH
-        this->ecc.read_page = bcm_umi_bch_read_page_hwecc;
-        this->ecc.write_page = bcm_umi_bch_write_page_hwecc;
-#else
-        this->ecc.correct = nand_correct_data512;
-        this->ecc.calculate = bcm_umi_hamming_get_hw_ecc;
-        this->ecc.hwctl = bcm_umi_hamming_enable_hwecc;
-#endif
-
-#if USE_DMA
-        err = nand_dma_init();
-        if (err != 0)
-                goto out_unmap;
-#endif
-
-        /* Figure out the size of the device that we have.
-         * We need to do this to figure out which ECC
-         * layout we'll be using.
-         */
-
-        err = nand_scan_ident(board_mtd, 1, NULL);
-        if (err) {
-                printk(KERN_ERR "nand_scan failed: %d\n", err);
-                goto out_unmap;
-        }
-
-        /* Now that we know the nand size, we can setup the ECC layout */
-
-        switch (board_mtd->writesize) { /* writesize is the pagesize */
-        case 4096:
-                this->ecc.layout = &nand_hw_eccoob_4096;
-                break;
-        case 2048:
-                this->ecc.layout = &nand_hw_eccoob_2048;
-                break;
-        case 512:
-                this->ecc.layout = &nand_hw_eccoob_512;
-                break;
-        default:
-                {
-                        printk(KERN_ERR "NAND - Unrecognized pagesize: %d\n",
-                                         board_mtd->writesize);
-                        err = -EINVAL;
-                        goto out_unmap;
-                }
-        }
-
-#if NAND_ECC_BCH
-        if (board_mtd->writesize > 512) {
-                if (this->bbt_options & NAND_BBT_USE_FLASH)
-                        largepage_bbt.options = NAND_BBT_SCAN2NDPAGE;
-                this->badblock_pattern = &largepage_bbt;
-        }
-
-        this->ecc.strength = 8;
-
-#endif
-
-        /* Now finish off the scan, now that ecc.layout has been initialized. */
-
-        err = nand_scan_tail(board_mtd);
-        if (err) {
-                printk(KERN_ERR "nand_scan failed: %d\n", err);
-                goto out_unmap;
-        }
-
-        /* Register the partitions */
-        board_mtd->name = "bcm_umi-nand";
-        mtd_device_parse_register(board_mtd, NULL, NULL, NULL, 0);
-
-        /* Return happy */
-        return 0;
-out_unmap:
-        iounmap(bcm_umi_io_base);
-out_free:
-        kfree(board_mtd);
-        return err;
-}
-
-static int bcm_umi_nand_remove(struct platform_device *pdev)
-{
-#if USE_DMA
-        nand_dma_term();
-#endif
-
-        /* Release resources, unregister device */
-        nand_release(board_mtd);
-
-        /* unmap physical address */
-        iounmap(bcm_umi_io_base);
-
-        /* Free the MTD device structure */
-        kfree(board_mtd);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int bcm_umi_nand_suspend(struct platform_device *pdev,
-                                pm_message_t state)
-{
-        printk(KERN_ERR "MTD NAND suspend is being called\n");
-        return 0;
-}
-
-static int bcm_umi_nand_resume(struct platform_device *pdev)
-{
-        printk(KERN_ERR "MTD NAND resume is being called\n");
-        return 0;
-}
-#else
-#define bcm_umi_nand_suspend   NULL
-#define bcm_umi_nand_resume    NULL
-#endif
-
-static struct platform_driver nand_driver = {
-        .driver = {
-                   .name = "bcm-nand",
-                   .owner = THIS_MODULE,
-                   },
-        .probe = bcm_umi_nand_probe,
-        .remove = bcm_umi_nand_remove,
-        .suspend = bcm_umi_nand_suspend,
-        .resume = bcm_umi_nand_resume,
-};
-
-module_platform_driver(nand_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Broadcom");
-MODULE_DESCRIPTION("BCM UMI MTD NAND driver");
diff --git a/drivers/mtd/nand/bf5xx_nand.c b/drivers/mtd/nand/bf5xx_nand.c
index 3f1c18599cbd..ab0caa74eb43 100644
--- a/drivers/mtd/nand/bf5xx_nand.c
+++ b/drivers/mtd/nand/bf5xx_nand.c
@@ -566,11 +566,13 @@ static int bf5xx_nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip
         return 0;
 }
 
-static void bf5xx_nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
-                const uint8_t *buf, int oob_required)
+static int bf5xx_nand_write_page_raw(struct mtd_info *mtd,
+                struct nand_chip *chip, const uint8_t *buf, int oob_required)
 {
         bf5xx_nand_write_buf(mtd, buf, mtd->writesize);
         bf5xx_nand_write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 /*
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index f3f6cfedd69e..2bb7170502c2 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -377,7 +377,7 @@ static int cafe_nand_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
  * @buf:        buffer to store read data
  * @oob_required:       caller expects OOB data read to chip->oob_poi
  *
- * The hw generator calculates the error syndrome automatically. Therefor
+ * The hw generator calculates the error syndrome automatically. Therefore
  * we need a special oob layout and handling.
  */
 static int cafe_nand_read_page(struct mtd_info *mtd, struct nand_chip *chip,
@@ -520,7 +520,7 @@ static struct nand_bbt_descr cafe_bbt_mirror_descr_512 = {
 };
 
 
-static void cafe_nand_write_page_lowlevel(struct mtd_info *mtd,
+static int cafe_nand_write_page_lowlevel(struct mtd_info *mtd,
                                           struct nand_chip *chip,
                                           const uint8_t *buf, int oob_required)
 {
@@ -531,6 +531,8 @@ static void cafe_nand_write_page_lowlevel(struct mtd_info *mtd,
 
         /* Set up ECC autogeneration */
         cafe->ctl2 |= (1<<30);
+
+        return 0;
 }
 
 static int cafe_nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
@@ -542,9 +544,12 @@ static int cafe_nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
         chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
 
         if (unlikely(raw))
-                chip->ecc.write_page_raw(mtd, chip, buf, oob_required);
+                status = chip->ecc.write_page_raw(mtd, chip, buf, oob_required);
         else
-                chip->ecc.write_page(mtd, chip, buf, oob_required);
+                status = chip->ecc.write_page(mtd, chip, buf, oob_required);
+
+        if (status < 0)
+                return status;
 
         /*
          * Cached progamming disabled for now, Not sure if its worth the
@@ -571,13 +576,6 @@ static int cafe_nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                 status = chip->waitfunc(mtd, chip);
         }
 
-#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
-        /* Send command to read back the data */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
-
-        if (chip->verify_buf(mtd, buf, mtd->writesize))
-                return -EIO;
-#endif
         return 0;
 }
 
diff --git a/drivers/mtd/nand/cmx270_nand.c b/drivers/mtd/nand/cmx270_nand.c
index 1024bfc05c86..39b2ef848811 100644
--- a/drivers/mtd/nand/cmx270_nand.c
+++ b/drivers/mtd/nand/cmx270_nand.c
@@ -76,18 +76,6 @@ static void cmx270_read_buf(struct mtd_info *mtd, u_char *buf, int len)
                 *buf++ = readl(this->IO_ADDR_R) >> 16;
 }
 
-static int cmx270_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        int i;
-        struct nand_chip *this = mtd->priv;
-
-        for (i=0; i<len; i++)
-                if (buf[i] != (u_char)(readl(this->IO_ADDR_R) >> 16))
-                        return -EFAULT;
-
-        return 0;
-}
-
 static inline void nand_cs_on(void)
 {
         gpio_set_value(GPIO_NAND_CS, 0);
@@ -209,7 +197,6 @@ static int __init cmx270_init(void)
         this->read_byte = cmx270_read_byte;
         this->read_buf = cmx270_read_buf;
         this->write_buf = cmx270_write_buf;
-        this->verify_buf = cmx270_verify_buf;
 
         /* Scan to find existence of the device */
         if (nand_scan (cmx270_nand_mtd, 1)) {
diff --git a/drivers/mtd/nand/davinci_nand.c b/drivers/mtd/nand/davinci_nand.c
index f1deb1ee2c95..945047ad0952 100644
--- a/drivers/mtd/nand/davinci_nand.c
+++ b/drivers/mtd/nand/davinci_nand.c
@@ -33,6 +33,7 @@
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
 #include <linux/slab.h>
+#include <linux/of_device.h>
 
 #include <linux/platform_data/mtd-davinci.h>
 #include <linux/platform_data/mtd-davinci-aemif.h>
@@ -518,9 +519,75 @@ static struct nand_ecclayout hwecc4_2048 __initconst = {
         },
 };
 
+#if defined(CONFIG_OF)
+static const struct of_device_id davinci_nand_of_match[] = {
+        {.compatible = "ti,davinci-nand", },
+        {},
+}
+MODULE_DEVICE_TABLE(of, davinci_nand_of_match);
+
+static struct davinci_nand_pdata
+        *nand_davinci_get_pdata(struct platform_device *pdev)
+{
+        if (!pdev->dev.platform_data && pdev->dev.of_node) {
+                struct davinci_nand_pdata *pdata;
+                const char *mode;
+                u32 prop;
+                int len;
+
+                pdata =  devm_kzalloc(&pdev->dev,
+                                sizeof(struct davinci_nand_pdata),
+                                GFP_KERNEL);
+                pdev->dev.platform_data = pdata;
+                if (!pdata)
+                        return NULL;
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-chipselect", &prop))
+                        pdev->id = prop;
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-mask-ale", &prop))
+                        pdata->mask_ale = prop;
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-mask-cle", &prop))
+                        pdata->mask_cle = prop;
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-mask-chipsel", &prop))
+                        pdata->mask_chipsel = prop;
+                if (!of_property_read_string(pdev->dev.of_node,
+                        "ti,davinci-ecc-mode", &mode)) {
+                        if (!strncmp("none", mode, 4))
+                                pdata->ecc_mode = NAND_ECC_NONE;
+                        if (!strncmp("soft", mode, 4))
+                                pdata->ecc_mode = NAND_ECC_SOFT;
+                        if (!strncmp("hw", mode, 2))
+                                pdata->ecc_mode = NAND_ECC_HW;
+                }
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-ecc-bits", &prop))
+                        pdata->ecc_bits = prop;
+                if (!of_property_read_u32(pdev->dev.of_node,
+                        "ti,davinci-nand-buswidth", &prop))
+                        if (prop == 16)
+                                pdata->options |= NAND_BUSWIDTH_16;
+                if (of_find_property(pdev->dev.of_node,
+                        "ti,davinci-nand-use-bbt", &len))
+                        pdata->bbt_options = NAND_BBT_USE_FLASH;
+        }
+
+        return pdev->dev.platform_data;
+}
+#else
+#define davinci_nand_of_match NULL
+static struct davinci_nand_pdata
+        *nand_davinci_get_pdata(struct platform_device *pdev)
+{
+        return pdev->dev.platform_data;
+}
+#endif
+
 static int __init nand_davinci_probe(struct platform_device *pdev)
 {
-        struct davinci_nand_pdata       *pdata = pdev->dev.platform_data;
+        struct davinci_nand_pdata       *pdata;
         struct davinci_nand_info        *info;
         struct resource                 *res1;
         struct resource                 *res2;
@@ -530,6 +597,7 @@ static int __init nand_davinci_probe(struct platform_device *pdev)
         uint32_t                        val;
         nand_ecc_modes_t                ecc_mode;
 
+        pdata = nand_davinci_get_pdata(pdev);
         /* insist on board-specific configuration */
         if (!pdata)
                 return -ENODEV;
@@ -656,7 +724,7 @@ static int __init nand_davinci_probe(struct platform_device *pdev)
                 goto err_clk;
         }
 
-        ret = clk_enable(info->clk);
+        ret = clk_prepare_enable(info->clk);
         if (ret < 0) {
                 dev_dbg(&pdev->dev, "unable to enable AEMIF clock, err %d\n",
                         ret);
@@ -767,7 +835,7 @@ syndrome_done:
 
 err_scan:
 err_timing:
-        clk_disable(info->clk);
+        clk_disable_unprepare(info->clk);
 
 err_clk_enable:
         clk_put(info->clk);
@@ -804,7 +872,7 @@ static int __exit nand_davinci_remove(struct platform_device *pdev)
 
         nand_release(&info->mtd);
 
-        clk_disable(info->clk);
+        clk_disable_unprepare(info->clk);
         clk_put(info->clk);
 
         kfree(info);
@@ -816,6 +884,8 @@ static struct platform_driver nand_davinci_driver = {
         .remove         = __exit_p(nand_davinci_remove),
         .driver         = {
                 .name   = "davinci_nand",
+                .owner  = THIS_MODULE,
+                .of_match_table = davinci_nand_of_match,
         },
 };
 MODULE_ALIAS("platform:davinci_nand");
diff --git a/drivers/mtd/nand/denali.c b/drivers/mtd/nand/denali.c
index 0650aafa0dd2..e706a237170f 100644
--- a/drivers/mtd/nand/denali.c
+++ b/drivers/mtd/nand/denali.c
@@ -1028,7 +1028,7 @@ static void denali_setup_dma(struct denali_nand_info *denali, int op)
 
 /* writes a page. user specifies type, and this function handles the
  * configuration details. */
-static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
+static int write_page(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, bool raw_xfer)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
@@ -1078,6 +1078,8 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
 
         denali_enable_dma(denali, false);
         dma_sync_single_for_cpu(denali->dev, addr, size, DMA_TO_DEVICE);
+
+        return 0;
 }
 
 /* NAND core entry points */
@@ -1086,24 +1088,24 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
  * writing a page with ECC or without is similar, all the work is done
  * by write_page above.
  * */
-static void denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
+static int denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                                 const uint8_t *buf, int oob_required)
 {
         /* for regular page writes, we let HW handle all the ECC
          * data written to the device. */
-        write_page(mtd, chip, buf, false);
+        return write_page(mtd, chip, buf, false);
 }
 
 /* This is the callback that the NAND core calls to write a page without ECC.
  * raw access is similar to ECC page writes, so all the work is done in the
  * write_page() function above.
  */
-static void denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
+static int denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                         const uint8_t *buf, int oob_required)
 {
         /* for raw page writes, we want to disable ECC and simply write
            whatever data is in the buffer. */
-        write_page(mtd, chip, buf, true);
+        return write_page(mtd, chip, buf, true);
 }
 
 static int denali_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index e2ca067631cf..256eb30f6180 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -376,19 +376,6 @@ static void doc2000_readbuf_dword(struct mtd_info *mtd, u_char *buf, int len)
         }
 }
 
-static int doc2000_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct nand_chip *this = mtd->priv;
-        struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
-        int i;
-
-        for (i = 0; i < len; i++)
-                if (buf[i] != ReadDOC(docptr, 2k_CDSN_IO))
-                        return -EFAULT;
-        return 0;
-}
-
 static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
 {
         struct nand_chip *this = mtd->priv;
@@ -526,26 +513,6 @@ static void doc2001_readbuf(struct mtd_info *mtd, u_char *buf, int len)
         buf[i] = ReadDOC(docptr, LastDataRead);
 }
 
-static int doc2001_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct nand_chip *this = mtd->priv;
-        struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
-        int i;
-
-        /* Start read pipeline */
-        ReadDOC(docptr, ReadPipeInit);
-
-        for (i = 0; i < len - 1; i++)
-                if (buf[i] != ReadDOC(docptr, Mil_CDSN_IO)) {
-                        ReadDOC(docptr, LastDataRead);
-                        return i;
-                }
-        if (buf[i] != ReadDOC(docptr, LastDataRead))
-                return i;
-        return 0;
-}
-
 static u_char doc2001plus_read_byte(struct mtd_info *mtd)
 {
         struct nand_chip *this = mtd->priv;
@@ -610,33 +577,6 @@ static void doc2001plus_readbuf(struct mtd_info *mtd, u_char *buf, int len)
                 printk("\n");
 }
 
-static int doc2001plus_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct nand_chip *this = mtd->priv;
-        struct doc_priv *doc = this->priv;
-        void __iomem *docptr = doc->virtadr;
-        int i;
-
-        if (debug)
-                printk("verifybuf of %d bytes: ", len);
-
-        /* Start read pipeline */
-        ReadDOC(docptr, Mplus_ReadPipeInit);
-        ReadDOC(docptr, Mplus_ReadPipeInit);
-
-        for (i = 0; i < len - 2; i++)
-                if (buf[i] != ReadDOC(docptr, Mil_CDSN_IO)) {
-                        ReadDOC(docptr, Mplus_LastDataRead);
-                        ReadDOC(docptr, Mplus_LastDataRead);
-                        return i;
-                }
-        if (buf[len - 2] != ReadDOC(docptr, Mplus_LastDataRead))
-                return len - 2;
-        if (buf[len - 1] != ReadDOC(docptr, Mplus_LastDataRead))
-                return len - 1;
-        return 0;
-}
-
 static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
 {
         struct nand_chip *this = mtd->priv;
@@ -1432,7 +1372,6 @@ static inline int __init doc2000_init(struct mtd_info *mtd)
         this->read_byte = doc2000_read_byte;
         this->write_buf = doc2000_writebuf;
         this->read_buf = doc2000_readbuf;
-        this->verify_buf = doc2000_verifybuf;
         this->scan_bbt = nftl_scan_bbt;
 
         doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
@@ -1449,7 +1388,6 @@ static inline int __init doc2001_init(struct mtd_info *mtd)
         this->read_byte = doc2001_read_byte;
         this->write_buf = doc2001_writebuf;
         this->read_buf = doc2001_readbuf;
-        this->verify_buf = doc2001_verifybuf;
 
         ReadDOC(doc->virtadr, ChipID);
         ReadDOC(doc->virtadr, ChipID);
@@ -1480,7 +1418,6 @@ static inline int __init doc2001plus_init(struct mtd_info *mtd)
         this->read_byte = doc2001plus_read_byte;
         this->write_buf = doc2001plus_writebuf;
         this->read_buf = doc2001plus_readbuf;
-        this->verify_buf = doc2001plus_verifybuf;
         this->scan_bbt = inftl_scan_bbt;
         this->cmd_ctrl = NULL;
         this->select_chip = doc2001plus_select_chip;
diff --git a/drivers/mtd/nand/docg4.c b/drivers/mtd/nand/docg4.c
index a225e49a5623..799da5d1c857 100644
--- a/drivers/mtd/nand/docg4.c
+++ b/drivers/mtd/nand/docg4.c
@@ -378,9 +378,9 @@ static int correct_data(struct mtd_info *mtd, uint8_t *buf, int page)
                  * bit flips(s) are not reported in stats.
                  */
 
-                if (doc->oob_buf[15]) {
+                if (nand->oob_poi[15]) {
                         int bit, numsetbits = 0;
-                        unsigned long written_flag = doc->oob_buf[15];
+                        unsigned long written_flag = nand->oob_poi[15];
                         for_each_set_bit(bit, &written_flag, 8)
                                 numsetbits++;
                         if (numsetbits > 4) { /* assume blank */
@@ -428,7 +428,7 @@ static int correct_data(struct mtd_info *mtd, uint8_t *buf, int page)
                 /* if error within oob area preceeding ecc bytes... */
                 if (errpos[i] > DOCG4_PAGE_SIZE * 8)
                         change_bit(errpos[i] - DOCG4_PAGE_SIZE * 8,
-                                   (unsigned long *)doc->oob_buf);
+                                   (unsigned long *)nand->oob_poi);
 
                 else    /* error in page data */
                         change_bit(errpos[i], (unsigned long *)buf);
@@ -748,18 +748,12 @@ static int read_page(struct mtd_info *mtd, struct nand_chip *nand,
 
         docg4_read_buf(mtd, buf, DOCG4_PAGE_SIZE); /* read the page data */
 
-        /*
-         * Diskonchips read oob immediately after a page read.  Mtd
-         * infrastructure issues a separate command for reading oob after the
-         * page is read.  So we save the oob bytes in a local buffer and just
-         * copy it if the next command reads oob from the same page.
-         */
-
+        /* this device always reads oob after page data */
         /* first 14 oob bytes read from I/O reg */
-        docg4_read_buf(mtd, doc->oob_buf, 14);
+        docg4_read_buf(mtd, nand->oob_poi, 14);
 
         /* last 2 read from another reg */
-        buf16 = (uint16_t *)(doc->oob_buf + 14);
+        buf16 = (uint16_t *)(nand->oob_poi + 14);
         *buf16 = readw(docptr + DOCG4_MYSTERY_REG);
 
         write_nop(docptr);
@@ -782,6 +776,8 @@ static int read_page(struct mtd_info *mtd, struct nand_chip *nand,
         }
 
         writew(0, docptr + DOC_DATAEND);
+        if (bits_corrected == -EBADMSG)   /* uncorrectable errors */
+                return 0;
         return bits_corrected;
 }
 
@@ -807,21 +803,6 @@ static int docg4_read_oob(struct mtd_info *mtd, struct nand_chip *nand,
 
         dev_dbg(doc->dev, "%s: page %x\n", __func__, page);
 
-        /*
-         * Oob bytes are read as part of a normal page read.  If the previous
-         * nand command was a read of the page whose oob is now being read, just
-         * copy the oob bytes that we saved in a local buffer and avoid a
-         * separate oob read.
-         */
-        if (doc->last_command.command == NAND_CMD_READ0 &&
-            doc->last_command.page == page) {
-                memcpy(nand->oob_poi, doc->oob_buf, 16);
-                return 0;
-        }
-
-        /*
-         * Separate read of oob data only.
-         */
         docg4_command(mtd, NAND_CMD_READ0, nand->ecc.size, page);
 
         writew(DOC_ECCCONF0_READ_MODE | DOCG4_OOB_SIZE, docptr + DOC_ECCCONF0);
@@ -898,7 +879,7 @@ static void docg4_erase_block(struct mtd_info *mtd, int page)
         write_nop(docptr);
 }
 
-static void write_page(struct mtd_info *mtd, struct nand_chip *nand,
+static int write_page(struct mtd_info *mtd, struct nand_chip *nand,
                        const uint8_t *buf, bool use_ecc)
 {
         struct docg4_priv *doc = nand->priv;
@@ -950,15 +931,17 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *nand,
         write_nop(docptr);
         writew(0, docptr + DOC_DATAEND);
         write_nop(docptr);
+
+        return 0;
 }
 
-static void docg4_write_page_raw(struct mtd_info *mtd, struct nand_chip *nand,
+static int docg4_write_page_raw(struct mtd_info *mtd, struct nand_chip *nand,
                                  const uint8_t *buf, int oob_required)
 {
         return write_page(mtd, nand, buf, false);
 }
 
-static void docg4_write_page(struct mtd_info *mtd, struct nand_chip *nand,
+static int docg4_write_page(struct mtd_info *mtd, struct nand_chip *nand,
                              const uint8_t *buf, int oob_required)
 {
         return write_page(mtd, nand, buf, true);
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 784293806110..cc1480a5e4c1 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -614,41 +614,6 @@ static void fsl_elbc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
                         len, avail);
 }
 
-/*
- * Verify buffer against the FCM Controller Data Buffer
- */
-static int fsl_elbc_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct nand_chip *chip = mtd->priv;
-        struct fsl_elbc_mtd *priv = chip->priv;
-        struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = priv->ctrl->nand;
-        int i;
-
-        if (len < 0) {
-                dev_err(priv->dev, "write_buf of %d bytes", len);
-                return -EINVAL;
-        }
-
-        if ((unsigned int)len >
-                        elbc_fcm_ctrl->read_bytes - elbc_fcm_ctrl->index) {
-                dev_err(priv->dev,
-                        "verify_buf beyond end of buffer "
-                        "(%d requested, %u available)\n",
-                        len, elbc_fcm_ctrl->read_bytes - elbc_fcm_ctrl->index);
-
-                elbc_fcm_ctrl->index = elbc_fcm_ctrl->read_bytes;
-                return -EINVAL;
-        }
-
-        for (i = 0; i < len; i++)
-                if (in_8(&elbc_fcm_ctrl->addr[elbc_fcm_ctrl->index + i])
-                                != buf[i])
-                        break;
-
-        elbc_fcm_ctrl->index += len;
-        return i == len && elbc_fcm_ctrl->status == LTESR_CC ? 0 : -EIO;
-}
-
 /* This function is called after Program and Erase Operations to
  * check for success or failure.
  */
@@ -766,11 +731,13 @@ static int fsl_elbc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
 /* ECC will be calculated automatically, and errors will be detected in
  * waitfunc.
  */
-static void fsl_elbc_write_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)
 {
         fsl_elbc_write_buf(mtd, buf, mtd->writesize);
         fsl_elbc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 static int fsl_elbc_chip_init(struct fsl_elbc_mtd *priv)
@@ -796,7 +763,6 @@ static int fsl_elbc_chip_init(struct fsl_elbc_mtd *priv)
         chip->read_byte = fsl_elbc_read_byte;
         chip->write_buf = fsl_elbc_write_buf;
         chip->read_buf = fsl_elbc_read_buf;
-        chip->verify_buf = fsl_elbc_verify_buf;
         chip->select_chip = fsl_elbc_select_chip;
         chip->cmdfunc = fsl_elbc_cmdfunc;
         chip->waitfunc = fsl_elbc_wait;
@@ -805,7 +771,6 @@ static int fsl_elbc_chip_init(struct fsl_elbc_mtd *priv)
         chip->bbt_md = &bbt_mirror_descr;
 
         /* set up nand options */
-        chip->options = NAND_NO_READRDY;
         chip->bbt_options = NAND_BBT_USE_FLASH;
 
         chip->controller = &elbc_fcm_ctrl->controller;
@@ -916,7 +881,8 @@ static int __devinit fsl_elbc_nand_probe(struct platform_device *pdev)
         elbc_fcm_ctrl->chips[bank] = priv;
         priv->bank = bank;
         priv->ctrl = fsl_lbc_ctrl_dev;
-        priv->dev = dev;
+        priv->dev = &pdev->dev;
+        dev_set_drvdata(priv->dev, priv);
 
         priv->vbase = ioremap(res.start, resource_size(&res));
         if (!priv->vbase) {
@@ -963,11 +929,10 @@ err:
 
 static int fsl_elbc_nand_remove(struct platform_device *pdev)
 {
-        int i;
         struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl = fsl_lbc_ctrl_dev->nand;
-        for (i = 0; i < MAX_BANKS; i++)
-                if (elbc_fcm_ctrl->chips[i])
-                        fsl_elbc_chip_remove(elbc_fcm_ctrl->chips[i]);
+        struct fsl_elbc_mtd *priv = dev_get_drvdata(&pdev->dev);
+
+        fsl_elbc_chip_remove(priv);
 
         mutex_lock(&fsl_elbc_nand_mutex);
         elbc_fcm_ctrl->counter--;
diff --git a/drivers/mtd/nand/fsl_ifc_nand.c b/drivers/mtd/nand/fsl_ifc_nand.c
index 01e2f2e87d8c..3551a99076ba 100644
--- a/drivers/mtd/nand/fsl_ifc_nand.c
+++ b/drivers/mtd/nand/fsl_ifc_nand.c
@@ -194,7 +194,7 @@ static int is_blank(struct mtd_info *mtd, unsigned int bufnum)
         struct nand_chip *chip = mtd->priv;
         struct fsl_ifc_mtd *priv = chip->priv;
         u8 __iomem *addr = priv->vbase + bufnum * (mtd->writesize * 2);
-        u32 __iomem *mainarea = (u32 *)addr;
+        u32 __iomem *mainarea = (u32 __iomem *)addr;
         u8 __iomem *oob = addr + mtd->writesize;
         int i;
 
@@ -592,8 +592,8 @@ static uint8_t fsl_ifc_read_byte16(struct mtd_info *mtd)
          * next byte.
          */
         if (ifc_nand_ctrl->index < ifc_nand_ctrl->read_bytes) {
-                data = in_be16((uint16_t *)&ifc_nand_ctrl->
-                                        addr[ifc_nand_ctrl->index]);
+                data = in_be16((uint16_t __iomem *)&ifc_nand_ctrl->
+                               addr[ifc_nand_ctrl->index]);
                 ifc_nand_ctrl->index += 2;
                 return (uint8_t) data;
         }
@@ -628,46 +628,6 @@ static void fsl_ifc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
 }
 
 /*
- * Verify buffer against the IFC Controller Data Buffer
- */
-static int fsl_ifc_verify_buf(struct mtd_info *mtd,
-                               const u_char *buf, int len)
-{
-        struct nand_chip *chip = mtd->priv;
-        struct fsl_ifc_mtd *priv = chip->priv;
-        struct fsl_ifc_ctrl *ctrl = priv->ctrl;
-        struct fsl_ifc_nand_ctrl *nctrl = ifc_nand_ctrl;
-        int i;
-
-        if (len < 0) {
-                dev_err(priv->dev, "%s: write_buf of %d bytes", __func__, len);
-                return -EINVAL;
-        }
-
-        if ((unsigned int)len > nctrl->read_bytes - nctrl->index) {
-                dev_err(priv->dev,
-                        "%s: beyond end of buffer (%d requested, %u available)\n",
-                        __func__, len, nctrl->read_bytes - nctrl->index);
-
-                nctrl->index = nctrl->read_bytes;
-                return -EINVAL;
-        }
-
-        for (i = 0; i < len; i++)
-                if (in_8(&nctrl->addr[nctrl->index + i]) != buf[i])
-                        break;
-
-        nctrl->index += len;
-
-        if (i != len)
-                return -EIO;
-        if (ctrl->nand_stat != IFC_NAND_EVTER_STAT_OPC)
-                return -EIO;
-
-        return 0;
-}
-
-/*
  * This function is called after Program and Erase Operations to
  * check for success or failure.
  */
@@ -722,11 +682,13 @@ static int fsl_ifc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
 /* ECC will be calculated automatically, and errors will be detected in
  * waitfunc.
  */
-static void fsl_ifc_write_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)
 {
         fsl_ifc_write_buf(mtd, buf, mtd->writesize);
         fsl_ifc_write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 static int fsl_ifc_chip_init_tail(struct mtd_info *mtd)
@@ -844,7 +806,6 @@ static int fsl_ifc_chip_init(struct fsl_ifc_mtd *priv)
 
         chip->write_buf = fsl_ifc_write_buf;
         chip->read_buf = fsl_ifc_read_buf;
-        chip->verify_buf = fsl_ifc_verify_buf;
         chip->select_chip = fsl_ifc_select_chip;
         chip->cmdfunc = fsl_ifc_cmdfunc;
         chip->waitfunc = fsl_ifc_wait;
@@ -855,7 +816,6 @@ static int fsl_ifc_chip_init(struct fsl_ifc_mtd *priv)
         out_be32(&ifc->ifc_nand.ncfgr, 0x0);
 
         /* set up nand options */
-        chip->options = NAND_NO_READRDY;
         chip->bbt_options = NAND_BBT_USE_FLASH;
 
 
diff --git a/drivers/mtd/nand/gpio.c b/drivers/mtd/nand/gpio.c
index 27000a5f5f47..bc73bc5f2713 100644
--- a/drivers/mtd/nand/gpio.c
+++ b/drivers/mtd/nand/gpio.c
@@ -100,23 +100,6 @@ static void gpio_nand_readbuf(struct mtd_info *mtd, u_char *buf, int len)
         readsb(this->IO_ADDR_R, buf, len);
 }
 
-static int gpio_nand_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct nand_chip *this = mtd->priv;
-        unsigned char read, *p = (unsigned char *) buf;
-        int i, err = 0;
-
-        for (i = 0; i < len; i++) {
-                read = readb(this->IO_ADDR_R);
-                if (read != p[i]) {
-                        pr_debug("%s: err at %d (read %04x vs %04x)\n",
-                               __func__, i, read, p[i]);
-                        err = -EFAULT;
-                }
-        }
-        return err;
-}
-
 static void gpio_nand_writebuf16(struct mtd_info *mtd, const u_char *buf,
                                  int len)
 {
@@ -148,26 +131,6 @@ static void gpio_nand_readbuf16(struct mtd_info *mtd, u_char *buf, int len)
         }
 }
 
-static int gpio_nand_verifybuf16(struct mtd_info *mtd, const u_char *buf,
-                                 int len)
-{
-        struct nand_chip *this = mtd->priv;
-        unsigned short read, *p = (unsigned short *) buf;
-        int i, err = 0;
-        len >>= 1;
-
-        for (i = 0; i < len; i++) {
-                read = readw(this->IO_ADDR_R);
-                if (read != p[i]) {
-                        pr_debug("%s: err at %d (read %04x vs %04x)\n",
-                               __func__, i, read, p[i]);
-                        err = -EFAULT;
-                }
-        }
-        return err;
-}
-
-
 static int gpio_nand_devready(struct mtd_info *mtd)
 {
         struct gpiomtd *gpiomtd = gpio_nand_getpriv(mtd);
@@ -391,11 +354,9 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
         if (this->options & NAND_BUSWIDTH_16) {
                 this->read_buf   = gpio_nand_readbuf16;
                 this->write_buf  = gpio_nand_writebuf16;
-                this->verify_buf = gpio_nand_verifybuf16;
         } else {
                 this->read_buf   = gpio_nand_readbuf;
                 this->write_buf  = gpio_nand_writebuf;
-                this->verify_buf = gpio_nand_verifybuf;
         }
 
         /* set the mtd private data for the nand driver */
@@ -456,20 +417,7 @@ static struct platform_driver gpio_nand_driver = {
         },
 };
 
-static int __init gpio_nand_init(void)
-{
-        printk(KERN_INFO "GPIO NAND driver, © 2004 Simtec Electronics\n");
-
-        return platform_driver_register(&gpio_nand_driver);
-}
-
-static void __exit gpio_nand_exit(void)
-{
-        platform_driver_unregister(&gpio_nand_driver);
-}
-
-module_init(gpio_nand_init);
-module_exit(gpio_nand_exit);
+module_platform_driver(gpio_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-lib.c b/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
index a1f43329ad43..3502accd4bc3 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-lib.c
@@ -26,7 +26,7 @@
 #include "gpmi-regs.h"
 #include "bch-regs.h"
 
-struct timing_threshod timing_default_threshold = {
+static struct timing_threshod timing_default_threshold = {
         .max_data_setup_cycles       = (BM_GPMI_TIMING0_DATA_SETUP >>
                                                 BP_GPMI_TIMING0_DATA_SETUP),
         .internal_data_setup_in_ns   = 0,
@@ -124,12 +124,42 @@ error:
         return -ETIMEDOUT;
 }
 
+static int __gpmi_enable_clk(struct gpmi_nand_data *this, bool v)
+{
+        struct clk *clk;
+        int ret;
+        int i;
+
+        for (i = 0; i < GPMI_CLK_MAX; i++) {
+                clk = this->resources.clock[i];
+                if (!clk)
+                        break;
+
+                if (v) {
+                        ret = clk_prepare_enable(clk);
+                        if (ret)
+                                goto err_clk;
+                } else {
+                        clk_disable_unprepare(clk);
+                }
+        }
+        return 0;
+
+err_clk:
+        for (; i > 0; i--)
+                clk_disable_unprepare(this->resources.clock[i - 1]);
+        return ret;
+}
+
+#define gpmi_enable_clk(x) __gpmi_enable_clk(x, true)
+#define gpmi_disable_clk(x) __gpmi_enable_clk(x, false)
+
 int gpmi_init(struct gpmi_nand_data *this)
 {
         struct resources *r = &this->resources;
         int ret;
 
-        ret = clk_prepare_enable(r->clock);
+        ret = gpmi_enable_clk(this);
         if (ret)
                 goto err_out;
         ret = gpmi_reset_block(r->gpmi_regs, false);
@@ -149,7 +179,7 @@ int gpmi_init(struct gpmi_nand_data *this)
         /* Select BCH ECC. */
         writel(BM_GPMI_CTRL1_BCH_MODE, r->gpmi_regs + HW_GPMI_CTRL1_SET);
 
-        clk_disable_unprepare(r->clock);
+        gpmi_disable_clk(this);
         return 0;
 err_out:
         return ret;
@@ -205,7 +235,7 @@ int bch_set_geometry(struct gpmi_nand_data *this)
         ecc_strength  = bch_geo->ecc_strength >> 1;
         page_size     = bch_geo->page_size;
 
-        ret = clk_prepare_enable(r->clock);
+        ret = gpmi_enable_clk(this);
         if (ret)
                 goto err_out;
 
@@ -240,7 +270,7 @@ int bch_set_geometry(struct gpmi_nand_data *this)
         writel(BM_BCH_CTRL_COMPLETE_IRQ_EN,
                                 r->bch_regs + HW_BCH_CTRL_SET);
 
-        clk_disable_unprepare(r->clock);
+        gpmi_disable_clk(this);
         return 0;
 err_out:
         return ret;
@@ -263,6 +293,7 @@ static int gpmi_nfc_compute_hardware_timing(struct gpmi_nand_data *this,
                                         struct gpmi_nfc_hardware_timing *hw)
 {
         struct timing_threshod *nfc = &timing_default_threshold;
+        struct resources *r = &this->resources;
         struct nand_chip *nand = &this->nand;
         struct nand_timing target = this->timing;
         bool improved_timing_is_available;
@@ -302,8 +333,9 @@ static int gpmi_nfc_compute_hardware_timing(struct gpmi_nand_data *this,
                 (target.tRHOH_in_ns >= 0) ;
 
         /* Inspect the clock. */
+        nfc->clock_frequency_in_hz = clk_get_rate(r->clock[0]);
         clock_frequency_in_hz = nfc->clock_frequency_in_hz;
-        clock_period_in_ns    = 1000000000 / clock_frequency_in_hz;
+        clock_period_in_ns    = NSEC_PER_SEC / clock_frequency_in_hz;
 
         /*
          * The NFC quantizes setup and hold parameters in terms of clock cycles.
@@ -698,17 +730,230 @@ return_results:
         hw->address_setup_in_cycles = address_setup_in_cycles;
         hw->use_half_periods        = dll_use_half_periods;
         hw->sample_delay_factor     = sample_delay_factor;
+        hw->device_busy_timeout     = GPMI_DEFAULT_BUSY_TIMEOUT;
+        hw->wrn_dly_sel             = BV_GPMI_CTRL1_WRN_DLY_SEL_4_TO_8NS;
 
         /* Return success. */
         return 0;
 }
 
+/*
+ * <1> Firstly, we should know what's the GPMI-clock means.
+ *     The GPMI-clock is the internal clock in the gpmi nand controller.
+ *     If you set 100MHz to gpmi nand controller, the GPMI-clock's period
+ *     is 10ns. Mark the GPMI-clock's period as GPMI-clock-period.
+ *
+ * <2> Secondly, we should know what's the frequency on the nand chip pins.
+ *     The frequency on the nand chip pins is derived from the GPMI-clock.
+ *     We can get it from the following equation:
+ *
+ *         F = G / (DS + DH)
+ *
+ *         F  : the frequency on the nand chip pins.
+ *         G  : the GPMI clock, such as 100MHz.
+ *         DS : GPMI_HW_GPMI_TIMING0:DATA_SETUP
+ *         DH : GPMI_HW_GPMI_TIMING0:DATA_HOLD
+ *
+ * <3> Thirdly, when the frequency on the nand chip pins is above 33MHz,
+ *     the nand EDO(extended Data Out) timing could be applied.
+ *     The GPMI implements a feedback read strobe to sample the read data.
+ *     The feedback read strobe can be delayed to support the nand EDO timing
+ *     where the read strobe may deasserts before the read data is valid, and
+ *     read data is valid for some time after read strobe.
+ *
+ *     The following figure illustrates some aspects of a NAND Flash read:
+ *
+ *                   |<---tREA---->|
+ *                   |             |
+ *                   |         |   |
+ *                   |<--tRP-->|   |
+ *                   |         |   |
+ *                  __          ___|__________________________________
+ *     RDN            \________/   |
+ *                                 |
+ *                                 /---------\
+ *     Read Data    --------------<           >---------
+ *                                 \---------/
+ *                                |     |
+ *                                |<-D->|
+ *     FeedbackRDN  ________             ____________
+ *                          \___________/
+ *
+ *          D stands for delay, set in the HW_GPMI_CTRL1:RDN_DELAY.
+ *
+ *
+ * <4> Now, we begin to describe how to compute the right RDN_DELAY.
+ *
+ *  4.1) From the aspect of the nand chip pins:
+ *        Delay = (tREA + C - tRP)               {1}
+ *
+ *        tREA : the maximum read access time. From the ONFI nand standards,
+ *               we know that tREA is 16ns in mode 5, tREA is 20ns is mode 4.
+ *               Please check it in : www.onfi.org
+ *        C    : a constant for adjust the delay. default is 4.
+ *        tRP  : the read pulse width.
+ *               Specified by the HW_GPMI_TIMING0:DATA_SETUP:
+ *                    tRP = (GPMI-clock-period) * DATA_SETUP
+ *
+ *  4.2) From the aspect of the GPMI nand controller:
+ *         Delay = RDN_DELAY * 0.125 * RP        {2}
+ *
+ *         RP   : the DLL reference period.
+ *            if (GPMI-clock-period > DLL_THRETHOLD)
+ *                   RP = GPMI-clock-period / 2;
+ *            else
+ *                   RP = GPMI-clock-period;
+ *
+ *            Set the HW_GPMI_CTRL1:HALF_PERIOD if GPMI-clock-period
+ *            is greater DLL_THRETHOLD. In other SOCs, the DLL_THRETHOLD
+ *            is 16ns, but in mx6q, we use 12ns.
+ *
+ *  4.3) since {1} equals {2}, we get:
+ *
+ *                    (tREA + 4 - tRP) * 8
+ *         RDN_DELAY = ---------------------     {3}
+ *                           RP
+ *
+ *  4.4) We only support the fastest asynchronous mode of ONFI nand.
+ *       For some ONFI nand, the mode 4 is the fastest mode;
+ *       while for some ONFI nand, the mode 5 is the fastest mode.
+ *       So we only support the mode 4 and mode 5. It is no need to
+ *       support other modes.
+ */
+static void gpmi_compute_edo_timing(struct gpmi_nand_data *this,
+                        struct gpmi_nfc_hardware_timing *hw)
+{
+        struct resources *r = &this->resources;
+        unsigned long rate = clk_get_rate(r->clock[0]);
+        int mode = this->timing_mode;
+        int dll_threshold = 16; /* in ns */
+        unsigned long delay;
+        unsigned long clk_period;
+        int t_rea;
+        int c = 4;
+        int t_rp;
+        int rp;
+
+        /*
+         * [1] for GPMI_HW_GPMI_TIMING0:
+         *     The async mode requires 40MHz for mode 4, 50MHz for mode 5.
+         *     The GPMI can support 100MHz at most. So if we want to
+         *     get the 40MHz or 50MHz, we have to set DS=1, DH=1.
+         *     Set the ADDRESS_SETUP to 0 in mode 4.
+         */
+        hw->data_setup_in_cycles = 1;
+        hw->data_hold_in_cycles = 1;
+        hw->address_setup_in_cycles = ((mode == 5) ? 1 : 0);
+
+        /* [2] for GPMI_HW_GPMI_TIMING1 */
+        hw->device_busy_timeout = 0x9000;
+
+        /* [3] for GPMI_HW_GPMI_CTRL1 */
+        hw->wrn_dly_sel = BV_GPMI_CTRL1_WRN_DLY_SEL_NO_DELAY;
+
+        if (GPMI_IS_MX6Q(this))
+                dll_threshold = 12;
+
+        /*
+         * Enlarge 10 times for the numerator and denominator in {3}.
+         * This make us to get more accurate result.
+         */
+        clk_period = NSEC_PER_SEC / (rate / 10);
+        dll_threshold *= 10;
+        t_rea = ((mode == 5) ? 16 : 20) * 10;
+        c *= 10;
+
+        t_rp = clk_period * 1; /* DATA_SETUP is 1 */
+
+        if (clk_period > dll_threshold) {
+                hw->use_half_periods = 1;
+                rp = clk_period / 2;
+        } else {
+                hw->use_half_periods = 0;
+                rp = clk_period;
+        }
+
+        /*
+         * Multiply the numerator with 10, we could do a round off:
+         *      7.8 round up to 8; 7.4 round down to 7.
+         */
+        delay  = (((t_rea + c - t_rp) * 8) * 10) / rp;
+        delay = (delay + 5) / 10;
+
+        hw->sample_delay_factor = delay;
+}
+
+static int enable_edo_mode(struct gpmi_nand_data *this, int mode)
+{
+        struct resources  *r = &this->resources;
+        struct nand_chip *nand = &this->nand;
+        struct mtd_info  *mtd = &this->mtd;
+        uint8_t feature[ONFI_SUBFEATURE_PARAM_LEN] = {};
+        unsigned long rate;
+        int ret;
+
+        nand->select_chip(mtd, 0);
+
+        /* [1] send SET FEATURE commond to NAND */
+        feature[0] = mode;
+        ret = nand->onfi_set_features(mtd, nand,
+                                ONFI_FEATURE_ADDR_TIMING_MODE, feature);
+        if (ret)
+                goto err_out;
+
+        /* [2] send GET FEATURE command to double-check the timing mode */
+        memset(feature, 0, ONFI_SUBFEATURE_PARAM_LEN);
+        ret = nand->onfi_get_features(mtd, nand,
+                                ONFI_FEATURE_ADDR_TIMING_MODE, feature);
+        if (ret || feature[0] != mode)
+                goto err_out;
+
+        nand->select_chip(mtd, -1);
+
+        /* [3] set the main IO clock, 100MHz for mode 5, 80MHz for mode 4. */
+        rate = (mode == 5) ? 100000000 : 80000000;
+        clk_set_rate(r->clock[0], rate);
+
+        /* Let the gpmi_begin() re-compute the timing again. */
+        this->flags &= ~GPMI_TIMING_INIT_OK;
+
+        this->flags |= GPMI_ASYNC_EDO_ENABLED;
+        this->timing_mode = mode;
+        dev_info(this->dev, "enable the asynchronous EDO mode %d\n", mode);
+        return 0;
+
+err_out:
+        nand->select_chip(mtd, -1);
+        dev_err(this->dev, "mode:%d ,failed in set feature.\n", mode);
+        return -EINVAL;
+}
+
+int gpmi_extra_init(struct gpmi_nand_data *this)
+{
+        struct nand_chip *chip = &this->nand;
+
+        /* Enable the asynchronous EDO feature. */
+        if (GPMI_IS_MX6Q(this) && chip->onfi_version) {
+                int mode = onfi_get_async_timing_mode(chip);
+
+                /* We only support the timing mode 4 and mode 5. */
+                if (mode & ONFI_TIMING_MODE_5)
+                        mode = 5;
+                else if (mode & ONFI_TIMING_MODE_4)
+                        mode = 4;
+                else
+                        return 0;
+
+                return enable_edo_mode(this, mode);
+        }
+        return 0;
+}
+
 /* Begin the I/O */
 void gpmi_begin(struct gpmi_nand_data *this)
 {
         struct resources *r = &this->resources;
-        struct timing_threshod *nfc = &timing_default_threshold;
-        unsigned char  *gpmi_regs = r->gpmi_regs;
+        void __iomem *gpmi_regs = r->gpmi_regs;
         unsigned int   clock_period_in_ns;
         uint32_t       reg;
         unsigned int   dll_wait_time_in_us;
@@ -716,60 +961,66 @@ void gpmi_begin(struct gpmi_nand_data *this)
         int ret;
 
         /* Enable the clock. */
-        ret = clk_prepare_enable(r->clock);
+        ret = gpmi_enable_clk(this);
         if (ret) {
                 pr_err("We failed in enable the clk\n");
                 goto err_out;
         }
 
-        /* set ready/busy timeout */
-        writel(0x500 << BP_GPMI_TIMING1_BUSY_TIMEOUT,
-                gpmi_regs + HW_GPMI_TIMING1);
-
-        /* Get the timing information we need. */
-        nfc->clock_frequency_in_hz = clk_get_rate(r->clock);
-        clock_period_in_ns = 1000000000 / nfc->clock_frequency_in_hz;
+        /* Only initialize the timing once */
+        if (this->flags & GPMI_TIMING_INIT_OK)
+                return;
+        this->flags |= GPMI_TIMING_INIT_OK;
 
-        gpmi_nfc_compute_hardware_timing(this, &hw);
+        if (this->flags & GPMI_ASYNC_EDO_ENABLED)
+                gpmi_compute_edo_timing(this, &hw);
+        else
+                gpmi_nfc_compute_hardware_timing(this, &hw);
 
-        /* Set up all the simple timing parameters. */
+        /* [1] Set HW_GPMI_TIMING0 */
         reg = BF_GPMI_TIMING0_ADDRESS_SETUP(hw.address_setup_in_cycles) |
                 BF_GPMI_TIMING0_DATA_HOLD(hw.data_hold_in_cycles)         |
                 BF_GPMI_TIMING0_DATA_SETUP(hw.data_setup_in_cycles)       ;
 
         writel(reg, gpmi_regs + HW_GPMI_TIMING0);
 
-        /*
-         * DLL_ENABLE must be set to 0 when setting RDN_DELAY or HALF_PERIOD.
-         */
+        /* [2] Set HW_GPMI_TIMING1 */
+        writel(BF_GPMI_TIMING1_BUSY_TIMEOUT(hw.device_busy_timeout),
+                gpmi_regs + HW_GPMI_TIMING1);
+
+        /* [3] The following code is to set the HW_GPMI_CTRL1. */
+
+        /* Set the WRN_DLY_SEL */
+        writel(BM_GPMI_CTRL1_WRN_DLY_SEL, gpmi_regs + HW_GPMI_CTRL1_CLR);
+        writel(BF_GPMI_CTRL1_WRN_DLY_SEL(hw.wrn_dly_sel),
+                                        gpmi_regs + HW_GPMI_CTRL1_SET);
+
+        /* DLL_ENABLE must be set to 0 when setting RDN_DELAY or HALF_PERIOD. */
         writel(BM_GPMI_CTRL1_DLL_ENABLE, gpmi_regs + HW_GPMI_CTRL1_CLR);
 
         /* Clear out the DLL control fields. */
-        writel(BM_GPMI_CTRL1_RDN_DELAY,   gpmi_regs + HW_GPMI_CTRL1_CLR);
-        writel(BM_GPMI_CTRL1_HALF_PERIOD, gpmi_regs + HW_GPMI_CTRL1_CLR);
+        reg = BM_GPMI_CTRL1_RDN_DELAY | BM_GPMI_CTRL1_HALF_PERIOD;
+        writel(reg, gpmi_regs + HW_GPMI_CTRL1_CLR);
 
         /* If no sample delay is called for, return immediately. */
         if (!hw.sample_delay_factor)
                 return;
 
-        /* Configure the HALF_PERIOD flag. */
-        if (hw.use_half_periods)
-                writel(BM_GPMI_CTRL1_HALF_PERIOD,
-                                                gpmi_regs + HW_GPMI_CTRL1_SET);
+        /* Set RDN_DELAY or HALF_PERIOD. */
+        reg = ((hw.use_half_periods) ? BM_GPMI_CTRL1_HALF_PERIOD : 0)
+                | BF_GPMI_CTRL1_RDN_DELAY(hw.sample_delay_factor);
 
-        /* Set the delay factor. */
-        writel(BF_GPMI_CTRL1_RDN_DELAY(hw.sample_delay_factor),
-                                                gpmi_regs + HW_GPMI_CTRL1_SET);
+        writel(reg, gpmi_regs + HW_GPMI_CTRL1_SET);
 
-        /* Enable the DLL. */
+        /* At last, we enable the DLL. */
         writel(BM_GPMI_CTRL1_DLL_ENABLE, gpmi_regs + HW_GPMI_CTRL1_SET);
 
         /*
          * After we enable the GPMI DLL, we have to wait 64 clock cycles before
-         * we can use the GPMI.
-         *
-         * Calculate the amount of time we need to wait, in microseconds.
+         * we can use the GPMI. Calculate the amount of time we need to wait,
+         * in microseconds.
          */
+        clock_period_in_ns = NSEC_PER_SEC / clk_get_rate(r->clock[0]);
         dll_wait_time_in_us = (clock_period_in_ns * 64) / 1000;
 
         if (!dll_wait_time_in_us)
@@ -784,8 +1035,7 @@ err_out:
 
 void gpmi_end(struct gpmi_nand_data *this)
 {
-        struct resources *r = &this->resources;
-        clk_disable_unprepare(r->clock);
+        gpmi_disable_clk(this);
 }
 
 /* Clears a BCH interrupt. */
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
index a6cad5caba78..d79696b2f19b 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -18,6 +18,9 @@
  * with this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/clk.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
@@ -27,6 +30,7 @@
 #include <linux/pinctrl/consumer.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/of_mtd.h>
 #include "gpmi-nand.h"
 
 /* add our owner bbt descriptor */
@@ -113,7 +117,7 @@ int common_nfc_set_geometry(struct gpmi_nand_data *this)
         /* We use the same ECC strength for all chunks. */
         geo->ecc_strength = get_ecc_strength(this);
         if (!geo->ecc_strength) {
-                pr_err("We get a wrong ECC strength.\n");
+                pr_err("wrong ECC strength.\n");
                 return -EINVAL;
         }
 
@@ -316,7 +320,7 @@ acquire_register_block(struct gpmi_nand_data *this, const char *res_name)
         struct platform_device *pdev = this->pdev;
         struct resources *res = &this->resources;
         struct resource *r;
-        void *p;
+        void __iomem *p;
 
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, res_name);
         if (!r) {
@@ -423,8 +427,8 @@ static int __devinit acquire_dma_channels(struct gpmi_nand_data *this)
         struct platform_device *pdev = this->pdev;
         struct resource *r_dma;
         struct device_node *dn;
-        int dma_channel;
-        unsigned int ret;
+        u32 dma_channel;
+        int ret;
         struct dma_chan *dma_chan;
         dma_cap_mask_t mask;
 
@@ -464,9 +468,73 @@ acquire_err:
         return -EINVAL;
 }
 
+static void gpmi_put_clks(struct gpmi_nand_data *this)
+{
+        struct resources *r = &this->resources;
+        struct clk *clk;
+        int i;
+
+        for (i = 0; i < GPMI_CLK_MAX; i++) {
+                clk = r->clock[i];
+                if (clk) {
+                        clk_put(clk);
+                        r->clock[i] = NULL;
+                }
+        }
+}
+
+static char *extra_clks_for_mx6q[GPMI_CLK_MAX] = {
+        "gpmi_apb", "gpmi_bch", "gpmi_bch_apb", "per1_bch",
+};
+
+static int __devinit gpmi_get_clks(struct gpmi_nand_data *this)
+{
+        struct resources *r = &this->resources;
+        char **extra_clks = NULL;
+        struct clk *clk;
+        int i;
+
+        /* The main clock is stored in the first. */
+        r->clock[0] = clk_get(this->dev, "gpmi_io");
+        if (IS_ERR(r->clock[0]))
+                goto err_clock;
+
+        /* Get extra clocks */
+        if (GPMI_IS_MX6Q(this))
+                extra_clks = extra_clks_for_mx6q;
+        if (!extra_clks)
+                return 0;
+
+        for (i = 1; i < GPMI_CLK_MAX; i++) {
+                if (extra_clks[i - 1] == NULL)
+                        break;
+
+                clk = clk_get(this->dev, extra_clks[i - 1]);
+                if (IS_ERR(clk))
+                        goto err_clock;
+
+                r->clock[i] = clk;
+        }
+
+        if (GPMI_IS_MX6Q(this))
+                /*
+                 * Set the default value for the gpmi clock in mx6q:
+                 *
+                 * If you want to use the ONFI nand which is in the
+                 * Synchronous Mode, you should change the clock as you need.
+                 */
+                clk_set_rate(r->clock[0], 22000000);
+
+        return 0;
+
+err_clock:
+        dev_dbg(this->dev, "failed in finding the clocks.\n");
+        gpmi_put_clks(this);
+        return -ENOMEM;
+}
+
 static int __devinit acquire_resources(struct gpmi_nand_data *this)
 {
-        struct resources *res = &this->resources;
         struct pinctrl *pinctrl;
         int ret;
 
@@ -492,12 +560,9 @@ static int __devinit acquire_resources(struct gpmi_nand_data *this)
                 goto exit_pin;
         }
 
-        res->clock = clk_get(&this->pdev->dev, NULL);
-        if (IS_ERR(res->clock)) {
-                pr_err("can not get the clock\n");
-                ret = -ENOENT;
+        ret = gpmi_get_clks(this);
+        if (ret)
                 goto exit_clock;
-        }
         return 0;
 
 exit_clock:
@@ -512,9 +577,7 @@ exit_regs:
 
 static void release_resources(struct gpmi_nand_data *this)
 {
-        struct resources *r = &this->resources;
-
-        clk_put(r->clock);
+        gpmi_put_clks(this);
         release_register_block(this);
         release_bch_irq(this);
         release_dma_channels(this);
@@ -667,12 +730,12 @@ static int gpmi_alloc_dma_buffer(struct gpmi_nand_data *this)
         struct device *dev = this->dev;
 
         /* [1] Allocate a command buffer. PAGE_SIZE is enough. */
-        this->cmd_buffer = kzalloc(PAGE_SIZE, GFP_DMA);
+        this->cmd_buffer = kzalloc(PAGE_SIZE, GFP_DMA | GFP_KERNEL);
         if (this->cmd_buffer == NULL)
                 goto error_alloc;
 
         /* [2] Allocate a read/write data buffer. PAGE_SIZE is enough. */
-        this->data_buffer_dma = kzalloc(PAGE_SIZE, GFP_DMA);
+        this->data_buffer_dma = kzalloc(PAGE_SIZE, GFP_DMA | GFP_KERNEL);
         if (this->data_buffer_dma == NULL)
                 goto error_alloc;
 
@@ -930,7 +993,7 @@ exit_nfc:
         return ret;
 }
 
-static void gpmi_ecc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
+static int gpmi_ecc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                                 const uint8_t *buf, int oob_required)
 {
         struct gpmi_nand_data *this = chip->priv;
@@ -972,7 +1035,7 @@ static void gpmi_ecc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                                 &payload_virt, &payload_phys);
                 if (ret) {
                         pr_err("Inadequate payload DMA buffer\n");
-                        return;
+                        return 0;
                 }
 
                 ret = send_page_prepare(this,
@@ -1002,6 +1065,8 @@ exit_auxiliary:
                                 nfc_geo->payload_size,
                                 payload_virt, payload_phys);
         }
+
+        return 0;
 }
 
 /*
@@ -1064,6 +1129,9 @@ exit_auxiliary:
  * ECC-based or raw view of the page is implicit in which function it calls
  * (there is a similar pair of ECC-based/raw functions for writing).
  *
+ * FIXME: The following paragraph is incorrect, now that there exist
+ * ecc.read_oob_raw and ecc.write_oob_raw functions.
+ *
  * Since MTD assumes the OOB is not covered by ECC, there is no pair of
  * ECC-based/raw functions for reading or or writing the OOB. The fact that the
  * caller wants an ECC-based or raw view of the page is not propagated down to
@@ -1190,7 +1258,6 @@ static int mx23_check_transcription_stamp(struct gpmi_nand_data *this)
         unsigned int search_area_size_in_strides;
         unsigned int stride;
         unsigned int page;
-        loff_t byte;
         uint8_t *buffer = chip->buffers->databuf;
         int saved_chip_number;
         int found_an_ncb_fingerprint = false;
@@ -1207,9 +1274,8 @@ static int mx23_check_transcription_stamp(struct gpmi_nand_data *this)
         dev_dbg(dev, "Scanning for an NCB fingerprint...\n");
 
         for (stride = 0; stride < search_area_size_in_strides; stride++) {
-                /* Compute the page and byte addresses. */
+                /* Compute the page addresses. */
                 page = stride * rom_geo->stride_size_in_pages;
-                byte = page   * mtd->writesize;
 
                 dev_dbg(dev, "Looking for a fingerprint in page 0x%x\n", page);
 
@@ -1251,7 +1317,6 @@ static int mx23_write_transcription_stamp(struct gpmi_nand_data *this)
         unsigned int block;
         unsigned int stride;
         unsigned int page;
-        loff_t       byte;
         uint8_t      *buffer = chip->buffers->databuf;
         int saved_chip_number;
         int status;
@@ -1300,9 +1365,8 @@ static int mx23_write_transcription_stamp(struct gpmi_nand_data *this)
         /* Loop through the first search area, writing NCB fingerprints. */
         dev_dbg(dev, "Writing NCB fingerprints...\n");
         for (stride = 0; stride < search_area_size_in_strides; stride++) {
-                /* Compute the page and byte addresses. */
+                /* Compute the page addresses. */
                 page = stride * rom_geo->stride_size_in_pages;
-                byte = page   * mtd->writesize;
 
                 /* Write the first page of the current stride. */
                 dev_dbg(dev, "Writing an NCB fingerprint in page 0x%x\n", page);
@@ -1436,6 +1500,7 @@ static int gpmi_pre_bbt_scan(struct gpmi_nand_data  *this)
         /* Adjust the ECC strength according to the chip. */
         this->nand.ecc.strength = this->bch_geometry.ecc_strength;
         this->mtd.ecc_strength = this->bch_geometry.ecc_strength;
+        this->mtd.bitflip_threshold = this->bch_geometry.ecc_strength;
 
         /* NAND boot init, depends on the gpmi_set_geometry(). */
         return nand_boot_init(this);
@@ -1452,11 +1517,19 @@ static int gpmi_scan_bbt(struct mtd_info *mtd)
         if (ret)
                 return ret;
 
+        /*
+         * Can we enable the extra features? such as EDO or Sync mode.
+         *
+         * We do not check the return value now. That's means if we fail in
+         * enable the extra features, we still can run in the normal way.
+         */
+        gpmi_extra_init(this);
+
         /* use the default BBT implementation */
         return nand_default_bbt(mtd);
 }
 
-void gpmi_nfc_exit(struct gpmi_nand_data *this)
+static void gpmi_nfc_exit(struct gpmi_nand_data *this)
 {
         nand_release(&this->mtd);
         gpmi_free_dma_buffer(this);
@@ -1497,6 +1570,8 @@ static int __devinit gpmi_nfc_init(struct gpmi_nand_data *this)
         chip->ecc.size          = 1;
         chip->ecc.strength      = 8;
         chip->ecc.layout        = &gpmi_hw_ecclayout;
+        if (of_get_nand_on_flash_bbt(this->dev->of_node))
+                chip->bbt_options |= NAND_BBT_USE_FLASH | NAND_BBT_NO_OOB;
 
         /* Allocate a temporary DMA buffer for reading ID in the nand_scan() */
         this->bch_geometry.payload_size = 1024;
@@ -1579,6 +1654,8 @@ static int __devinit gpmi_nand_probe(struct platform_device *pdev)
         if (ret)
                 goto exit_nfc_init;
 
+        dev_info(this->dev, "driver registered.\n");
+
         return 0;
 
 exit_nfc_init:
@@ -1586,10 +1663,12 @@ exit_nfc_init:
 exit_acquire_resources:
         platform_set_drvdata(pdev, NULL);
         kfree(this);
+        dev_err(this->dev, "driver registration failed: %d\n", ret);
+
         return ret;
 }
 
-static int __exit gpmi_nand_remove(struct platform_device *pdev)
+static int __devexit gpmi_nand_remove(struct platform_device *pdev)
 {
         struct gpmi_nand_data *this = platform_get_drvdata(pdev);
 
@@ -1606,29 +1685,10 @@ static struct platform_driver gpmi_nand_driver = {
                 .of_match_table = gpmi_nand_id_table,
         },
         .probe   = gpmi_nand_probe,
-        .remove  = __exit_p(gpmi_nand_remove),
+        .remove  = __devexit_p(gpmi_nand_remove),
         .id_table = gpmi_ids,
 };
-
-static int __init gpmi_nand_init(void)
-{
-        int err;
-
-        err = platform_driver_register(&gpmi_nand_driver);
-        if (err == 0)
-                printk(KERN_INFO "GPMI NAND driver registered. (IMX)\n");
-        else
-                pr_err("i.MX GPMI NAND driver registration failed\n");
-        return err;
-}
-
-static void __exit gpmi_nand_exit(void)
-{
-        platform_driver_unregister(&gpmi_nand_driver);
-}
-
-module_init(gpmi_nand_init);
-module_exit(gpmi_nand_exit);
+module_platform_driver(gpmi_nand_driver);
 
 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_DESCRIPTION("i.MX GPMI NAND Flash Controller Driver");
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
index ce5daa160920..7ac25c1e58f9 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.h
@@ -22,14 +22,15 @@
 #include <linux/dma-mapping.h>
 #include <linux/fsl/mxs-dma.h>
 
+#define GPMI_CLK_MAX 5 /* MX6Q needs five clocks */
 struct resources {
-        void          *gpmi_regs;
-        void          *bch_regs;
+        void __iomem  *gpmi_regs;
+        void __iomem  *bch_regs;
         unsigned int  bch_low_interrupt;
         unsigned int  bch_high_interrupt;
         unsigned int  dma_low_channel;
         unsigned int  dma_high_channel;
-        struct clk    *clock;
+        struct clk    *clock[GPMI_CLK_MAX];
 };
 
 /**
@@ -121,6 +122,11 @@ struct nand_timing {
 };
 
 struct gpmi_nand_data {
+        /* flags */
+#define GPMI_ASYNC_EDO_ENABLED  (1 << 0)
+#define GPMI_TIMING_INIT_OK     (1 << 1)
+        int                     flags;
+
         /* System Interface */
         struct device           *dev;
         struct platform_device  *pdev;
@@ -131,6 +137,7 @@ struct gpmi_nand_data {
 
         /* Flash Hardware */
         struct nand_timing      timing;
+        int                     timing_mode;
 
         /* BCH */
         struct bch_geometry     bch_geometry;
@@ -188,16 +195,28 @@ struct gpmi_nand_data {
  * @data_setup_in_cycles:      The data setup time, in cycles.
  * @data_hold_in_cycles:       The data hold time, in cycles.
  * @address_setup_in_cycles:   The address setup time, in cycles.
+ * @device_busy_timeout:       The timeout waiting for NAND Ready/Busy,
+ *                             this value is the number of cycles multiplied
+ *                             by 4096.
  * @use_half_periods:          Indicates the clock is running slowly, so the
  *                             NFC DLL should use half-periods.
  * @sample_delay_factor:       The sample delay factor.
+ * @wrn_dly_sel:               The delay on the GPMI write strobe.
  */
 struct gpmi_nfc_hardware_timing {
+        /* for HW_GPMI_TIMING0 */
         uint8_t  data_setup_in_cycles;
         uint8_t  data_hold_in_cycles;
         uint8_t  address_setup_in_cycles;
+
+        /* for HW_GPMI_TIMING1 */
+        uint16_t device_busy_timeout;
+#define GPMI_DEFAULT_BUSY_TIMEOUT       0x500 /* default busy timeout value.*/
+
+        /* for HW_GPMI_CTRL1 */
         bool     use_half_periods;
         uint8_t  sample_delay_factor;
+        uint8_t  wrn_dly_sel;
 };
 
 /**
@@ -246,6 +265,7 @@ extern int start_dma_with_bch_irq(struct gpmi_nand_data *,
 
 /* GPMI-NAND helper function library */
 extern int gpmi_init(struct gpmi_nand_data *);
+extern int gpmi_extra_init(struct gpmi_nand_data *);
 extern void gpmi_clear_bch(struct gpmi_nand_data *);
 extern void gpmi_dump_info(struct gpmi_nand_data *);
 extern int bch_set_geometry(struct gpmi_nand_data *);
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-regs.h b/drivers/mtd/nand/gpmi-nand/gpmi-regs.h
index 83431240e2f2..53397cc290fc 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-regs.h
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-regs.h
@@ -108,6 +108,15 @@
 #define HW_GPMI_CTRL1_CLR                               0x00000068
 #define HW_GPMI_CTRL1_TOG                               0x0000006c
 
+#define BP_GPMI_CTRL1_WRN_DLY_SEL                       22
+#define BM_GPMI_CTRL1_WRN_DLY_SEL       (0x3 << BP_GPMI_CTRL1_WRN_DLY_SEL)
+#define BF_GPMI_CTRL1_WRN_DLY_SEL(v)  \
+        (((v) << BP_GPMI_CTRL1_WRN_DLY_SEL) & BM_GPMI_CTRL1_WRN_DLY_SEL)
+#define BV_GPMI_CTRL1_WRN_DLY_SEL_4_TO_8NS              0x0
+#define BV_GPMI_CTRL1_WRN_DLY_SEL_6_TO_10NS             0x1
+#define BV_GPMI_CTRL1_WRN_DLY_SEL_7_TO_12NS             0x2
+#define BV_GPMI_CTRL1_WRN_DLY_SEL_NO_DELAY              0x3
+
 #define BM_GPMI_CTRL1_BCH_MODE                          (1 << 18)
 
 #define BP_GPMI_CTRL1_DLL_ENABLE                        17
@@ -154,6 +163,9 @@
 
 #define HW_GPMI_TIMING1                                 0x00000080
 #define BP_GPMI_TIMING1_BUSY_TIMEOUT                    16
+#define BM_GPMI_TIMING1_BUSY_TIMEOUT    (0xffff << BP_GPMI_TIMING1_BUSY_TIMEOUT)
+#define BF_GPMI_TIMING1_BUSY_TIMEOUT(v)         \
+        (((v) << BP_GPMI_TIMING1_BUSY_TIMEOUT) & BM_GPMI_TIMING1_BUSY_TIMEOUT)
 
 #define HW_GPMI_TIMING2                                 0x00000090
 #define HW_GPMI_DATA                                    0x000000a0
diff --git a/drivers/mtd/nand/lpc32xx_mlc.c b/drivers/mtd/nand/lpc32xx_mlc.c
new file mode 100644
index 000000000000..c29b7ac1f6af
--- /dev/null
+++ b/drivers/mtd/nand/lpc32xx_mlc.c
@@ -0,0 +1,924 @@
+/*
+ * Driver for NAND MLC Controller in LPC32xx
+ *
+ * Author: Roland Stigge <stigge@antcom.de>
+ *
+ * Copyright © 2011 WORK Microwave GmbH
+ * Copyright © 2011, 2012 Roland Stigge
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ *
+ * NAND Flash Controller Operation:
+ * - Read: Auto Decode
+ * - Write: Auto Encode
+ * - Tested Page Sizes: 2048, 4096
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/completion.h>
+#include <linux/interrupt.h>
+#include <linux/of.h>
+#include <linux/of_mtd.h>
+#include <linux/of_gpio.h>
+#include <linux/mtd/lpc32xx_mlc.h>
+#include <linux/io.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/mtd/nand_ecc.h>
+
+#define DRV_NAME "lpc32xx_mlc"
+
+/**********************************************************************
+* MLC NAND controller register offsets
+**********************************************************************/
+
+#define MLC_BUFF(x)                     (x + 0x00000)
+#define MLC_DATA(x)                     (x + 0x08000)
+#define MLC_CMD(x)                      (x + 0x10000)
+#define MLC_ADDR(x)                     (x + 0x10004)
+#define MLC_ECC_ENC_REG(x)              (x + 0x10008)
+#define MLC_ECC_DEC_REG(x)              (x + 0x1000C)
+#define MLC_ECC_AUTO_ENC_REG(x)         (x + 0x10010)
+#define MLC_ECC_AUTO_DEC_REG(x)         (x + 0x10014)
+#define MLC_RPR(x)                      (x + 0x10018)
+#define MLC_WPR(x)                      (x + 0x1001C)
+#define MLC_RUBP(x)                     (x + 0x10020)
+#define MLC_ROBP(x)                     (x + 0x10024)
+#define MLC_SW_WP_ADD_LOW(x)            (x + 0x10028)
+#define MLC_SW_WP_ADD_HIG(x)            (x + 0x1002C)
+#define MLC_ICR(x)                      (x + 0x10030)
+#define MLC_TIME_REG(x)                 (x + 0x10034)
+#define MLC_IRQ_MR(x)                   (x + 0x10038)
+#define MLC_IRQ_SR(x)                   (x + 0x1003C)
+#define MLC_LOCK_PR(x)                  (x + 0x10044)
+#define MLC_ISR(x)                      (x + 0x10048)
+#define MLC_CEH(x)                      (x + 0x1004C)
+
+/**********************************************************************
+* MLC_CMD bit definitions
+**********************************************************************/
+#define MLCCMD_RESET                    0xFF
+
+/**********************************************************************
+* MLC_ICR bit definitions
+**********************************************************************/
+#define MLCICR_WPROT                    (1 << 3)
+#define MLCICR_LARGEBLOCK               (1 << 2)
+#define MLCICR_LONGADDR                 (1 << 1)
+#define MLCICR_16BIT                    (1 << 0)  /* unsupported by LPC32x0! */
+
+/**********************************************************************
+* MLC_TIME_REG bit definitions
+**********************************************************************/
+#define MLCTIMEREG_TCEA_DELAY(n)        (((n) & 0x03) << 24)
+#define MLCTIMEREG_BUSY_DELAY(n)        (((n) & 0x1F) << 19)
+#define MLCTIMEREG_NAND_TA(n)           (((n) & 0x07) << 16)
+#define MLCTIMEREG_RD_HIGH(n)           (((n) & 0x0F) << 12)
+#define MLCTIMEREG_RD_LOW(n)            (((n) & 0x0F) << 8)
+#define MLCTIMEREG_WR_HIGH(n)           (((n) & 0x0F) << 4)
+#define MLCTIMEREG_WR_LOW(n)            (((n) & 0x0F) << 0)
+
+/**********************************************************************
+* MLC_IRQ_MR and MLC_IRQ_SR bit definitions
+**********************************************************************/
+#define MLCIRQ_NAND_READY               (1 << 5)
+#define MLCIRQ_CONTROLLER_READY         (1 << 4)
+#define MLCIRQ_DECODE_FAILURE           (1 << 3)
+#define MLCIRQ_DECODE_ERROR             (1 << 2)
+#define MLCIRQ_ECC_READY                (1 << 1)
+#define MLCIRQ_WRPROT_FAULT             (1 << 0)
+
+/**********************************************************************
+* MLC_LOCK_PR bit definitions
+**********************************************************************/
+#define MLCLOCKPR_MAGIC                 0xA25E
+
+/**********************************************************************
+* MLC_ISR bit definitions
+**********************************************************************/
+#define MLCISR_DECODER_FAILURE          (1 << 6)
+#define MLCISR_ERRORS                   ((1 << 4) | (1 << 5))
+#define MLCISR_ERRORS_DETECTED          (1 << 3)
+#define MLCISR_ECC_READY                (1 << 2)
+#define MLCISR_CONTROLLER_READY         (1 << 1)
+#define MLCISR_NAND_READY               (1 << 0)
+
+/**********************************************************************
+* MLC_CEH bit definitions
+**********************************************************************/
+#define MLCCEH_NORMAL                   (1 << 0)
+
+struct lpc32xx_nand_cfg_mlc {
+        uint32_t tcea_delay;
+        uint32_t busy_delay;
+        uint32_t nand_ta;
+        uint32_t rd_high;
+        uint32_t rd_low;
+        uint32_t wr_high;
+        uint32_t wr_low;
+        int wp_gpio;
+        struct mtd_partition *parts;
+        unsigned num_parts;
+};
+
+static struct nand_ecclayout lpc32xx_nand_oob = {
+        .eccbytes = 40,
+        .eccpos = { 6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+                   22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                   38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+                   54, 55, 56, 57, 58, 59, 60, 61, 62, 63 },
+        .oobfree = {
+                { .offset = 0,
+                  .length = 6, },
+                { .offset = 16,
+                  .length = 6, },
+                { .offset = 32,
+                  .length = 6, },
+                { .offset = 48,
+                  .length = 6, },
+                },
+};
+
+static struct nand_bbt_descr lpc32xx_nand_bbt = {
+        .options = NAND_BBT_ABSPAGE | NAND_BBT_2BIT | NAND_BBT_NO_OOB |
+                   NAND_BBT_WRITE,
+        .pages = { 524224, 0, 0, 0, 0, 0, 0, 0 },
+};
+
+static struct nand_bbt_descr lpc32xx_nand_bbt_mirror = {
+        .options = NAND_BBT_ABSPAGE | NAND_BBT_2BIT | NAND_BBT_NO_OOB |
+                   NAND_BBT_WRITE,
+        .pages = { 524160, 0, 0, 0, 0, 0, 0, 0 },
+};
+
+struct lpc32xx_nand_host {
+        struct nand_chip        nand_chip;
+        struct lpc32xx_mlc_platform_data *pdata;
+        struct clk              *clk;
+        struct mtd_info         mtd;
+        void __iomem            *io_base;
+        int                     irq;
+        struct lpc32xx_nand_cfg_mlc     *ncfg;
+        struct completion       comp_nand;
+        struct completion       comp_controller;
+        uint32_t llptr;
+        /*
+         * Physical addresses of ECC buffer, DMA data buffers, OOB data buffer
+         */
+        dma_addr_t              oob_buf_phy;
+        /*
+         * Virtual addresses of ECC buffer, DMA data buffers, OOB data buffer
+         */
+        uint8_t                 *oob_buf;
+        /* Physical address of DMA base address */
+        dma_addr_t              io_base_phy;
+
+        struct completion       comp_dma;
+        struct dma_chan         *dma_chan;
+        struct dma_slave_config dma_slave_config;
+        struct scatterlist      sgl;
+        uint8_t                 *dma_buf;
+        uint8_t                 *dummy_buf;
+        int                     mlcsubpages; /* number of 512bytes-subpages */
+};
+
+/*
+ * Activate/Deactivate DMA Operation:
+ *
+ * Using the PL080 DMA Controller for transferring the 512 byte subpages
+ * instead of doing readl() / writel() in a loop slows it down significantly.
+ * Measurements via getnstimeofday() upon 512 byte subpage reads reveal:
+ *
+ * - readl() of 128 x 32 bits in a loop: ~20us
+ * - DMA read of 512 bytes (32 bit, 4...128 words bursts): ~60us
+ * - DMA read of 512 bytes (32 bit, no bursts): ~100us
+ *
+ * This applies to the transfer itself. In the DMA case: only the
+ * wait_for_completion() (DMA setup _not_ included).
+ *
+ * Note that the 512 bytes subpage transfer is done directly from/to a
+ * FIFO/buffer inside the NAND controller. Most of the time (~400-800us for a
+ * 2048 bytes page) is spent waiting for the NAND IRQ, anyway. (The NAND
+ * controller transferring data between its internal buffer to/from the NAND
+ * chip.)
+ *
+ * Therefore, using the PL080 DMA is disabled by default, for now.
+ *
+ */
+static int use_dma;
+
+static void lpc32xx_nand_setup(struct lpc32xx_nand_host *host)
+{
+        uint32_t clkrate, tmp;
+
+        /* Reset MLC controller */
+        writel(MLCCMD_RESET, MLC_CMD(host->io_base));
+        udelay(1000);
+
+        /* Get base clock for MLC block */
+        clkrate = clk_get_rate(host->clk);
+        if (clkrate == 0)
+                clkrate = 104000000;
+
+        /* Unlock MLC_ICR
+         * (among others, will be locked again automatically) */
+        writew(MLCLOCKPR_MAGIC, MLC_LOCK_PR(host->io_base));
+
+        /* Configure MLC Controller: Large Block, 5 Byte Address */
+        tmp = MLCICR_LARGEBLOCK | MLCICR_LONGADDR;
+        writel(tmp, MLC_ICR(host->io_base));
+
+        /* Unlock MLC_TIME_REG
+         * (among others, will be locked again automatically) */
+        writew(MLCLOCKPR_MAGIC, MLC_LOCK_PR(host->io_base));
+
+        /* Compute clock setup values, see LPC and NAND manual */
+        tmp = 0;
+        tmp |= MLCTIMEREG_TCEA_DELAY(clkrate / host->ncfg->tcea_delay + 1);
+        tmp |= MLCTIMEREG_BUSY_DELAY(clkrate / host->ncfg->busy_delay + 1);
+        tmp |= MLCTIMEREG_NAND_TA(clkrate / host->ncfg->nand_ta + 1);
+        tmp |= MLCTIMEREG_RD_HIGH(clkrate / host->ncfg->rd_high + 1);
+        tmp |= MLCTIMEREG_RD_LOW(clkrate / host->ncfg->rd_low);
+        tmp |= MLCTIMEREG_WR_HIGH(clkrate / host->ncfg->wr_high + 1);
+        tmp |= MLCTIMEREG_WR_LOW(clkrate / host->ncfg->wr_low);
+        writel(tmp, MLC_TIME_REG(host->io_base));
+
+        /* Enable IRQ for CONTROLLER_READY and NAND_READY */
+        writeb(MLCIRQ_CONTROLLER_READY | MLCIRQ_NAND_READY,
+                        MLC_IRQ_MR(host->io_base));
+
+        /* Normal nCE operation: nCE controlled by controller */
+        writel(MLCCEH_NORMAL, MLC_CEH(host->io_base));
+}
+
+/*
+ * Hardware specific access to control lines
+ */
+static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
+                                  unsigned int ctrl)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct lpc32xx_nand_host *host = nand_chip->priv;
+
+        if (cmd != NAND_CMD_NONE) {
+                if (ctrl & NAND_CLE)
+                        writel(cmd, MLC_CMD(host->io_base));
+                else
+                        writel(cmd, MLC_ADDR(host->io_base));
+        }
+}
+
+/*
+ * Read Device Ready (NAND device _and_ controller ready)
+ */
+static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct lpc32xx_nand_host *host = nand_chip->priv;
+
+        if ((readb(MLC_ISR(host->io_base)) &
+             (MLCISR_CONTROLLER_READY | MLCISR_NAND_READY)) ==
+            (MLCISR_CONTROLLER_READY | MLCISR_NAND_READY))
+                return  1;
+
+        return 0;
+}
+
+static irqreturn_t lpc3xxx_nand_irq(int irq, struct lpc32xx_nand_host *host)
+{
+        uint8_t sr;
+
+        /* Clear interrupt flag by reading status */
+        sr = readb(MLC_IRQ_SR(host->io_base));
+        if (sr & MLCIRQ_NAND_READY)
+                complete(&host->comp_nand);
+        if (sr & MLCIRQ_CONTROLLER_READY)
+                complete(&host->comp_controller);
+
+        return IRQ_HANDLED;
+}
+
+static int lpc32xx_waitfunc_nand(struct mtd_info *mtd, struct nand_chip *chip)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        if (readb(MLC_ISR(host->io_base)) & MLCISR_NAND_READY)
+                goto exit;
+
+        wait_for_completion(&host->comp_nand);
+
+        while (!(readb(MLC_ISR(host->io_base)) & MLCISR_NAND_READY)) {
+                /* Seems to be delayed sometimes by controller */
+                dev_dbg(&mtd->dev, "Warning: NAND not ready.\n");
+                cpu_relax();
+        }
+
+exit:
+        return NAND_STATUS_READY;
+}
+
+static int lpc32xx_waitfunc_controller(struct mtd_info *mtd,
+                                       struct nand_chip *chip)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        if (readb(MLC_ISR(host->io_base)) & MLCISR_CONTROLLER_READY)
+                goto exit;
+
+        wait_for_completion(&host->comp_controller);
+
+        while (!(readb(MLC_ISR(host->io_base)) &
+                 MLCISR_CONTROLLER_READY)) {
+                dev_dbg(&mtd->dev, "Warning: Controller not ready.\n");
+                cpu_relax();
+        }
+
+exit:
+        return NAND_STATUS_READY;
+}
+
+static int lpc32xx_waitfunc(struct mtd_info *mtd, struct nand_chip *chip)
+{
+        lpc32xx_waitfunc_nand(mtd, chip);
+        lpc32xx_waitfunc_controller(mtd, chip);
+
+        return NAND_STATUS_READY;
+}
+
+/*
+ * Enable NAND write protect
+ */
+static void lpc32xx_wp_enable(struct lpc32xx_nand_host *host)
+{
+        if (gpio_is_valid(host->ncfg->wp_gpio))
+                gpio_set_value(host->ncfg->wp_gpio, 0);
+}
+
+/*
+ * Disable NAND write protect
+ */
+static void lpc32xx_wp_disable(struct lpc32xx_nand_host *host)
+{
+        if (gpio_is_valid(host->ncfg->wp_gpio))
+                gpio_set_value(host->ncfg->wp_gpio, 1);
+}
+
+static void lpc32xx_dma_complete_func(void *completion)
+{
+        complete(completion);
+}
+
+static int lpc32xx_xmit_dma(struct mtd_info *mtd, void *mem, int len,
+                            enum dma_transfer_direction dir)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+        struct dma_async_tx_descriptor *desc;
+        int flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
+        int res;
+
+        sg_init_one(&host->sgl, mem, len);
+
+        res = dma_map_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                         DMA_BIDIRECTIONAL);
+        if (res != 1) {
+                dev_err(mtd->dev.parent, "Failed to map sg list\n");
+                return -ENXIO;
+        }
+        desc = dmaengine_prep_slave_sg(host->dma_chan, &host->sgl, 1, dir,
+                                       flags);
+        if (!desc) {
+                dev_err(mtd->dev.parent, "Failed to prepare slave sg\n");
+                goto out1;
+        }
+
+        init_completion(&host->comp_dma);
+        desc->callback = lpc32xx_dma_complete_func;
+        desc->callback_param = &host->comp_dma;
+
+        dmaengine_submit(desc);
+        dma_async_issue_pending(host->dma_chan);
+
+        wait_for_completion_timeout(&host->comp_dma, msecs_to_jiffies(1000));
+
+        dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                     DMA_BIDIRECTIONAL);
+        return 0;
+out1:
+        dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                     DMA_BIDIRECTIONAL);
+        return -ENXIO;
+}
+
+static int lpc32xx_read_page(struct mtd_info *mtd, struct nand_chip *chip,
+                             uint8_t *buf, int oob_required, int page)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+        int i, j;
+        uint8_t *oobbuf = chip->oob_poi;
+        uint32_t mlc_isr;
+        int res;
+        uint8_t *dma_buf;
+        bool dma_mapped;
+
+        if ((void *)buf <= high_memory) {
+                dma_buf = buf;
+                dma_mapped = true;
+        } else {
+                dma_buf = host->dma_buf;
+                dma_mapped = false;
+        }
+
+        /* Writing Command and Address */
+        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+
+        /* For all sub-pages */
+        for (i = 0; i < host->mlcsubpages; i++) {
+                /* Start Auto Decode Command */
+                writeb(0x00, MLC_ECC_AUTO_DEC_REG(host->io_base));
+
+                /* Wait for Controller Ready */
+                lpc32xx_waitfunc_controller(mtd, chip);
+
+                /* Check ECC Error status */
+                mlc_isr = readl(MLC_ISR(host->io_base));
+                if (mlc_isr & MLCISR_DECODER_FAILURE) {
+                        mtd->ecc_stats.failed++;
+                        dev_warn(&mtd->dev, "%s: DECODER_FAILURE\n", __func__);
+                } else if (mlc_isr & MLCISR_ERRORS_DETECTED) {
+                        mtd->ecc_stats.corrected += ((mlc_isr >> 4) & 0x3) + 1;
+                }
+
+                /* Read 512 + 16 Bytes */
+                if (use_dma) {
+                        res = lpc32xx_xmit_dma(mtd, dma_buf + i * 512, 512,
+                                               DMA_DEV_TO_MEM);
+                        if (res)
+                                return res;
+                } else {
+                        for (j = 0; j < (512 >> 2); j++) {
+                                *((uint32_t *)(buf)) =
+                                        readl(MLC_BUFF(host->io_base));
+                                buf += 4;
+                        }
+                }
+                for (j = 0; j < (16 >> 2); j++) {
+                        *((uint32_t *)(oobbuf)) =
+                                readl(MLC_BUFF(host->io_base));
+                        oobbuf += 4;
+                }
+        }
+
+        if (use_dma && !dma_mapped)
+                memcpy(buf, dma_buf, mtd->writesize);
+
+        return 0;
+}
+
+static int lpc32xx_write_page_lowlevel(struct mtd_info *mtd,
+                                       struct nand_chip *chip,
+                                       const uint8_t *buf, int oob_required)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+        const uint8_t *oobbuf = chip->oob_poi;
+        uint8_t *dma_buf = (uint8_t *)buf;
+        int res;
+        int i, j;
+
+        if (use_dma && (void *)buf >= high_memory) {
+                dma_buf = host->dma_buf;
+                memcpy(dma_buf, buf, mtd->writesize);
+        }
+
+        for (i = 0; i < host->mlcsubpages; i++) {
+                /* Start Encode */
+                writeb(0x00, MLC_ECC_ENC_REG(host->io_base));
+
+                /* Write 512 + 6 Bytes to Buffer */
+                if (use_dma) {
+                        res = lpc32xx_xmit_dma(mtd, dma_buf + i * 512, 512,
+                                               DMA_MEM_TO_DEV);
+                        if (res)
+                                return res;
+                } else {
+                        for (j = 0; j < (512 >> 2); j++) {
+                                writel(*((uint32_t *)(buf)),
+                                       MLC_BUFF(host->io_base));
+                                buf += 4;
+                        }
+                }
+                writel(*((uint32_t *)(oobbuf)), MLC_BUFF(host->io_base));
+                oobbuf += 4;
+                writew(*((uint16_t *)(oobbuf)), MLC_BUFF(host->io_base));
+                oobbuf += 12;
+
+                /* Auto Encode w/ Bit 8 = 0 (see LPC MLC Controller manual) */
+                writeb(0x00, MLC_ECC_AUTO_ENC_REG(host->io_base));
+
+                /* Wait for Controller Ready */
+                lpc32xx_waitfunc_controller(mtd, chip);
+        }
+        return 0;
+}
+
+static int lpc32xx_write_page(struct mtd_info *mtd, struct nand_chip *chip,
+                              const uint8_t *buf, int oob_required, int page,
+                              int cached, int raw)
+{
+        int res;
+
+        chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
+        res = lpc32xx_write_page_lowlevel(mtd, chip, buf, oob_required);
+        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
+        lpc32xx_waitfunc(mtd, chip);
+
+        return res;
+}
+
+static int lpc32xx_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
+                            int page)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        /* Read whole page - necessary with MLC controller! */
+        lpc32xx_read_page(mtd, chip, host->dummy_buf, 1, page);
+
+        return 0;
+}
+
+static int lpc32xx_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
+                              int page)
+{
+        /* None, write_oob conflicts with the automatic LPC MLC ECC decoder! */
+        return 0;
+}
+
+/* Prepares MLC for transfers with H/W ECC enabled: always enabled anyway */
+static void lpc32xx_ecc_enable(struct mtd_info *mtd, int mode)
+{
+        /* Always enabled! */
+}
+
+static int lpc32xx_dma_setup(struct lpc32xx_nand_host *host)
+{
+        struct mtd_info *mtd = &host->mtd;
+        dma_cap_mask_t mask;
+
+        if (!host->pdata || !host->pdata->dma_filter) {
+                dev_err(mtd->dev.parent, "no DMA platform data\n");
+                return -ENOENT;
+        }
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        host->dma_chan = dma_request_channel(mask, host->pdata->dma_filter,
+                                             "nand-mlc");
+        if (!host->dma_chan) {
+                dev_err(mtd->dev.parent, "Failed to request DMA channel\n");
+                return -EBUSY;
+        }
+
+        /*
+         * Set direction to a sensible value even if the dmaengine driver
+         * should ignore it. With the default (DMA_MEM_TO_MEM), the amba-pl08x
+         * driver criticizes it as "alien transfer direction".
+         */
+        host->dma_slave_config.direction = DMA_DEV_TO_MEM;
+        host->dma_slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_slave_config.src_maxburst = 128;
+        host->dma_slave_config.dst_maxburst = 128;
+        /* DMA controller does flow control: */
+        host->dma_slave_config.device_fc = false;
+        host->dma_slave_config.src_addr = MLC_BUFF(host->io_base_phy);
+        host->dma_slave_config.dst_addr = MLC_BUFF(host->io_base_phy);
+        if (dmaengine_slave_config(host->dma_chan, &host->dma_slave_config)) {
+                dev_err(mtd->dev.parent, "Failed to setup DMA slave\n");
+                goto out1;
+        }
+
+        return 0;
+out1:
+        dma_release_channel(host->dma_chan);
+        return -ENXIO;
+}
+
+static struct lpc32xx_nand_cfg_mlc *lpc32xx_parse_dt(struct device *dev)
+{
+        struct lpc32xx_nand_cfg_mlc *ncfg;
+        struct device_node *np = dev->of_node;
+
+        ncfg = devm_kzalloc(dev, sizeof(*ncfg), GFP_KERNEL);
+        if (!ncfg) {
+                dev_err(dev, "could not allocate memory for platform data\n");
+                return NULL;
+        }
+
+        of_property_read_u32(np, "nxp,tcea-delay", &ncfg->tcea_delay);
+        of_property_read_u32(np, "nxp,busy-delay", &ncfg->busy_delay);
+        of_property_read_u32(np, "nxp,nand-ta", &ncfg->nand_ta);
+        of_property_read_u32(np, "nxp,rd-high", &ncfg->rd_high);
+        of_property_read_u32(np, "nxp,rd-low", &ncfg->rd_low);
+        of_property_read_u32(np, "nxp,wr-high", &ncfg->wr_high);
+        of_property_read_u32(np, "nxp,wr-low", &ncfg->wr_low);
+
+        if (!ncfg->tcea_delay || !ncfg->busy_delay || !ncfg->nand_ta ||
+            !ncfg->rd_high || !ncfg->rd_low || !ncfg->wr_high ||
+            !ncfg->wr_low) {
+                dev_err(dev, "chip parameters not specified correctly\n");
+                return NULL;
+        }
+
+        ncfg->wp_gpio = of_get_named_gpio(np, "gpios", 0);
+
+        return ncfg;
+}
+
+/*
+ * Probe for NAND controller
+ */
+static int __devinit lpc32xx_nand_probe(struct platform_device *pdev)
+{
+        struct lpc32xx_nand_host *host;
+        struct mtd_info *mtd;
+        struct nand_chip *nand_chip;
+        struct resource *rc;
+        int res;
+        struct mtd_part_parser_data ppdata = {};
+
+        /* Allocate memory for the device structure (and zero it) */
+        host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
+        if (!host) {
+                dev_err(&pdev->dev, "failed to allocate device structure.\n");
+                return -ENOMEM;
+        }
+
+        rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (rc == NULL) {
+                dev_err(&pdev->dev, "No memory resource found for device!\r\n");
+                return -ENXIO;
+        }
+
+        host->io_base = devm_request_and_ioremap(&pdev->dev, rc);
+        if (host->io_base == NULL) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                return -EIO;
+        }
+        host->io_base_phy = rc->start;
+
+        mtd = &host->mtd;
+        nand_chip = &host->nand_chip;
+        if (pdev->dev.of_node)
+                host->ncfg = lpc32xx_parse_dt(&pdev->dev);
+        if (!host->ncfg) {
+                dev_err(&pdev->dev,
+                        "Missing or bad NAND config from device tree\n");
+                return -ENOENT;
+        }
+        if (host->ncfg->wp_gpio == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (gpio_is_valid(host->ncfg->wp_gpio) &&
+                        gpio_request(host->ncfg->wp_gpio, "NAND WP")) {
+                dev_err(&pdev->dev, "GPIO not available\n");
+                return -EBUSY;
+        }
+        lpc32xx_wp_disable(host);
+
+        host->pdata = pdev->dev.platform_data;
+
+        nand_chip->priv = host;         /* link the private data structures */
+        mtd->priv = nand_chip;
+        mtd->owner = THIS_MODULE;
+        mtd->dev.parent = &pdev->dev;
+
+        /* Get NAND clock */
+        host->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(host->clk)) {
+                dev_err(&pdev->dev, "Clock initialization failure\n");
+                res = -ENOENT;
+                goto err_exit1;
+        }
+        clk_enable(host->clk);
+
+        nand_chip->cmd_ctrl = lpc32xx_nand_cmd_ctrl;
+        nand_chip->dev_ready = lpc32xx_nand_device_ready;
+        nand_chip->chip_delay = 25; /* us */
+        nand_chip->IO_ADDR_R = MLC_DATA(host->io_base);
+        nand_chip->IO_ADDR_W = MLC_DATA(host->io_base);
+
+        /* Init NAND controller */
+        lpc32xx_nand_setup(host);
+
+        platform_set_drvdata(pdev, host);
+
+        /* Initialize function pointers */
+        nand_chip->ecc.hwctl = lpc32xx_ecc_enable;
+        nand_chip->ecc.read_page_raw = lpc32xx_read_page;
+        nand_chip->ecc.read_page = lpc32xx_read_page;
+        nand_chip->ecc.write_page_raw = lpc32xx_write_page_lowlevel;
+        nand_chip->ecc.write_page = lpc32xx_write_page_lowlevel;
+        nand_chip->ecc.write_oob = lpc32xx_write_oob;
+        nand_chip->ecc.read_oob = lpc32xx_read_oob;
+        nand_chip->ecc.strength = 4;
+        nand_chip->write_page = lpc32xx_write_page;
+        nand_chip->waitfunc = lpc32xx_waitfunc;
+
+        nand_chip->bbt_options = NAND_BBT_USE_FLASH | NAND_BBT_NO_OOB;
+        nand_chip->bbt_td = &lpc32xx_nand_bbt;
+        nand_chip->bbt_md = &lpc32xx_nand_bbt_mirror;
+
+        /* bitflip_threshold's default is defined as ecc_strength anyway.
+         * Unfortunately, it is set only later at add_mtd_device(). Meanwhile
+         * being 0, it causes bad block table scanning errors in
+         * nand_scan_tail(), so preparing it here. */
+        mtd->bitflip_threshold = nand_chip->ecc.strength;
+
+        if (use_dma) {
+                res = lpc32xx_dma_setup(host);
+                if (res) {
+                        res = -EIO;
+                        goto err_exit2;
+                }
+        }
+
+        /*
+         * Scan to find existance of the device and
+         * Get the type of NAND device SMALL block or LARGE block
+         */
+        if (nand_scan_ident(mtd, 1, NULL)) {
+                res = -ENXIO;
+                goto err_exit3;
+        }
+
+        host->dma_buf = devm_kzalloc(&pdev->dev, mtd->writesize, GFP_KERNEL);
+        if (!host->dma_buf) {
+                dev_err(&pdev->dev, "Error allocating dma_buf memory\n");
+                res = -ENOMEM;
+                goto err_exit3;
+        }
+
+        host->dummy_buf = devm_kzalloc(&pdev->dev, mtd->writesize, GFP_KERNEL);
+        if (!host->dummy_buf) {
+                dev_err(&pdev->dev, "Error allocating dummy_buf memory\n");
+                res = -ENOMEM;
+                goto err_exit3;
+        }
+
+        nand_chip->ecc.mode = NAND_ECC_HW;
+        nand_chip->ecc.size = mtd->writesize;
+        nand_chip->ecc.layout = &lpc32xx_nand_oob;
+        host->mlcsubpages = mtd->writesize / 512;
+
+        /* initially clear interrupt status */
+        readb(MLC_IRQ_SR(host->io_base));
+
+        init_completion(&host->comp_nand);
+        init_completion(&host->comp_controller);
+
+        host->irq = platform_get_irq(pdev, 0);
+        if ((host->irq < 0) || (host->irq >= NR_IRQS)) {
+                dev_err(&pdev->dev, "failed to get platform irq\n");
+                res = -EINVAL;
+                goto err_exit3;
+        }
+
+        if (request_irq(host->irq, (irq_handler_t)&lpc3xxx_nand_irq,
+                        IRQF_TRIGGER_HIGH, DRV_NAME, host)) {
+                dev_err(&pdev->dev, "Error requesting NAND IRQ\n");
+                res = -ENXIO;
+                goto err_exit3;
+        }
+
+        /*
+         * Fills out all the uninitialized function pointers with the defaults
+         * And scans for a bad block table if appropriate.
+         */
+        if (nand_scan_tail(mtd)) {
+                res = -ENXIO;
+                goto err_exit4;
+        }
+
+        mtd->name = DRV_NAME;
+
+        ppdata.of_node = pdev->dev.of_node;
+        res = mtd_device_parse_register(mtd, NULL, &ppdata, host->ncfg->parts,
+                                        host->ncfg->num_parts);
+        if (!res)
+                return res;
+
+        nand_release(mtd);
+
+err_exit4:
+        free_irq(host->irq, host);
+err_exit3:
+        if (use_dma)
+                dma_release_channel(host->dma_chan);
+err_exit2:
+        clk_disable(host->clk);
+        clk_put(host->clk);
+        platform_set_drvdata(pdev, NULL);
+err_exit1:
+        lpc32xx_wp_enable(host);
+        gpio_free(host->ncfg->wp_gpio);
+
+        return res;
+}
+
+/*
+ * Remove NAND device
+ */
+static int __devexit lpc32xx_nand_remove(struct platform_device *pdev)
+{
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+        struct mtd_info *mtd = &host->mtd;
+
+        nand_release(mtd);
+        free_irq(host->irq, host);
+        if (use_dma)
+                dma_release_channel(host->dma_chan);
+
+        clk_disable(host->clk);
+        clk_put(host->clk);
+        platform_set_drvdata(pdev, NULL);
+
+        lpc32xx_wp_enable(host);
+        gpio_free(host->ncfg->wp_gpio);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int lpc32xx_nand_resume(struct platform_device *pdev)
+{
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+
+        /* Re-enable NAND clock */
+        clk_enable(host->clk);
+
+        /* Fresh init of NAND controller */
+        lpc32xx_nand_setup(host);
+
+        /* Disable write protect */
+        lpc32xx_wp_disable(host);
+
+        return 0;
+}
+
+static int lpc32xx_nand_suspend(struct platform_device *pdev, pm_message_t pm)
+{
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+
+        /* Enable write protect for safety */
+        lpc32xx_wp_enable(host);
+
+        /* Disable clock */
+        clk_disable(host->clk);
+        return 0;
+}
+
+#else
+#define lpc32xx_nand_resume NULL
+#define lpc32xx_nand_suspend NULL
+#endif
+
+static const struct of_device_id lpc32xx_nand_match[] = {
+        { .compatible = "nxp,lpc3220-mlc" },
+        { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, lpc32xx_nand_match);
+
+static struct platform_driver lpc32xx_nand_driver = {
+        .probe          = lpc32xx_nand_probe,
+        .remove         = __devexit_p(lpc32xx_nand_remove),
+        .resume         = lpc32xx_nand_resume,
+        .suspend        = lpc32xx_nand_suspend,
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(lpc32xx_nand_match),
+        },
+};
+
+module_platform_driver(lpc32xx_nand_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
+MODULE_DESCRIPTION("NAND driver for the NXP LPC32XX MLC controller");
diff --git a/drivers/mtd/nand/lpc32xx_slc.c b/drivers/mtd/nand/lpc32xx_slc.c
new file mode 100644
index 000000000000..32409c45d479
--- /dev/null
+++ b/drivers/mtd/nand/lpc32xx_slc.c
@@ -0,0 +1,1039 @@
+/*
+ * NXP LPC32XX NAND SLC driver
+ *
+ * Authors:
+ *    Kevin Wells <kevin.wells@nxp.com>
+ *    Roland Stigge <stigge@antcom.de>
+ *
+ * Copyright © 2011 NXP Semiconductors
+ * Copyright © 2012 Roland Stigge
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/mtd/nand_ecc.h>
+#include <linux/gpio.h>
+#include <linux/of.h>
+#include <linux/of_mtd.h>
+#include <linux/of_gpio.h>
+#include <linux/mtd/lpc32xx_slc.h>
+
+#define LPC32XX_MODNAME         "lpc32xx-nand"
+
+/**********************************************************************
+* SLC NAND controller register offsets
+**********************************************************************/
+
+#define SLC_DATA(x)             (x + 0x000)
+#define SLC_ADDR(x)             (x + 0x004)
+#define SLC_CMD(x)              (x + 0x008)
+#define SLC_STOP(x)             (x + 0x00C)
+#define SLC_CTRL(x)             (x + 0x010)
+#define SLC_CFG(x)              (x + 0x014)
+#define SLC_STAT(x)             (x + 0x018)
+#define SLC_INT_STAT(x)         (x + 0x01C)
+#define SLC_IEN(x)              (x + 0x020)
+#define SLC_ISR(x)              (x + 0x024)
+#define SLC_ICR(x)              (x + 0x028)
+#define SLC_TAC(x)              (x + 0x02C)
+#define SLC_TC(x)               (x + 0x030)
+#define SLC_ECC(x)              (x + 0x034)
+#define SLC_DMA_DATA(x)         (x + 0x038)
+
+/**********************************************************************
+* slc_ctrl register definitions
+**********************************************************************/
+#define SLCCTRL_SW_RESET        (1 << 2) /* Reset the NAND controller bit */
+#define SLCCTRL_ECC_CLEAR       (1 << 1) /* Reset ECC bit */
+#define SLCCTRL_DMA_START       (1 << 0) /* Start DMA channel bit */
+
+/**********************************************************************
+* slc_cfg register definitions
+**********************************************************************/
+#define SLCCFG_CE_LOW           (1 << 5) /* Force CE low bit */
+#define SLCCFG_DMA_ECC          (1 << 4) /* Enable DMA ECC bit */
+#define SLCCFG_ECC_EN           (1 << 3) /* ECC enable bit */
+#define SLCCFG_DMA_BURST        (1 << 2) /* DMA burst bit */
+#define SLCCFG_DMA_DIR          (1 << 1) /* DMA write(0)/read(1) bit */
+#define SLCCFG_WIDTH            (1 << 0) /* External device width, 0=8bit */
+
+/**********************************************************************
+* slc_stat register definitions
+**********************************************************************/
+#define SLCSTAT_DMA_FIFO        (1 << 2) /* DMA FIFO has data bit */
+#define SLCSTAT_SLC_FIFO        (1 << 1) /* SLC FIFO has data bit */
+#define SLCSTAT_NAND_READY      (1 << 0) /* NAND device is ready bit */
+
+/**********************************************************************
+* slc_int_stat, slc_ien, slc_isr, and slc_icr register definitions
+**********************************************************************/
+#define SLCSTAT_INT_TC          (1 << 1) /* Transfer count bit */
+#define SLCSTAT_INT_RDY_EN      (1 << 0) /* Ready interrupt bit */
+
+/**********************************************************************
+* slc_tac register definitions
+**********************************************************************/
+/* Clock setting for RDY write sample wait time in 2*n clocks */
+#define SLCTAC_WDR(n)           (((n) & 0xF) << 28)
+/* Write pulse width in clock cycles, 1 to 16 clocks */
+#define SLCTAC_WWIDTH(n)        (((n) & 0xF) << 24)
+/* Write hold time of control and data signals, 1 to 16 clocks */
+#define SLCTAC_WHOLD(n)         (((n) & 0xF) << 20)
+/* Write setup time of control and data signals, 1 to 16 clocks */
+#define SLCTAC_WSETUP(n)        (((n) & 0xF) << 16)
+/* Clock setting for RDY read sample wait time in 2*n clocks */
+#define SLCTAC_RDR(n)           (((n) & 0xF) << 12)
+/* Read pulse width in clock cycles, 1 to 16 clocks */
+#define SLCTAC_RWIDTH(n)        (((n) & 0xF) << 8)
+/* Read hold time of control and data signals, 1 to 16 clocks */
+#define SLCTAC_RHOLD(n)         (((n) & 0xF) << 4)
+/* Read setup time of control and data signals, 1 to 16 clocks */
+#define SLCTAC_RSETUP(n)        (((n) & 0xF) << 0)
+
+/**********************************************************************
+* slc_ecc register definitions
+**********************************************************************/
+/* ECC line party fetch macro */
+#define SLCECC_TO_LINEPAR(n)    (((n) >> 6) & 0x7FFF)
+#define SLCECC_TO_COLPAR(n)     ((n) & 0x3F)
+
+/*
+ * DMA requires storage space for the DMA local buffer and the hardware ECC
+ * storage area. The DMA local buffer is only used if DMA mapping fails
+ * during runtime.
+ */
+#define LPC32XX_DMA_DATA_SIZE           4096
+#define LPC32XX_ECC_SAVE_SIZE           ((4096 / 256) * 4)
+
+/* Number of bytes used for ECC stored in NAND per 256 bytes */
+#define LPC32XX_SLC_DEV_ECC_BYTES       3
+
+/*
+ * If the NAND base clock frequency can't be fetched, this frequency will be
+ * used instead as the base. This rate is used to setup the timing registers
+ * used for NAND accesses.
+ */
+#define LPC32XX_DEF_BUS_RATE            133250000
+
+/* Milliseconds for DMA FIFO timeout (unlikely anyway) */
+#define LPC32XX_DMA_TIMEOUT             100
+
+/*
+ * NAND ECC Layout for small page NAND devices
+ * Note: For large and huge page devices, the default layouts are used
+ */
+static struct nand_ecclayout lpc32xx_nand_oob_16 = {
+        .eccbytes = 6,
+        .eccpos = {10, 11, 12, 13, 14, 15},
+        .oobfree = {
+                { .offset = 0, .length = 4 },
+                { .offset = 6, .length = 4 },
+        },
+};
+
+static u8 bbt_pattern[] = {'B', 'b', 't', '0' };
+static u8 mirror_pattern[] = {'1', 't', 'b', 'B' };
+
+/*
+ * Small page FLASH BBT descriptors, marker at offset 0, version at offset 6
+ * Note: Large page devices used the default layout
+ */
+static struct nand_bbt_descr bbt_smallpage_main_descr = {
+        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
+                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
+        .offs = 0,
+        .len = 4,
+        .veroffs = 6,
+        .maxblocks = 4,
+        .pattern = bbt_pattern
+};
+
+static struct nand_bbt_descr bbt_smallpage_mirror_descr = {
+        .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
+                | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
+        .offs = 0,
+        .len = 4,
+        .veroffs = 6,
+        .maxblocks = 4,
+        .pattern = mirror_pattern
+};
+
+/*
+ * NAND platform configuration structure
+ */
+struct lpc32xx_nand_cfg_slc {
+        uint32_t wdr_clks;
+        uint32_t wwidth;
+        uint32_t whold;
+        uint32_t wsetup;
+        uint32_t rdr_clks;
+        uint32_t rwidth;
+        uint32_t rhold;
+        uint32_t rsetup;
+        bool use_bbt;
+        int wp_gpio;
+        struct mtd_partition *parts;
+        unsigned num_parts;
+};
+
+struct lpc32xx_nand_host {
+        struct nand_chip        nand_chip;
+        struct lpc32xx_slc_platform_data *pdata;
+        struct clk              *clk;
+        struct mtd_info         mtd;
+        void __iomem            *io_base;
+        struct lpc32xx_nand_cfg_slc *ncfg;
+
+        struct completion       comp;
+        struct dma_chan         *dma_chan;
+        uint32_t                dma_buf_len;
+        struct dma_slave_config dma_slave_config;
+        struct scatterlist      sgl;
+
+        /*
+         * DMA and CPU addresses of ECC work area and data buffer
+         */
+        uint32_t                *ecc_buf;
+        uint8_t                 *data_buf;
+        dma_addr_t              io_base_dma;
+};
+
+static void lpc32xx_nand_setup(struct lpc32xx_nand_host *host)
+{
+        uint32_t clkrate, tmp;
+
+        /* Reset SLC controller */
+        writel(SLCCTRL_SW_RESET, SLC_CTRL(host->io_base));
+        udelay(1000);
+
+        /* Basic setup */
+        writel(0, SLC_CFG(host->io_base));
+        writel(0, SLC_IEN(host->io_base));
+        writel((SLCSTAT_INT_TC | SLCSTAT_INT_RDY_EN),
+                SLC_ICR(host->io_base));
+
+        /* Get base clock for SLC block */
+        clkrate = clk_get_rate(host->clk);
+        if (clkrate == 0)
+                clkrate = LPC32XX_DEF_BUS_RATE;
+
+        /* Compute clock setup values */
+        tmp = SLCTAC_WDR(host->ncfg->wdr_clks) |
+                SLCTAC_WWIDTH(1 + (clkrate / host->ncfg->wwidth)) |
+                SLCTAC_WHOLD(1 + (clkrate / host->ncfg->whold)) |
+                SLCTAC_WSETUP(1 + (clkrate / host->ncfg->wsetup)) |
+                SLCTAC_RDR(host->ncfg->rdr_clks) |
+                SLCTAC_RWIDTH(1 + (clkrate / host->ncfg->rwidth)) |
+                SLCTAC_RHOLD(1 + (clkrate / host->ncfg->rhold)) |
+                SLCTAC_RSETUP(1 + (clkrate / host->ncfg->rsetup));
+        writel(tmp, SLC_TAC(host->io_base));
+}
+
+/*
+ * Hardware specific access to control lines
+ */
+static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
+        unsigned int ctrl)
+{
+        uint32_t tmp;
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        /* Does CE state need to be changed? */
+        tmp = readl(SLC_CFG(host->io_base));
+        if (ctrl & NAND_NCE)
+                tmp |= SLCCFG_CE_LOW;
+        else
+                tmp &= ~SLCCFG_CE_LOW;
+        writel(tmp, SLC_CFG(host->io_base));
+
+        if (cmd != NAND_CMD_NONE) {
+                if (ctrl & NAND_CLE)
+                        writel(cmd, SLC_CMD(host->io_base));
+                else
+                        writel(cmd, SLC_ADDR(host->io_base));
+        }
+}
+
+/*
+ * Read the Device Ready pin
+ */
+static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+        int rdy = 0;
+
+        if ((readl(SLC_STAT(host->io_base)) & SLCSTAT_NAND_READY) != 0)
+                rdy = 1;
+
+        return rdy;
+}
+
+/*
+ * Enable NAND write protect
+ */
+static void lpc32xx_wp_enable(struct lpc32xx_nand_host *host)
+{
+        if (gpio_is_valid(host->ncfg->wp_gpio))
+                gpio_set_value(host->ncfg->wp_gpio, 0);
+}
+
+/*
+ * Disable NAND write protect
+ */
+static void lpc32xx_wp_disable(struct lpc32xx_nand_host *host)
+{
+        if (gpio_is_valid(host->ncfg->wp_gpio))
+                gpio_set_value(host->ncfg->wp_gpio, 1);
+}
+
+/*
+ * Prepares SLC for transfers with H/W ECC enabled
+ */
+static void lpc32xx_nand_ecc_enable(struct mtd_info *mtd, int mode)
+{
+        /* Hardware ECC is enabled automatically in hardware as needed */
+}
+
+/*
+ * Calculates the ECC for the data
+ */
+static int lpc32xx_nand_ecc_calculate(struct mtd_info *mtd,
+                                      const unsigned char *buf,
+                                      unsigned char *code)
+{
+        /*
+         * ECC is calculated automatically in hardware during syndrome read
+         * and write operations, so it doesn't need to be calculated here.
+         */
+        return 0;
+}
+
+/*
+ * Read a single byte from NAND device
+ */
+static uint8_t lpc32xx_nand_read_byte(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        return (uint8_t)readl(SLC_DATA(host->io_base));
+}
+
+/*
+ * Simple device read without ECC
+ */
+static void lpc32xx_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        /* Direct device read with no ECC */
+        while (len-- > 0)
+                *buf++ = (uint8_t)readl(SLC_DATA(host->io_base));
+}
+
+/*
+ * Simple device write without ECC
+ */
+static void lpc32xx_nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+
+        /* Direct device write with no ECC */
+        while (len-- > 0)
+                writel((uint32_t)*buf++, SLC_DATA(host->io_base));
+}
+
+/*
+ * Read the OOB data from the device without ECC using FIFO method
+ */
+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);
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
+}
+
+/*
+ * Write the OOB data to the device without ECC using FIFO method
+ */
+static int lpc32xx_nand_write_oob_syndrome(struct mtd_info *mtd,
+        struct nand_chip *chip, int page)
+{
+        int status;
+
+        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;
+}
+
+/*
+ * Fills in the ECC fields in the OOB buffer with the hardware generated ECC
+ */
+static void lpc32xx_slc_ecc_copy(uint8_t *spare, const uint32_t *ecc, int count)
+{
+        int i;
+
+        for (i = 0; i < (count * 3); i += 3) {
+                uint32_t ce = ecc[i / 3];
+                ce = ~(ce << 2) & 0xFFFFFF;
+                spare[i + 2] = (uint8_t)(ce & 0xFF);
+                ce >>= 8;
+                spare[i + 1] = (uint8_t)(ce & 0xFF);
+                ce >>= 8;
+                spare[i] = (uint8_t)(ce & 0xFF);
+        }
+}
+
+static void lpc32xx_dma_complete_func(void *completion)
+{
+        complete(completion);
+}
+
+static int lpc32xx_xmit_dma(struct mtd_info *mtd, dma_addr_t dma,
+                            void *mem, int len, enum dma_transfer_direction dir)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+        struct dma_async_tx_descriptor *desc;
+        int flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
+        int res;
+
+        host->dma_slave_config.direction = dir;
+        host->dma_slave_config.src_addr = dma;
+        host->dma_slave_config.dst_addr = dma;
+        host->dma_slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        host->dma_slave_config.src_maxburst = 4;
+        host->dma_slave_config.dst_maxburst = 4;
+        /* DMA controller does flow control: */
+        host->dma_slave_config.device_fc = false;
+        if (dmaengine_slave_config(host->dma_chan, &host->dma_slave_config)) {
+                dev_err(mtd->dev.parent, "Failed to setup DMA slave\n");
+                return -ENXIO;
+        }
+
+        sg_init_one(&host->sgl, mem, len);
+
+        res = dma_map_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                         DMA_BIDIRECTIONAL);
+        if (res != 1) {
+                dev_err(mtd->dev.parent, "Failed to map sg list\n");
+                return -ENXIO;
+        }
+        desc = dmaengine_prep_slave_sg(host->dma_chan, &host->sgl, 1, dir,
+                                       flags);
+        if (!desc) {
+                dev_err(mtd->dev.parent, "Failed to prepare slave sg\n");
+                goto out1;
+        }
+
+        init_completion(&host->comp);
+        desc->callback = lpc32xx_dma_complete_func;
+        desc->callback_param = &host->comp;
+
+        dmaengine_submit(desc);
+        dma_async_issue_pending(host->dma_chan);
+
+        wait_for_completion_timeout(&host->comp, msecs_to_jiffies(1000));
+
+        dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                     DMA_BIDIRECTIONAL);
+
+        return 0;
+out1:
+        dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
+                     DMA_BIDIRECTIONAL);
+        return -ENXIO;
+}
+
+/*
+ * DMA read/write transfers with ECC support
+ */
+static int lpc32xx_xfer(struct mtd_info *mtd, uint8_t *buf, int eccsubpages,
+                        int read)
+{
+        struct nand_chip *chip = mtd->priv;
+        struct lpc32xx_nand_host *host = chip->priv;
+        int i, status = 0;
+        unsigned long timeout;
+        int res;
+        enum dma_transfer_direction dir =
+                read ? DMA_DEV_TO_MEM : DMA_MEM_TO_DEV;
+        uint8_t *dma_buf;
+        bool dma_mapped;
+
+        if ((void *)buf <= high_memory) {
+                dma_buf = buf;
+                dma_mapped = true;
+        } else {
+                dma_buf = host->data_buf;
+                dma_mapped = false;
+                if (!read)
+                        memcpy(host->data_buf, buf, mtd->writesize);
+        }
+
+        if (read) {
+                writel(readl(SLC_CFG(host->io_base)) |
+                       SLCCFG_DMA_DIR | SLCCFG_ECC_EN | SLCCFG_DMA_ECC |
+                       SLCCFG_DMA_BURST, SLC_CFG(host->io_base));
+        } else {
+                writel((readl(SLC_CFG(host->io_base)) |
+                        SLCCFG_ECC_EN | SLCCFG_DMA_ECC | SLCCFG_DMA_BURST) &
+                       ~SLCCFG_DMA_DIR,
+                        SLC_CFG(host->io_base));
+        }
+
+        /* Clear initial ECC */
+        writel(SLCCTRL_ECC_CLEAR, SLC_CTRL(host->io_base));
+
+        /* Transfer size is data area only */
+        writel(mtd->writesize, SLC_TC(host->io_base));
+
+        /* Start transfer in the NAND controller */
+        writel(readl(SLC_CTRL(host->io_base)) | SLCCTRL_DMA_START,
+               SLC_CTRL(host->io_base));
+
+        for (i = 0; i < chip->ecc.steps; i++) {
+                /* Data */
+                res = lpc32xx_xmit_dma(mtd, SLC_DMA_DATA(host->io_base_dma),
+                                       dma_buf + i * chip->ecc.size,
+                                       mtd->writesize / chip->ecc.steps, dir);
+                if (res)
+                        return res;
+
+                /* Always _read_ ECC */
+                if (i == chip->ecc.steps - 1)
+                        break;
+                if (!read) /* ECC availability delayed on write */
+                        udelay(10);
+                res = lpc32xx_xmit_dma(mtd, SLC_ECC(host->io_base_dma),
+                                       &host->ecc_buf[i], 4, DMA_DEV_TO_MEM);
+                if (res)
+                        return res;
+        }
+
+        /*
+         * According to NXP, the DMA can be finished here, but the NAND
+         * controller may still have buffered data. After porting to using the
+         * dmaengine DMA driver (amba-pl080), the condition (DMA_FIFO empty)
+         * appears to be always true, according to tests. Keeping the check for
+         * safety reasons for now.
+         */
+        if (readl(SLC_STAT(host->io_base)) & SLCSTAT_DMA_FIFO) {
+                dev_warn(mtd->dev.parent, "FIFO not empty!\n");
+                timeout = jiffies + msecs_to_jiffies(LPC32XX_DMA_TIMEOUT);
+                while ((readl(SLC_STAT(host->io_base)) & SLCSTAT_DMA_FIFO) &&
+                       time_before(jiffies, timeout))
+                        cpu_relax();
+                if (!time_before(jiffies, timeout)) {
+                        dev_err(mtd->dev.parent, "FIFO held data too long\n");
+                        status = -EIO;
+                }
+        }
+
+        /* Read last calculated ECC value */
+        if (!read)
+                udelay(10);
+        host->ecc_buf[chip->ecc.steps - 1] =
+                readl(SLC_ECC(host->io_base));
+
+        /* Flush DMA */
+        dmaengine_terminate_all(host->dma_chan);
+
+        if (readl(SLC_STAT(host->io_base)) & SLCSTAT_DMA_FIFO ||
+            readl(SLC_TC(host->io_base))) {
+                /* Something is left in the FIFO, something is wrong */
+                dev_err(mtd->dev.parent, "DMA FIFO failure\n");
+                status = -EIO;
+        }
+
+        /* Stop DMA & HW ECC */
+        writel(readl(SLC_CTRL(host->io_base)) & ~SLCCTRL_DMA_START,
+               SLC_CTRL(host->io_base));
+        writel(readl(SLC_CFG(host->io_base)) &
+               ~(SLCCFG_DMA_DIR | SLCCFG_ECC_EN | SLCCFG_DMA_ECC |
+                 SLCCFG_DMA_BURST), SLC_CFG(host->io_base));
+
+        if (!dma_mapped && read)
+                memcpy(buf, host->data_buf, mtd->writesize);
+
+        return status;
+}
+
+/*
+ * Read the data and OOB data from the device, use ECC correction with the
+ * data, disable ECC for the OOB data
+ */
+static int lpc32xx_nand_read_page_syndrome(struct mtd_info *mtd,
+                                           struct nand_chip *chip, uint8_t *buf,
+                                           int oob_required, int page)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+        int stat, i, status;
+        uint8_t *oobecc, tmpecc[LPC32XX_ECC_SAVE_SIZE];
+
+        /* Issue read command */
+        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+
+        /* Read data and oob, calculate ECC */
+        status = lpc32xx_xfer(mtd, buf, chip->ecc.steps, 1);
+
+        /* Get OOB data */
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        /* Convert to stored ECC format */
+        lpc32xx_slc_ecc_copy(tmpecc, (uint32_t *) host->ecc_buf, chip->ecc.steps);
+
+        /* Pointer to ECC data retrieved from NAND spare area */
+        oobecc = chip->oob_poi + chip->ecc.layout->eccpos[0];
+
+        for (i = 0; i < chip->ecc.steps; i++) {
+                stat = chip->ecc.correct(mtd, buf, oobecc,
+                                         &tmpecc[i * chip->ecc.bytes]);
+                if (stat < 0)
+                        mtd->ecc_stats.failed++;
+                else
+                        mtd->ecc_stats.corrected += stat;
+
+                buf += chip->ecc.size;
+                oobecc += chip->ecc.bytes;
+        }
+
+        return status;
+}
+
+/*
+ * Read the data and OOB data from the device, no ECC correction with the
+ * data or OOB data
+ */
+static int lpc32xx_nand_read_page_raw_syndrome(struct mtd_info *mtd,
+                                               struct nand_chip *chip,
+                                               uint8_t *buf, int oob_required,
+                                               int page)
+{
+        /* Issue read command */
+        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
+
+        /* Raw reads can just use the FIFO interface */
+        chip->read_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
+}
+
+/*
+ * Write the data and OOB data to the device, use ECC with the data,
+ * disable ECC for the OOB data
+ */
+static int lpc32xx_nand_write_page_syndrome(struct mtd_info *mtd,
+                                            struct nand_chip *chip,
+                                            const uint8_t *buf, int oob_required)
+{
+        struct lpc32xx_nand_host *host = chip->priv;
+        uint8_t *pb = chip->oob_poi + chip->ecc.layout->eccpos[0];
+        int error;
+
+        /* Write data, calculate ECC on outbound data */
+        error = lpc32xx_xfer(mtd, (uint8_t *)buf, chip->ecc.steps, 0);
+        if (error)
+                return error;
+
+        /*
+         * The calculated ECC needs some manual work done to it before
+         * committing it to NAND. Process the calculated ECC and place
+         * the resultant values directly into the OOB buffer. */
+        lpc32xx_slc_ecc_copy(pb, (uint32_t *)host->ecc_buf, chip->ecc.steps);
+
+        /* Write ECC data to device */
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return 0;
+}
+
+/*
+ * Write the data and OOB data to the device, no ECC correction with the
+ * data or OOB data
+ */
+static int lpc32xx_nand_write_page_raw_syndrome(struct mtd_info *mtd,
+                                                struct nand_chip *chip,
+                                                const uint8_t *buf,
+                                                int oob_required)
+{
+        /* Raw writes can just use the FIFO interface */
+        chip->write_buf(mtd, buf, chip->ecc.size * chip->ecc.steps);
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return 0;
+}
+
+static int lpc32xx_nand_dma_setup(struct lpc32xx_nand_host *host)
+{
+        struct mtd_info *mtd = &host->mtd;
+        dma_cap_mask_t mask;
+
+        if (!host->pdata || !host->pdata->dma_filter) {
+                dev_err(mtd->dev.parent, "no DMA platform data\n");
+                return -ENOENT;
+        }
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        host->dma_chan = dma_request_channel(mask, host->pdata->dma_filter,
+                                             "nand-slc");
+        if (!host->dma_chan) {
+                dev_err(mtd->dev.parent, "Failed to request DMA channel\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static struct lpc32xx_nand_cfg_slc *lpc32xx_parse_dt(struct device *dev)
+{
+        struct lpc32xx_nand_cfg_slc *ncfg;
+        struct device_node *np = dev->of_node;
+
+        ncfg = devm_kzalloc(dev, sizeof(*ncfg), GFP_KERNEL);
+        if (!ncfg) {
+                dev_err(dev, "could not allocate memory for NAND config\n");
+                return NULL;
+        }
+
+        of_property_read_u32(np, "nxp,wdr-clks", &ncfg->wdr_clks);
+        of_property_read_u32(np, "nxp,wwidth", &ncfg->wwidth);
+        of_property_read_u32(np, "nxp,whold", &ncfg->whold);
+        of_property_read_u32(np, "nxp,wsetup", &ncfg->wsetup);
+        of_property_read_u32(np, "nxp,rdr-clks", &ncfg->rdr_clks);
+        of_property_read_u32(np, "nxp,rwidth", &ncfg->rwidth);
+        of_property_read_u32(np, "nxp,rhold", &ncfg->rhold);
+        of_property_read_u32(np, "nxp,rsetup", &ncfg->rsetup);
+
+        if (!ncfg->wdr_clks || !ncfg->wwidth || !ncfg->whold ||
+            !ncfg->wsetup || !ncfg->rdr_clks || !ncfg->rwidth ||
+            !ncfg->rhold || !ncfg->rsetup) {
+                dev_err(dev, "chip parameters not specified correctly\n");
+                return NULL;
+        }
+
+        ncfg->use_bbt = of_get_nand_on_flash_bbt(np);
+        ncfg->wp_gpio = of_get_named_gpio(np, "gpios", 0);
+
+        return ncfg;
+}
+
+/*
+ * Probe for NAND controller
+ */
+static int __devinit lpc32xx_nand_probe(struct platform_device *pdev)
+{
+        struct lpc32xx_nand_host *host;
+        struct mtd_info *mtd;
+        struct nand_chip *chip;
+        struct resource *rc;
+        struct mtd_part_parser_data ppdata = {};
+        int res;
+
+        rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (rc == NULL) {
+                dev_err(&pdev->dev, "No memory resource found for device\n");
+                return -EBUSY;
+        }
+
+        /* Allocate memory for the device structure (and zero it) */
+        host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
+        if (!host) {
+                dev_err(&pdev->dev, "failed to allocate device structure\n");
+                return -ENOMEM;
+        }
+        host->io_base_dma = rc->start;
+
+        host->io_base = devm_request_and_ioremap(&pdev->dev, rc);
+        if (host->io_base == NULL) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                return -ENOMEM;
+        }
+
+        if (pdev->dev.of_node)
+                host->ncfg = lpc32xx_parse_dt(&pdev->dev);
+        if (!host->ncfg) {
+                dev_err(&pdev->dev,
+                        "Missing or bad NAND config from device tree\n");
+                return -ENOENT;
+        }
+        if (host->ncfg->wp_gpio == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (gpio_is_valid(host->ncfg->wp_gpio) &&
+                        gpio_request(host->ncfg->wp_gpio, "NAND WP")) {
+                dev_err(&pdev->dev, "GPIO not available\n");
+                return -EBUSY;
+        }
+        lpc32xx_wp_disable(host);
+
+        host->pdata = pdev->dev.platform_data;
+
+        mtd = &host->mtd;
+        chip = &host->nand_chip;
+        chip->priv = host;
+        mtd->priv = chip;
+        mtd->owner = THIS_MODULE;
+        mtd->dev.parent = &pdev->dev;
+
+        /* Get NAND clock */
+        host->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(host->clk)) {
+                dev_err(&pdev->dev, "Clock failure\n");
+                res = -ENOENT;
+                goto err_exit1;
+        }
+        clk_enable(host->clk);
+
+        /* Set NAND IO addresses and command/ready functions */
+        chip->IO_ADDR_R = SLC_DATA(host->io_base);
+        chip->IO_ADDR_W = SLC_DATA(host->io_base);
+        chip->cmd_ctrl = lpc32xx_nand_cmd_ctrl;
+        chip->dev_ready = lpc32xx_nand_device_ready;
+        chip->chip_delay = 20; /* 20us command delay time */
+
+        /* Init NAND controller */
+        lpc32xx_nand_setup(host);
+
+        platform_set_drvdata(pdev, host);
+
+        /* NAND callbacks for LPC32xx SLC hardware */
+        chip->ecc.mode = NAND_ECC_HW_SYNDROME;
+        chip->read_byte = lpc32xx_nand_read_byte;
+        chip->read_buf = lpc32xx_nand_read_buf;
+        chip->write_buf = lpc32xx_nand_write_buf;
+        chip->ecc.read_page_raw = lpc32xx_nand_read_page_raw_syndrome;
+        chip->ecc.read_page = lpc32xx_nand_read_page_syndrome;
+        chip->ecc.write_page_raw = lpc32xx_nand_write_page_raw_syndrome;
+        chip->ecc.write_page = lpc32xx_nand_write_page_syndrome;
+        chip->ecc.write_oob = lpc32xx_nand_write_oob_syndrome;
+        chip->ecc.read_oob = lpc32xx_nand_read_oob_syndrome;
+        chip->ecc.calculate = lpc32xx_nand_ecc_calculate;
+        chip->ecc.correct = nand_correct_data;
+        chip->ecc.strength = 1;
+        chip->ecc.hwctl = lpc32xx_nand_ecc_enable;
+
+        /* bitflip_threshold's default is defined as ecc_strength anyway.
+         * Unfortunately, it is set only later at add_mtd_device(). Meanwhile
+         * being 0, it causes bad block table scanning errors in
+         * nand_scan_tail(), so preparing it here already. */
+        mtd->bitflip_threshold = chip->ecc.strength;
+
+        /*
+         * Allocate a large enough buffer for a single huge page plus
+         * extra space for the spare area and ECC storage area
+         */
+        host->dma_buf_len = LPC32XX_DMA_DATA_SIZE + LPC32XX_ECC_SAVE_SIZE;
+        host->data_buf = devm_kzalloc(&pdev->dev, host->dma_buf_len,
+                                      GFP_KERNEL);
+        if (host->data_buf == NULL) {
+                dev_err(&pdev->dev, "Error allocating memory\n");
+                res = -ENOMEM;
+                goto err_exit2;
+        }
+
+        res = lpc32xx_nand_dma_setup(host);
+        if (res) {
+                res = -EIO;
+                goto err_exit2;
+        }
+
+        /* Find NAND device */
+        if (nand_scan_ident(mtd, 1, NULL)) {
+                res = -ENXIO;
+                goto err_exit3;
+        }
+
+        /* OOB and ECC CPU and DMA work areas */
+        host->ecc_buf = (uint32_t *)(host->data_buf + LPC32XX_DMA_DATA_SIZE);
+
+        /*
+         * Small page FLASH has a unique OOB layout, but large and huge
+         * page FLASH use the standard layout. Small page FLASH uses a
+         * custom BBT marker layout.
+         */
+        if (mtd->writesize <= 512)
+                chip->ecc.layout = &lpc32xx_nand_oob_16;
+
+        /* These sizes remain the same regardless of page size */
+        chip->ecc.size = 256;
+        chip->ecc.bytes = LPC32XX_SLC_DEV_ECC_BYTES;
+        chip->ecc.prepad = chip->ecc.postpad = 0;
+
+        /* Avoid extra scan if using BBT, setup BBT support */
+        if (host->ncfg->use_bbt) {
+                chip->options |= NAND_SKIP_BBTSCAN;
+                chip->bbt_options |= NAND_BBT_USE_FLASH;
+
+                /*
+                 * Use a custom BBT marker setup for small page FLASH that
+                 * won't interfere with the ECC layout. Large and huge page
+                 * FLASH use the standard layout.
+                 */
+                if (mtd->writesize <= 512) {
+                        chip->bbt_td = &bbt_smallpage_main_descr;
+                        chip->bbt_md = &bbt_smallpage_mirror_descr;
+                }
+        }
+
+        /*
+         * Fills out all the uninitialized function pointers with the defaults
+         */
+        if (nand_scan_tail(mtd)) {
+                res = -ENXIO;
+                goto err_exit3;
+        }
+
+        /* Standard layout in FLASH for bad block tables */
+        if (host->ncfg->use_bbt) {
+                if (nand_default_bbt(mtd) < 0)
+                        dev_err(&pdev->dev,
+                               "Error initializing default bad block tables\n");
+        }
+
+        mtd->name = "nxp_lpc3220_slc";
+        ppdata.of_node = pdev->dev.of_node;
+        res = mtd_device_parse_register(mtd, NULL, &ppdata, host->ncfg->parts,
+                                        host->ncfg->num_parts);
+        if (!res)
+                return res;
+
+        nand_release(mtd);
+
+err_exit3:
+        dma_release_channel(host->dma_chan);
+err_exit2:
+        clk_disable(host->clk);
+        clk_put(host->clk);
+        platform_set_drvdata(pdev, NULL);
+err_exit1:
+        lpc32xx_wp_enable(host);
+        gpio_free(host->ncfg->wp_gpio);
+
+        return res;
+}
+
+/*
+ * Remove NAND device.
+ */
+static int __devexit lpc32xx_nand_remove(struct platform_device *pdev)
+{
+        uint32_t tmp;
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+        struct mtd_info *mtd = &host->mtd;
+
+        nand_release(mtd);
+        dma_release_channel(host->dma_chan);
+
+        /* Force CE high */
+        tmp = readl(SLC_CTRL(host->io_base));
+        tmp &= ~SLCCFG_CE_LOW;
+        writel(tmp, SLC_CTRL(host->io_base));
+
+        clk_disable(host->clk);
+        clk_put(host->clk);
+        platform_set_drvdata(pdev, NULL);
+        lpc32xx_wp_enable(host);
+        gpio_free(host->ncfg->wp_gpio);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int lpc32xx_nand_resume(struct platform_device *pdev)
+{
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+
+        /* Re-enable NAND clock */
+        clk_enable(host->clk);
+
+        /* Fresh init of NAND controller */
+        lpc32xx_nand_setup(host);
+
+        /* Disable write protect */
+        lpc32xx_wp_disable(host);
+
+        return 0;
+}
+
+static int lpc32xx_nand_suspend(struct platform_device *pdev, pm_message_t pm)
+{
+        uint32_t tmp;
+        struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
+
+        /* Force CE high */
+        tmp = readl(SLC_CTRL(host->io_base));
+        tmp &= ~SLCCFG_CE_LOW;
+        writel(tmp, SLC_CTRL(host->io_base));
+
+        /* Enable write protect for safety */
+        lpc32xx_wp_enable(host);
+
+        /* Disable clock */
+        clk_disable(host->clk);
+
+        return 0;
+}
+
+#else
+#define lpc32xx_nand_resume NULL
+#define lpc32xx_nand_suspend NULL
+#endif
+
+static const struct of_device_id lpc32xx_nand_match[] = {
+        { .compatible = "nxp,lpc3220-slc" },
+        { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, lpc32xx_nand_match);
+
+static struct platform_driver lpc32xx_nand_driver = {
+        .probe          = lpc32xx_nand_probe,
+        .remove         = __devexit_p(lpc32xx_nand_remove),
+        .resume         = lpc32xx_nand_resume,
+        .suspend        = lpc32xx_nand_suspend,
+        .driver         = {
+                .name   = LPC32XX_MODNAME,
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(lpc32xx_nand_match),
+        },
+};
+
+module_platform_driver(lpc32xx_nand_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com>");
+MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
+MODULE_DESCRIPTION("NAND driver for the NXP LPC32XX SLC controller");
diff --git a/drivers/mtd/nand/mpc5121_nfc.c b/drivers/mtd/nand/mpc5121_nfc.c
index c259c24d7986..f776c8577b8c 100644
--- a/drivers/mtd/nand/mpc5121_nfc.c
+++ b/drivers/mtd/nand/mpc5121_nfc.c
@@ -506,27 +506,6 @@ static void mpc5121_nfc_write_buf(struct mtd_info *mtd,
         mpc5121_nfc_buf_copy(mtd, (u_char *)buf, len, 1);
 }
 
-/* Compare buffer with NAND flash */
-static int mpc5121_nfc_verify_buf(struct mtd_info *mtd,
-                                                const u_char *buf, int len)
-{
-        u_char tmp[256];
-        uint bsize;
-
-        while (len) {
-                bsize = min(len, 256);
-                mpc5121_nfc_read_buf(mtd, tmp, bsize);
-
-                if (memcmp(buf, tmp, bsize))
-                        return 1;
-
-                buf += bsize;
-                len -= bsize;
-        }
-
-        return 0;
-}
-
 /* Read byte from NFC buffers */
 static u8 mpc5121_nfc_read_byte(struct mtd_info *mtd)
 {
@@ -732,7 +711,6 @@ static int __devinit mpc5121_nfc_probe(struct platform_device *op)
         chip->read_word = mpc5121_nfc_read_word;
         chip->read_buf = mpc5121_nfc_read_buf;
         chip->write_buf = mpc5121_nfc_write_buf;
-        chip->verify_buf = mpc5121_nfc_verify_buf;
         chip->select_chip = mpc5121_nfc_select_chip;
         chip->bbt_options = NAND_BBT_USE_FLASH;
         chip->ecc.mode = NAND_ECC_SOFT;
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index 5683604967d7..72e31d86030d 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -43,8 +43,8 @@
 
 #define nfc_is_v21()            (cpu_is_mx25() || cpu_is_mx35())
 #define nfc_is_v1()             (cpu_is_mx31() || cpu_is_mx27() || cpu_is_mx21())
-#define nfc_is_v3_2()           (cpu_is_mx51() || cpu_is_mx53())
-#define nfc_is_v3()             nfc_is_v3_2()
+#define nfc_is_v3_2a()          cpu_is_mx51()
+#define nfc_is_v3_2b()          cpu_is_mx53()
 
 /* Addresses for NFC registers */
 #define NFC_V1_V2_BUF_SIZE              (host->regs + 0x00)
@@ -122,7 +122,7 @@
 #define NFC_V3_CONFIG2_2CMD_PHASES              (1 << 4)
 #define NFC_V3_CONFIG2_NUM_ADDR_PHASE0          (1 << 5)
 #define NFC_V3_CONFIG2_ECC_MODE_8               (1 << 6)
-#define NFC_V3_CONFIG2_PPB(x)                   (((x) & 0x3) << 7)
+#define NFC_V3_CONFIG2_PPB(x, shift)            (((x) & 0x3) << shift)
 #define NFC_V3_CONFIG2_NUM_ADDR_PHASE1(x)       (((x) & 0x3) << 12)
 #define NFC_V3_CONFIG2_INT_MSK                  (1 << 15)
 #define NFC_V3_CONFIG2_ST_CMD(x)                (((x) & 0xff) << 24)
@@ -174,6 +174,7 @@ struct mxc_nand_devtype_data {
         int spare_len;
         int eccbytes;
         int eccsize;
+        int ppb_shift;
 };
 
 struct mxc_nand_host {
@@ -745,14 +746,6 @@ static void mxc_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         host->buf_start += n;
 }
 
-/* Used by the upper layer to verify the data in NAND Flash
- * with the data in the buf. */
-static int mxc_nand_verify_buf(struct mtd_info *mtd,
-                                const u_char *buf, int len)
-{
-        return -EFAULT;
-}
-
 /* This function is used by upper layer for select and
  * deselect of the NAND chip */
 static void mxc_nand_select_chip_v1_v3(struct mtd_info *mtd, int chip)
@@ -784,7 +777,7 @@ static void mxc_nand_select_chip_v2(struct mtd_info *mtd, int chip)
         if (chip == -1) {
                 /* Disable the NFC clock */
                 if (host->clk_act) {
-                        clk_disable(host->clk);
+                        clk_disable_unprepare(host->clk);
                         host->clk_act = 0;
                 }
                 return;
@@ -792,7 +785,7 @@ static void mxc_nand_select_chip_v2(struct mtd_info *mtd, int chip)
 
         if (!host->clk_act) {
                 /* Enable the NFC clock */
-                clk_enable(host->clk);
+                clk_prepare_enable(host->clk);
                 host->clk_act = 1;
         }
 
@@ -1021,7 +1014,9 @@ static void preset_v3(struct mtd_info *mtd)
         }
 
         if (mtd->writesize) {
-                config2 |= NFC_V3_CONFIG2_PPB(ffs(mtd->erasesize / mtd->writesize) - 6);
+                config2 |= NFC_V3_CONFIG2_PPB(
+                                ffs(mtd->erasesize / mtd->writesize) - 6,
+                                host->devtype_data->ppb_shift);
                 host->eccsize = get_eccsize(mtd);
                 if (host->eccsize == 8)
                         config2 |= NFC_V3_CONFIG2_ECC_MODE_8;
@@ -1234,7 +1229,7 @@ static const struct mxc_nand_devtype_data imx25_nand_devtype_data = {
         .eccsize = 0,
 };
 
-/* v3: i.MX51, i.MX53 */
+/* v3.2a: i.MX51 */
 static const struct mxc_nand_devtype_data imx51_nand_devtype_data = {
         .preset = preset_v3,
         .send_cmd = send_cmd_v3,
@@ -1258,6 +1253,34 @@ static const struct mxc_nand_devtype_data imx51_nand_devtype_data = {
         .spare_len = 64,
         .eccbytes = 0,
         .eccsize = 0,
+        .ppb_shift = 7,
+};
+
+/* v3.2b: i.MX53 */
+static const struct mxc_nand_devtype_data imx53_nand_devtype_data = {
+        .preset = preset_v3,
+        .send_cmd = send_cmd_v3,
+        .send_addr = send_addr_v3,
+        .send_page = send_page_v3,
+        .send_read_id = send_read_id_v3,
+        .get_dev_status = get_dev_status_v3,
+        .check_int = check_int_v3,
+        .irq_control = irq_control_v3,
+        .get_ecc_status = get_ecc_status_v3,
+        .ecclayout_512 = &nandv2_hw_eccoob_smallpage,
+        .ecclayout_2k = &nandv2_hw_eccoob_largepage,
+        .ecclayout_4k = &nandv2_hw_eccoob_smallpage, /* XXX: needs fix */
+        .select_chip = mxc_nand_select_chip_v1_v3,
+        .correct_data = mxc_nand_correct_data_v2_v3,
+        .irqpending_quirk = 0,
+        .needs_ip = 1,
+        .regs_offset = 0,
+        .spare0_offset = 0x1000,
+        .axi_offset = 0x1e00,
+        .spare_len = 64,
+        .eccbytes = 0,
+        .eccsize = 0,
+        .ppb_shift = 8,
 };
 
 #ifdef CONFIG_OF_MTD
@@ -1274,6 +1297,9 @@ static const struct of_device_id mxcnd_dt_ids[] = {
         }, {
                 .compatible = "fsl,imx51-nand",
                 .data = &imx51_nand_devtype_data,
+        }, {
+                .compatible = "fsl,imx53-nand",
+                .data = &imx53_nand_devtype_data,
         },
         { /* sentinel */ }
 };
@@ -1327,15 +1353,17 @@ static int __init mxcnd_probe_pdata(struct mxc_nand_host *host)
                         host->devtype_data = &imx27_nand_devtype_data;
         } else if (nfc_is_v21()) {
                 host->devtype_data = &imx25_nand_devtype_data;
-        } else if (nfc_is_v3_2()) {
+        } else if (nfc_is_v3_2a()) {
                 host->devtype_data = &imx51_nand_devtype_data;
+        } else if (nfc_is_v3_2b()) {
+                host->devtype_data = &imx53_nand_devtype_data;
         } else
                 BUG();
 
         return 0;
 }
 
-static int __init mxcnd_probe(struct platform_device *pdev)
+static int __devinit mxcnd_probe(struct platform_device *pdev)
 {
         struct nand_chip *this;
         struct mtd_info *mtd;
@@ -1344,8 +1372,8 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         int err = 0;
 
         /* Allocate memory for MTD device structure and private data */
-        host = kzalloc(sizeof(struct mxc_nand_host) + NAND_MAX_PAGESIZE +
-                        NAND_MAX_OOBSIZE, GFP_KERNEL);
+        host = devm_kzalloc(&pdev->dev, sizeof(struct mxc_nand_host) +
+                        NAND_MAX_PAGESIZE + NAND_MAX_OOBSIZE, GFP_KERNEL);
         if (!host)
                 return -ENOMEM;
 
@@ -1370,36 +1398,38 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         this->read_word = mxc_nand_read_word;
         this->write_buf = mxc_nand_write_buf;
         this->read_buf = mxc_nand_read_buf;
-        this->verify_buf = mxc_nand_verify_buf;
 
-        host->clk = clk_get(&pdev->dev, "nfc");
-        if (IS_ERR(host->clk)) {
-                err = PTR_ERR(host->clk);
-                goto eclk;
-        }
+        host->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(host->clk))
+                return PTR_ERR(host->clk);
 
-        clk_prepare_enable(host->clk);
-        host->clk_act = 1;
+        err = mxcnd_probe_dt(host);
+        if (err > 0)
+                err = mxcnd_probe_pdata(host);
+        if (err < 0)
+                return err;
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                err = -ENODEV;
-                goto eres;
-        }
+        if (host->devtype_data->needs_ip) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                if (!res)
+                        return -ENODEV;
+                host->regs_ip = devm_request_and_ioremap(&pdev->dev, res);
+                if (!host->regs_ip)
+                        return -ENOMEM;
 
-        host->base = ioremap(res->start, resource_size(res));
-        if (!host->base) {
-                err = -ENOMEM;
-                goto eres;
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        } else {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         }
 
-        host->main_area0 = host->base;
+        if (!res)
+                return -ENODEV;
 
-        err = mxcnd_probe_dt(host);
-        if (err > 0)
-                err = mxcnd_probe_pdata(host);
-        if (err < 0)
-                goto eirq;
+        host->base = devm_request_and_ioremap(&pdev->dev, res);
+        if (!host->base)
+                return -ENOMEM;
+
+        host->main_area0 = host->base;
 
         if (host->devtype_data->regs_offset)
                 host->regs = host->base + host->devtype_data->regs_offset;
@@ -1414,19 +1444,6 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         this->ecc.size = 512;
         this->ecc.layout = host->devtype_data->ecclayout_512;
 
-        if (host->devtype_data->needs_ip) {
-                res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-                if (!res) {
-                        err = -ENODEV;
-                        goto eirq;
-                }
-                host->regs_ip = ioremap(res->start, resource_size(res));
-                if (!host->regs_ip) {
-                        err = -ENOMEM;
-                        goto eirq;
-                }
-        }
-
         if (host->pdata.hw_ecc) {
                 this->ecc.calculate = mxc_nand_calculate_ecc;
                 this->ecc.hwctl = mxc_nand_enable_hwecc;
@@ -1458,9 +1475,13 @@ static int __init mxcnd_probe(struct platform_device *pdev)
          */
         host->devtype_data->irq_control(host, 0);
 
-        err = request_irq(host->irq, mxc_nfc_irq, IRQF_DISABLED, DRIVER_NAME, host);
+        err = devm_request_irq(&pdev->dev, host->irq, mxc_nfc_irq,
+                        IRQF_DISABLED, DRIVER_NAME, host);
         if (err)
-                goto eirq;
+                return err;
+
+        clk_prepare_enable(host->clk);
+        host->clk_act = 1;
 
         /*
          * Now that we "own" the interrupt make sure the interrupt mask bit is
@@ -1512,15 +1533,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         return 0;
 
 escan:
-        free_irq(host->irq, host);
-eirq:
-        if (host->regs_ip)
-                iounmap(host->regs_ip);
-        iounmap(host->base);
-eres:
-        clk_put(host->clk);
-eclk:
-        kfree(host);
+        clk_disable_unprepare(host->clk);
 
         return err;
 }
@@ -1529,16 +1542,9 @@ static int __devexit mxcnd_remove(struct platform_device *pdev)
 {
         struct mxc_nand_host *host = platform_get_drvdata(pdev);
 
-        clk_put(host->clk);
-
         platform_set_drvdata(pdev, NULL);
 
         nand_release(&host->mtd);
-        free_irq(host->irq, host);
-        if (host->regs_ip)
-                iounmap(host->regs_ip);
-        iounmap(host->base);
-        kfree(host);
 
         return 0;
 }
@@ -1549,22 +1555,10 @@ static struct platform_driver mxcnd_driver = {
                    .owner = THIS_MODULE,
                    .of_match_table = of_match_ptr(mxcnd_dt_ids),
         },
+        .probe = mxcnd_probe,
         .remove = __devexit_p(mxcnd_remove),
 };
-
-static int __init mxc_nd_init(void)
-{
-        return platform_driver_probe(&mxcnd_driver, mxcnd_probe);
-}
-
-static void __exit mxc_nd_cleanup(void)
-{
-        /* Unregister the device structure */
-        platform_driver_unregister(&mxcnd_driver);
-}
-
-module_init(mxc_nd_init);
-module_exit(mxc_nd_cleanup);
+module_platform_driver(mxcnd_driver);
 
 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_DESCRIPTION("MXC NAND MTD driver");
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index a11253a0fcab..ec6841d8e956 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -243,25 +243,6 @@ static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 }
 
 /**
- * nand_verify_buf - [DEFAULT] Verify chip data against buffer
- * @mtd: MTD device structure
- * @buf: buffer containing the data to compare
- * @len: number of bytes to compare
- *
- * Default verify function for 8bit buswidth.
- */
-static int nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
-{
-        int i;
-        struct nand_chip *chip = mtd->priv;
-
-        for (i = 0; i < len; i++)
-                if (buf[i] != readb(chip->IO_ADDR_R))
-                        return -EFAULT;
-        return 0;
-}
-
-/**
  * nand_write_buf16 - [DEFAULT] write buffer to chip
  * @mtd: MTD device structure
  * @buf: data buffer
@@ -301,28 +282,6 @@ static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
 }
 
 /**
- * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
- * @mtd: MTD device structure
- * @buf: buffer containing the data to compare
- * @len: number of bytes to compare
- *
- * Default verify function for 16bit buswidth.
- */
-static int nand_verify_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
-{
-        int i;
-        struct nand_chip *chip = mtd->priv;
-        u16 *p = (u16 *) buf;
-        len >>= 1;
-
-        for (i = 0; i < len; i++)
-                if (p[i] != readw(chip->IO_ADDR_R))
-                        return -EFAULT;
-
-        return 0;
-}
-
-/**
  * nand_block_bad - [DEFAULT] Read bad block marker from the chip
  * @mtd: MTD device structure
  * @ofs: offset from device start
@@ -1525,7 +1484,8 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
                                 ret = chip->ecc.read_page_raw(mtd, chip, bufpoi,
                                                               oob_required,
                                                               page);
-                        else if (!aligned && NAND_SUBPAGE_READ(chip) && !oob)
+                        else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) &&
+                                 !oob)
                                 ret = chip->ecc.read_subpage(mtd, chip,
                                                         col, bytes, bufpoi);
                         else
@@ -1542,7 +1502,7 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
 
                         /* Transfer not aligned data */
                         if (!aligned) {
-                                if (!NAND_SUBPAGE_READ(chip) && !oob &&
+                                if (!NAND_HAS_SUBPAGE_READ(chip) && !oob &&
                                     !(mtd->ecc_stats.failed - stats.failed) &&
                                     (ops->mode != MTD_OPS_RAW)) {
                                         chip->pagebuf = realpage;
@@ -1565,14 +1525,6 @@ static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
                                         oobreadlen -= toread;
                                 }
                         }
-
-                        if (!(chip->options & NAND_NO_READRDY)) {
-                                /* Apply delay or wait for ready/busy pin */
-                                if (!chip->dev_ready)
-                                        udelay(chip->chip_delay);
-                                else
-                                        nand_wait_ready(mtd);
-                        }
                 } else {
                         memcpy(buf, chip->buffers->databuf + col, bytes);
                         buf += bytes;
@@ -1633,7 +1585,7 @@ static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
         ops.len = len;
         ops.datbuf = buf;
         ops.oobbuf = NULL;
-        ops.mode = 0;
+        ops.mode = MTD_OPS_PLACE_OOB;
         ret = nand_do_read_ops(mtd, from, &ops);
         *retlen = ops.retlen;
         nand_release_device(mtd);
@@ -1837,14 +1789,6 @@ static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
                 len = min(len, readlen);
                 buf = nand_transfer_oob(chip, buf, ops, len);
 
-                if (!(chip->options & NAND_NO_READRDY)) {
-                        /* Apply delay or wait for ready/busy pin */
-                        if (!chip->dev_ready)
-                                udelay(chip->chip_delay);
-                        else
-                                nand_wait_ready(mtd);
-                }
-
                 readlen -= len;
                 if (!readlen)
                         break;
@@ -1927,12 +1871,14 @@ out:
  *
  * Not for syndrome calculating ECC controllers, which use a special oob layout.
  */
-static void nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
+static int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                 const uint8_t *buf, int oob_required)
 {
         chip->write_buf(mtd, buf, mtd->writesize);
         if (oob_required)
                 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 /**
@@ -1944,7 +1890,7 @@ static void nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
  *
  * We need a special oob layout and handling even when ECC isn't checked.
  */
-static void nand_write_page_raw_syndrome(struct mtd_info *mtd,
+static int nand_write_page_raw_syndrome(struct mtd_info *mtd,
                                         struct nand_chip *chip,
                                         const uint8_t *buf, int oob_required)
 {
@@ -1974,6 +1920,8 @@ static void nand_write_page_raw_syndrome(struct mtd_info *mtd,
         size = mtd->oobsize - (oob - chip->oob_poi);
         if (size)
                 chip->write_buf(mtd, oob, size);
+
+        return 0;
 }
 /**
  * nand_write_page_swecc - [REPLACEABLE] software ECC based page write function
@@ -1982,7 +1930,7 @@ static void nand_write_page_raw_syndrome(struct mtd_info *mtd,
  * @buf: data buffer
  * @oob_required: must write chip->oob_poi to OOB
  */
-static void nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
+static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
                                   const uint8_t *buf, int oob_required)
 {
         int i, eccsize = chip->ecc.size;
@@ -1999,7 +1947,7 @@ static void nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
         for (i = 0; i < chip->ecc.total; i++)
                 chip->oob_poi[eccpos[i]] = ecc_calc[i];
 
-        chip->ecc.write_page_raw(mtd, chip, buf, 1);
+        return chip->ecc.write_page_raw(mtd, chip, buf, 1);
 }
 
 /**
@@ -2009,7 +1957,7 @@ static void nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
  * @buf: data buffer
  * @oob_required: must write chip->oob_poi to OOB
  */
-static void nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                                   const uint8_t *buf, int oob_required)
 {
         int i, eccsize = chip->ecc.size;
@@ -2029,6 +1977,8 @@ static void nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                 chip->oob_poi[eccpos[i]] = ecc_calc[i];
 
         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 /**
@@ -2041,7 +1991,7 @@ static void nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
  * The hw generator calculates the error syndrome automatically. Therefore we
  * need a special oob layout and handling.
  */
-static void nand_write_page_syndrome(struct mtd_info *mtd,
+static int nand_write_page_syndrome(struct mtd_info *mtd,
                                     struct nand_chip *chip,
                                     const uint8_t *buf, int oob_required)
 {
@@ -2075,6 +2025,8 @@ static void nand_write_page_syndrome(struct mtd_info *mtd,
         i = mtd->oobsize - (oob - chip->oob_poi);
         if (i)
                 chip->write_buf(mtd, oob, i);
+
+        return 0;
 }
 
 /**
@@ -2096,9 +2048,12 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
         chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
 
         if (unlikely(raw))
-                chip->ecc.write_page_raw(mtd, chip, buf, oob_required);
+                status = chip->ecc.write_page_raw(mtd, chip, buf, oob_required);
         else
-                chip->ecc.write_page(mtd, chip, buf, oob_required);
+                status = chip->ecc.write_page(mtd, chip, buf, oob_required);
+
+        if (status < 0)
+                return status;
 
         /*
          * Cached progamming disabled for now. Not sure if it's worth the
@@ -2125,16 +2080,6 @@ static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                 status = chip->waitfunc(mtd, chip);
         }
 
-#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
-        /* Send command to read back the data */
-        chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
-
-        if (chip->verify_buf(mtd, buf, mtd->writesize))
-                return -EIO;
-
-        /* Make sure the next page prog is preceded by a status read */
-        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
-#endif
         return 0;
 }
 
@@ -2336,7 +2281,7 @@ static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len,
         ops.len = len;
         ops.datbuf = (uint8_t *)buf;
         ops.oobbuf = NULL;
-        ops.mode = 0;
+        ops.mode = MTD_OPS_PLACE_OOB;
 
         ret = nand_do_write_ops(mtd, to, &ops);
 
@@ -2365,7 +2310,7 @@ static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
         ops.len = len;
         ops.datbuf = (uint8_t *)buf;
         ops.oobbuf = NULL;
-        ops.mode = 0;
+        ops.mode = MTD_OPS_PLACE_OOB;
         ret = nand_do_write_ops(mtd, to, &ops);
         *retlen = ops.retlen;
         nand_release_device(mtd);
@@ -2755,6 +2700,50 @@ static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
 }
 
 /**
+ * nand_onfi_set_features- [REPLACEABLE] set features for ONFI nand
+ * @mtd: MTD device structure
+ * @chip: nand chip info structure
+ * @addr: feature address.
+ * @subfeature_param: the subfeature parameters, a four bytes array.
+ */
+static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip,
+                        int addr, uint8_t *subfeature_param)
+{
+        int status;
+
+        if (!chip->onfi_version)
+                return -EINVAL;
+
+        chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, addr, -1);
+        chip->write_buf(mtd, subfeature_param, ONFI_SUBFEATURE_PARAM_LEN);
+        status = chip->waitfunc(mtd, chip);
+        if (status & NAND_STATUS_FAIL)
+                return -EIO;
+        return 0;
+}
+
+/**
+ * nand_onfi_get_features- [REPLACEABLE] get features for ONFI nand
+ * @mtd: MTD device structure
+ * @chip: nand chip info structure
+ * @addr: feature address.
+ * @subfeature_param: the subfeature parameters, a four bytes array.
+ */
+static int nand_onfi_get_features(struct mtd_info *mtd, struct nand_chip *chip,
+                        int addr, uint8_t *subfeature_param)
+{
+        if (!chip->onfi_version)
+                return -EINVAL;
+
+        /* clear the sub feature parameters */
+        memset(subfeature_param, 0, ONFI_SUBFEATURE_PARAM_LEN);
+
+        chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, addr, -1);
+        chip->read_buf(mtd, subfeature_param, ONFI_SUBFEATURE_PARAM_LEN);
+        return 0;
+}
+
+/**
  * nand_suspend - [MTD Interface] Suspend the NAND flash
  * @mtd: MTD device structure
  */
@@ -2809,8 +2798,6 @@ static void nand_set_defaults(struct nand_chip *chip, int busw)
                 chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;
         if (!chip->read_buf)
                 chip->read_buf = busw ? nand_read_buf16 : nand_read_buf;
-        if (!chip->verify_buf)
-                chip->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
         if (!chip->scan_bbt)
                 chip->scan_bbt = nand_default_bbt;
 
@@ -2914,14 +2901,250 @@ static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip,
         if (le16_to_cpu(p->features) & 1)
                 *busw = NAND_BUSWIDTH_16;
 
-        chip->options &= ~NAND_CHIPOPTIONS_MSK;
-        chip->options |= NAND_NO_READRDY & NAND_CHIPOPTIONS_MSK;
-
         pr_info("ONFI flash detected\n");
         return 1;
 }
 
 /*
+ * nand_id_has_period - Check if an ID string has a given wraparound period
+ * @id_data: the ID string
+ * @arrlen: the length of the @id_data array
+ * @period: the period of repitition
+ *
+ * Check if an ID string is repeated within a given sequence of bytes at
+ * specific repetition interval period (e.g., {0x20,0x01,0x7F,0x20} has a
+ * period of 2). This is a helper function for nand_id_len(). Returns non-zero
+ * if the repetition has a period of @period; otherwise, returns zero.
+ */
+static int nand_id_has_period(u8 *id_data, int arrlen, int period)
+{
+        int i, j;
+        for (i = 0; i < period; i++)
+                for (j = i + period; j < arrlen; j += period)
+                        if (id_data[i] != id_data[j])
+                                return 0;
+        return 1;
+}
+
+/*
+ * nand_id_len - Get the length of an ID string returned by CMD_READID
+ * @id_data: the ID string
+ * @arrlen: the length of the @id_data array
+
+ * Returns the length of the ID string, according to known wraparound/trailing
+ * zero patterns. If no pattern exists, returns the length of the array.
+ */
+static int nand_id_len(u8 *id_data, int arrlen)
+{
+        int last_nonzero, period;
+
+        /* Find last non-zero byte */
+        for (last_nonzero = arrlen - 1; last_nonzero >= 0; last_nonzero--)
+                if (id_data[last_nonzero])
+                        break;
+
+        /* All zeros */
+        if (last_nonzero < 0)
+                return 0;
+
+        /* Calculate wraparound period */
+        for (period = 1; period < arrlen; period++)
+                if (nand_id_has_period(id_data, arrlen, period))
+                        break;
+
+        /* There's a repeated pattern */
+        if (period < arrlen)
+                return period;
+
+        /* There are trailing zeros */
+        if (last_nonzero < arrlen - 1)
+                return last_nonzero + 1;
+
+        /* No pattern detected */
+        return arrlen;
+}
+
+/*
+ * Many new NAND share similar device ID codes, which represent the size of the
+ * chip. The rest of the parameters must be decoded according to generic or
+ * manufacturer-specific "extended ID" decoding patterns.
+ */
+static void nand_decode_ext_id(struct mtd_info *mtd, struct nand_chip *chip,
+                                u8 id_data[8], int *busw)
+{
+        int extid, id_len;
+        /* The 3rd id byte holds MLC / multichip data */
+        chip->cellinfo = id_data[2];
+        /* The 4th id byte is the important one */
+        extid = id_data[3];
+
+        id_len = nand_id_len(id_data, 8);
+
+        /*
+         * Field definitions are in the following datasheets:
+         * Old style (4,5 byte ID): Samsung K9GAG08U0M (p.32)
+         * New style   (6 byte ID): Samsung K9GAG08U0F (p.44)
+         * Hynix MLC   (6 byte ID): Hynix H27UBG8T2B (p.22)
+         *
+         * Check for ID length, cell type, and Hynix/Samsung ID to decide what
+         * to do.
+         */
+        if (id_len == 6 && id_data[0] == NAND_MFR_SAMSUNG) {
+                /* Calc pagesize */
+                mtd->writesize = 2048 << (extid & 0x03);
+                extid >>= 2;
+                /* Calc oobsize */
+                switch (((extid >> 2) & 0x04) | (extid & 0x03)) {
+                case 1:
+                        mtd->oobsize = 128;
+                        break;
+                case 2:
+                        mtd->oobsize = 218;
+                        break;
+                case 3:
+                        mtd->oobsize = 400;
+                        break;
+                case 4:
+                        mtd->oobsize = 436;
+                        break;
+                case 5:
+                        mtd->oobsize = 512;
+                        break;
+                case 6:
+                default: /* Other cases are "reserved" (unknown) */
+                        mtd->oobsize = 640;
+                        break;
+                }
+                extid >>= 2;
+                /* Calc blocksize */
+                mtd->erasesize = (128 * 1024) <<
+                        (((extid >> 1) & 0x04) | (extid & 0x03));
+                *busw = 0;
+        } else if (id_len == 6 && id_data[0] == NAND_MFR_HYNIX &&
+                        (chip->cellinfo & NAND_CI_CELLTYPE_MSK)) {
+                unsigned int tmp;
+
+                /* Calc pagesize */
+                mtd->writesize = 2048 << (extid & 0x03);
+                extid >>= 2;
+                /* Calc oobsize */
+                switch (((extid >> 2) & 0x04) | (extid & 0x03)) {
+                case 0:
+                        mtd->oobsize = 128;
+                        break;
+                case 1:
+                        mtd->oobsize = 224;
+                        break;
+                case 2:
+                        mtd->oobsize = 448;
+                        break;
+                case 3:
+                        mtd->oobsize = 64;
+                        break;
+                case 4:
+                        mtd->oobsize = 32;
+                        break;
+                case 5:
+                        mtd->oobsize = 16;
+                        break;
+                default:
+                        mtd->oobsize = 640;
+                        break;
+                }
+                extid >>= 2;
+                /* Calc blocksize */
+                tmp = ((extid >> 1) & 0x04) | (extid & 0x03);
+                if (tmp < 0x03)
+                        mtd->erasesize = (128 * 1024) << tmp;
+                else if (tmp == 0x03)
+                        mtd->erasesize = 768 * 1024;
+                else
+                        mtd->erasesize = (64 * 1024) << tmp;
+                *busw = 0;
+        } else {
+                /* Calc pagesize */
+                mtd->writesize = 1024 << (extid & 0x03);
+                extid >>= 2;
+                /* Calc oobsize */
+                mtd->oobsize = (8 << (extid & 0x01)) *
+                        (mtd->writesize >> 9);
+                extid >>= 2;
+                /* Calc blocksize. Blocksize is multiples of 64KiB */
+                mtd->erasesize = (64 * 1024) << (extid & 0x03);
+                extid >>= 2;
+                /* Get buswidth information */
+                *busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
+        }
+}
+
+/*
+ * Old devices have chip data hardcoded in the device ID table. nand_decode_id
+ * decodes a matching ID table entry and assigns the MTD size parameters for
+ * the chip.
+ */
+static void nand_decode_id(struct mtd_info *mtd, struct nand_chip *chip,
+                                struct nand_flash_dev *type, u8 id_data[8],
+                                int *busw)
+{
+        int maf_id = id_data[0];
+
+        mtd->erasesize = type->erasesize;
+        mtd->writesize = type->pagesize;
+        mtd->oobsize = mtd->writesize / 32;
+        *busw = type->options & NAND_BUSWIDTH_16;
+
+        /*
+         * Check for Spansion/AMD ID + repeating 5th, 6th byte since
+         * some Spansion chips have erasesize that conflicts with size
+         * listed in nand_ids table.
+         * Data sheet (5 byte ID): Spansion S30ML-P ORNAND (p.39)
+         */
+        if (maf_id == NAND_MFR_AMD && id_data[4] != 0x00 && id_data[5] == 0x00
+                        && id_data[6] == 0x00 && id_data[7] == 0x00
+                        && mtd->writesize == 512) {
+                mtd->erasesize = 128 * 1024;
+                mtd->erasesize <<= ((id_data[3] & 0x03) << 1);
+        }
+}
+
+/*
+ * Set the bad block marker/indicator (BBM/BBI) patterns according to some
+ * heuristic patterns using various detected parameters (e.g., manufacturer,
+ * page size, cell-type information).
+ */
+static void nand_decode_bbm_options(struct mtd_info *mtd,
+                                    struct nand_chip *chip, u8 id_data[8])
+{
+        int maf_id = id_data[0];
+
+        /* Set the bad block position */
+        if (mtd->writesize > 512 || (chip->options & NAND_BUSWIDTH_16))
+                chip->badblockpos = NAND_LARGE_BADBLOCK_POS;
+        else
+                chip->badblockpos = NAND_SMALL_BADBLOCK_POS;
+
+        /*
+         * Bad block marker is stored in the last page of each block on Samsung
+         * and Hynix MLC devices; stored in first two pages of each block on
+         * Micron devices with 2KiB pages and on SLC Samsung, Hynix, Toshiba,
+         * AMD/Spansion, and Macronix.  All others scan only the first page.
+         */
+        if ((chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
+                        (maf_id == NAND_MFR_SAMSUNG ||
+                         maf_id == NAND_MFR_HYNIX))
+                chip->bbt_options |= NAND_BBT_SCANLASTPAGE;
+        else if ((!(chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
+                                (maf_id == NAND_MFR_SAMSUNG ||
+                                 maf_id == NAND_MFR_HYNIX ||
+                                 maf_id == NAND_MFR_TOSHIBA ||
+                                 maf_id == NAND_MFR_AMD ||
+                                 maf_id == NAND_MFR_MACRONIX)) ||
+                        (mtd->writesize == 2048 &&
+                         maf_id == NAND_MFR_MICRON))
+                chip->bbt_options |= NAND_BBT_SCAN2NDPAGE;
+}
+
+/*
  * Get the flash and manufacturer id and lookup if the type is supported.
  */
 static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
@@ -2932,7 +3155,6 @@ static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
 {
         int i, maf_idx;
         u8 id_data[8];
-        int ret;
 
         /* Select the device */
         chip->select_chip(mtd, 0);
@@ -2959,7 +3181,8 @@ static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
 
         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
 
-        for (i = 0; i < 2; i++)
+        /* Read entire ID string */
+        for (i = 0; i < 8; i++)
                 id_data[i] = chip->read_byte(mtd);
 
         if (id_data[0] != *maf_id || id_data[1] != *dev_id) {
@@ -2979,18 +3202,10 @@ static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
         chip->onfi_version = 0;
         if (!type->name || !type->pagesize) {
                 /* Check is chip is ONFI compliant */
-                ret = nand_flash_detect_onfi(mtd, chip, &busw);
-                if (ret)
+                if (nand_flash_detect_onfi(mtd, chip, &busw))
                         goto ident_done;
         }
 
-        chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
-
-        /* Read entire ID string */
-
-        for (i = 0; i < 8; i++)
-                id_data[i] = chip->read_byte(mtd);
-
         if (!type->name)
                 return ERR_PTR(-ENODEV);
 
@@ -3003,86 +3218,13 @@ static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
                 /* Set the pagesize, oobsize, erasesize by the driver */
                 busw = chip->init_size(mtd, chip, id_data);
         } else if (!type->pagesize) {
-                int extid;
-                /* The 3rd id byte holds MLC / multichip data */
-                chip->cellinfo = id_data[2];
-                /* The 4th id byte is the important one */
-                extid = id_data[3];
-
-                /*
-                 * Field definitions are in the following datasheets:
-                 * Old style (4,5 byte ID): Samsung K9GAG08U0M (p.32)
-                 * New style   (6 byte ID): Samsung K9GBG08U0M (p.40)
-                 *
-                 * Check for wraparound + Samsung ID + nonzero 6th byte
-                 * to decide what to do.
-                 */
-                if (id_data[0] == id_data[6] && id_data[1] == id_data[7] &&
-                                id_data[0] == NAND_MFR_SAMSUNG &&
-                                (chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
-                                id_data[5] != 0x00) {
-                        /* Calc pagesize */
-                        mtd->writesize = 2048 << (extid & 0x03);
-                        extid >>= 2;
-                        /* Calc oobsize */
-                        switch (extid & 0x03) {
-                        case 1:
-                                mtd->oobsize = 128;
-                                break;
-                        case 2:
-                                mtd->oobsize = 218;
-                                break;
-                        case 3:
-                                mtd->oobsize = 400;
-                                break;
-                        default:
-                                mtd->oobsize = 436;
-                                break;
-                        }
-                        extid >>= 2;
-                        /* Calc blocksize */
-                        mtd->erasesize = (128 * 1024) <<
-                                (((extid >> 1) & 0x04) | (extid & 0x03));
-                        busw = 0;
-                } else {
-                        /* Calc pagesize */
-                        mtd->writesize = 1024 << (extid & 0x03);
-                        extid >>= 2;
-                        /* Calc oobsize */
-                        mtd->oobsize = (8 << (extid & 0x01)) *
-                                (mtd->writesize >> 9);
-                        extid >>= 2;
-                        /* Calc blocksize. Blocksize is multiples of 64KiB */
-                        mtd->erasesize = (64 * 1024) << (extid & 0x03);
-                        extid >>= 2;
-                        /* Get buswidth information */
-                        busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
-                }
+                /* Decode parameters from extended ID */
+                nand_decode_ext_id(mtd, chip, id_data, &busw);
         } else {
-                /*
-                 * Old devices have chip data hardcoded in the device id table.
-                 */
-                mtd->erasesize = type->erasesize;
-                mtd->writesize = type->pagesize;
-                mtd->oobsize = mtd->writesize / 32;
-                busw = type->options & NAND_BUSWIDTH_16;
-
-                /*
-                 * Check for Spansion/AMD ID + repeating 5th, 6th byte since
-                 * some Spansion chips have erasesize that conflicts with size
-                 * listed in nand_ids table.
-                 * Data sheet (5 byte ID): Spansion S30ML-P ORNAND (p.39)
-                 */
-                if (*maf_id == NAND_MFR_AMD && id_data[4] != 0x00 &&
-                                id_data[5] == 0x00 && id_data[6] == 0x00 &&
-                                id_data[7] == 0x00 && mtd->writesize == 512) {
-                        mtd->erasesize = 128 * 1024;
-                        mtd->erasesize <<= ((id_data[3] & 0x03) << 1);
-                }
+                nand_decode_id(mtd, chip, type, id_data, &busw);
         }
-        /* Get chip options, preserve non chip based options */
-        chip->options &= ~NAND_CHIPOPTIONS_MSK;
-        chip->options |= type->options & NAND_CHIPOPTIONS_MSK;
+        /* Get chip options */
+        chip->options |= type->options;
 
         /*
          * Check if chip is not a Samsung device. Do not clear the
@@ -3112,6 +3254,8 @@ ident_done:
                 return ERR_PTR(-EINVAL);
         }
 
+        nand_decode_bbm_options(mtd, chip, id_data);
+
         /* Calculate the address shift from the page size */
         chip->page_shift = ffs(mtd->writesize) - 1;
         /* Convert chipsize to number of pages per chip -1 */
@@ -3128,33 +3272,6 @@ ident_done:
 
         chip->badblockbits = 8;
 
-        /* Set the bad block position */
-        if (mtd->writesize > 512 || (busw & NAND_BUSWIDTH_16))
-                chip->badblockpos = NAND_LARGE_BADBLOCK_POS;
-        else
-                chip->badblockpos = NAND_SMALL_BADBLOCK_POS;
-
-        /*
-         * Bad block marker is stored in the last page of each block
-         * on Samsung and Hynix MLC devices; stored in first two pages
-         * of each block on Micron devices with 2KiB pages and on
-         * SLC Samsung, Hynix, Toshiba, AMD/Spansion, and Macronix.
-         * All others scan only the first page.
-         */
-        if ((chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
-                        (*maf_id == NAND_MFR_SAMSUNG ||
-                         *maf_id == NAND_MFR_HYNIX))
-                chip->bbt_options |= NAND_BBT_SCANLASTPAGE;
-        else if ((!(chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
-                                (*maf_id == NAND_MFR_SAMSUNG ||
-                                 *maf_id == NAND_MFR_HYNIX ||
-                                 *maf_id == NAND_MFR_TOSHIBA ||
-                                 *maf_id == NAND_MFR_AMD ||
-                                 *maf_id == NAND_MFR_MACRONIX)) ||
-                        (mtd->writesize == 2048 &&
-                         *maf_id == NAND_MFR_MICRON))
-                chip->bbt_options |= NAND_BBT_SCAN2NDPAGE;
-
         /* Check for AND chips with 4 page planes */
         if (chip->options & NAND_4PAGE_ARRAY)
                 chip->erase_cmd = multi_erase_cmd;
@@ -3284,6 +3401,12 @@ int nand_scan_tail(struct mtd_info *mtd)
         if (!chip->write_page)
                 chip->write_page = nand_write_page;
 
+        /* set for ONFI nand */
+        if (!chip->onfi_set_features)
+                chip->onfi_set_features = nand_onfi_set_features;
+        if (!chip->onfi_get_features)
+                chip->onfi_get_features = nand_onfi_get_features;
+
         /*
          * Check ECC mode, default to software if 3byte/512byte hardware ECC is
          * selected and we have 256 byte pagesize fallback to software ECC
@@ -3477,6 +3600,10 @@ int nand_scan_tail(struct mtd_info *mtd)
         /* Invalidate the pagebuffer reference */
         chip->pagebuf = -1;
 
+        /* Large page NAND with SOFT_ECC should support subpage reads */
+        if ((chip->ecc.mode == NAND_ECC_SOFT) && (chip->page_shift > 9))
+                chip->options |= NAND_SUBPAGE_READ;
+
         /* Fill in remaining MTD driver data */
         mtd->type = MTD_NANDFLASH;
         mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM :
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index 30d1319ff065..916d6e9c0ab1 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -4,7 +4,7 @@
  *  Overview:
  *   Bad block table support for the NAND driver
  *
- *  Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
+ *  Copyright © 2004 Thomas Gleixner (tglx@linutronix.de)
  *
  * 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
@@ -22,7 +22,7 @@
  * BBT on flash. If a BBT is found then the contents are read and the memory
  * based BBT is created. If a mirrored BBT is selected then the mirror is
  * searched too and the versions are compared. If the mirror has a greater
- * version number than the mirror BBT is used to build the memory based BBT.
+ * version number, then the mirror BBT is used to build the memory based BBT.
  * If the tables are not versioned, then we "or" the bad block information.
  * If one of the BBTs is out of date or does not exist it is (re)created.
  * If no BBT exists at all then the device is scanned for factory marked
@@ -62,21 +62,20 @@
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/mtd/mtd.h>
+#include <linux/mtd/bbm.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/nand_ecc.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/vmalloc.h>
 #include <linux/export.h>
+#include <linux/string.h>
 
 static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
 {
-        int ret;
-
-        ret = memcmp(buf, td->pattern, td->len);
-        if (!ret)
-                return ret;
-        return -1;
+        if (memcmp(buf, td->pattern, td->len))
+                return -1;
+        return 0;
 }
 
 /**
@@ -92,19 +91,16 @@ static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
  */
 static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
 {
-        int i, end = 0;
+        int end = 0;
         uint8_t *p = buf;
 
         if (td->options & NAND_BBT_NO_OOB)
                 return check_pattern_no_oob(buf, td);
 
         end = paglen + td->offs;
-        if (td->options & NAND_BBT_SCANEMPTY) {
-                for (i = 0; i < end; i++) {
-                        if (p[i] != 0xff)
-                                return -1;
-                }
-        }
+        if (td->options & NAND_BBT_SCANEMPTY)
+                if (memchr_inv(p, 0xff, end))
+                        return -1;
         p += end;
 
         /* Compare the pattern */
@@ -114,10 +110,8 @@ static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_desc
         if (td->options & NAND_BBT_SCANEMPTY) {
                 p += td->len;
                 end += td->len;
-                for (i = end; i < len; i++) {
-                        if (*p++ != 0xff)
-                                return -1;
-                }
+                if (memchr_inv(p, 0xff, len - end))
+                        return -1;
         }
         return 0;
 }
@@ -133,14 +127,9 @@ static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_desc
  */
 static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
 {
-        int i;
-        uint8_t *p = buf;
-
         /* Compare the pattern */
-        for (i = 0; i < td->len; i++) {
-                if (p[td->offs + i] != td->pattern[i])
-                        return -1;
-        }
+        if (memcmp(buf + td->offs, td->pattern, td->len))
+                return -1;
         return 0;
 }
 
@@ -288,7 +277,7 @@ static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_desc
 }
 
 /* BBT marker is in the first page, no OOB */
-static int scan_read_raw_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
+static int scan_read_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
                          struct nand_bbt_descr *td)
 {
         size_t retlen;
@@ -301,14 +290,24 @@ static int scan_read_raw_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
         return mtd_read(mtd, offs, len, &retlen, buf);
 }
 
-/* Scan read raw data from flash */
-static int scan_read_raw_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
+/**
+ * scan_read_oob - [GENERIC] Scan data+OOB region to buffer
+ * @mtd: MTD device structure
+ * @buf: temporary buffer
+ * @offs: offset at which to scan
+ * @len: length of data region to read
+ *
+ * Scan read data from data+OOB. May traverse multiple pages, interleaving
+ * page,OOB,page,OOB,... in buf. Completes transfer and returns the "strongest"
+ * ECC condition (error or bitflip). May quit on the first (non-ECC) error.
+ */
+static int scan_read_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
                          size_t len)
 {
         struct mtd_oob_ops ops;
-        int res;
+        int res, ret = 0;
 
-        ops.mode = MTD_OPS_RAW;
+        ops.mode = MTD_OPS_PLACE_OOB;
         ops.ooboffs = 0;
         ops.ooblen = mtd->oobsize;
 
@@ -318,24 +317,27 @@ static int scan_read_raw_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
                 ops.oobbuf = buf + ops.len;
 
                 res = mtd_read_oob(mtd, offs, &ops);
-
-                if (res)
-                        return res;
+                if (res) {
+                        if (!mtd_is_bitflip_or_eccerr(res))
+                                return res;
+                        else if (mtd_is_eccerr(res) || !ret)
+                                ret = res;
+                }
 
                 buf += mtd->oobsize + mtd->writesize;
                 len -= mtd->writesize;
                 offs += mtd->writesize;
         }
-        return 0;
+        return ret;
 }
 
-static int scan_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
+static int scan_read(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
                          size_t len, struct nand_bbt_descr *td)
 {
         if (td->options & NAND_BBT_NO_OOB)
-                return scan_read_raw_data(mtd, buf, offs, td);
+                return scan_read_data(mtd, buf, offs, td);
         else
-                return scan_read_raw_oob(mtd, buf, offs, len);
+                return scan_read_oob(mtd, buf, offs, len);
 }
 
 /* Scan write data with oob to flash */
@@ -373,14 +375,14 @@ static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
  * Read the bad block table(s) for all chips starting at a given page. We
  * assume that the bbt bits are in consecutive order.
  */
-static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
-                         struct nand_bbt_descr *td, struct nand_bbt_descr *md)
+static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
+                          struct nand_bbt_descr *td, struct nand_bbt_descr *md)
 {
         struct nand_chip *this = mtd->priv;
 
         /* Read the primary version, if available */
         if (td->options & NAND_BBT_VERSION) {
-                scan_read_raw(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
+                scan_read(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
                               mtd->writesize, td);
                 td->version[0] = buf[bbt_get_ver_offs(mtd, td)];
                 pr_info("Bad block table at page %d, version 0x%02X\n",
@@ -389,28 +391,27 @@ static int read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
 
         /* Read the mirror version, if available */
         if (md && (md->options & NAND_BBT_VERSION)) {
-                scan_read_raw(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
-                              mtd->writesize, td);
+                scan_read(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
+                              mtd->writesize, md);
                 md->version[0] = buf[bbt_get_ver_offs(mtd, md)];
                 pr_info("Bad block table at page %d, version 0x%02X\n",
                          md->pages[0], md->version[0]);
         }
-        return 1;
 }
 
 /* Scan a given block full */
 static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
                            loff_t offs, uint8_t *buf, size_t readlen,
-                           int scanlen, int len)
+                           int scanlen, int numpages)
 {
         int ret, j;
 
-        ret = scan_read_raw_oob(mtd, buf, offs, readlen);
+        ret = scan_read_oob(mtd, buf, offs, readlen);
         /* Ignore ECC errors when checking for BBM */
         if (ret && !mtd_is_bitflip_or_eccerr(ret))
                 return ret;
 
-        for (j = 0; j < len; j++, buf += scanlen) {
+        for (j = 0; j < numpages; j++, buf += scanlen) {
                 if (check_pattern(buf, scanlen, mtd->writesize, bd))
                         return 1;
         }
@@ -419,7 +420,7 @@ static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
 
 /* Scan a given block partially */
 static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
-                           loff_t offs, uint8_t *buf, int len)
+                           loff_t offs, uint8_t *buf, int numpages)
 {
         struct mtd_oob_ops ops;
         int j, ret;
@@ -430,7 +431,7 @@ static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
         ops.datbuf = NULL;
         ops.mode = MTD_OPS_PLACE_OOB;
 
-        for (j = 0; j < len; j++) {
+        for (j = 0; j < numpages; j++) {
                 /*
                  * Read the full oob until read_oob is fixed to handle single
                  * byte reads for 16 bit buswidth.
@@ -463,7 +464,7 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
         struct nand_bbt_descr *bd, int chip)
 {
         struct nand_chip *this = mtd->priv;
-        int i, numblocks, len, scanlen;
+        int i, numblocks, numpages, scanlen;
         int startblock;
         loff_t from;
         size_t readlen;
@@ -471,11 +472,11 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
         pr_info("Scanning device for bad blocks\n");
 
         if (bd->options & NAND_BBT_SCANALLPAGES)
-                len = 1 << (this->bbt_erase_shift - this->page_shift);
+                numpages = 1 << (this->bbt_erase_shift - this->page_shift);
         else if (bd->options & NAND_BBT_SCAN2NDPAGE)
-                len = 2;
+                numpages = 2;
         else
-                len = 1;
+                numpages = 1;
 
         if (!(bd->options & NAND_BBT_SCANEMPTY)) {
                 /* We need only read few bytes from the OOB area */
@@ -484,7 +485,7 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
         } else {
                 /* Full page content should be read */
                 scanlen = mtd->writesize + mtd->oobsize;
-                readlen = len * mtd->writesize;
+                readlen = numpages * mtd->writesize;
         }
 
         if (chip == -1) {
@@ -508,7 +509,7 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
         }
 
         if (this->bbt_options & NAND_BBT_SCANLASTPAGE)
-                from += mtd->erasesize - (mtd->writesize * len);
+                from += mtd->erasesize - (mtd->writesize * numpages);
 
         for (i = startblock; i < numblocks;) {
                 int ret;
@@ -517,9 +518,9 @@ static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
 
                 if (bd->options & NAND_BBT_SCANALLPAGES)
                         ret = scan_block_full(mtd, bd, from, buf, readlen,
-                                              scanlen, len);
+                                              scanlen, numpages);
                 else
-                        ret = scan_block_fast(mtd, bd, from, buf, len);
+                        ret = scan_block_fast(mtd, bd, from, buf, numpages);
 
                 if (ret < 0)
                         return ret;
@@ -594,7 +595,7 @@ static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
                         loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
 
                         /* Read first page */
-                        scan_read_raw(mtd, buf, offs, mtd->writesize, td);
+                        scan_read(mtd, buf, offs, mtd->writesize, td);
                         if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
                                 td->pages[i] = actblock << blocktopage;
                                 if (td->options & NAND_BBT_VERSION) {
@@ -626,7 +627,9 @@ static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr
  *
  * Search and read the bad block table(s).
  */
-static int search_read_bbts(struct mtd_info *mtd, uint8_t * buf, struct nand_bbt_descr *td, struct nand_bbt_descr *md)
+static void search_read_bbts(struct mtd_info *mtd, uint8_t *buf,
+                             struct nand_bbt_descr *td,
+                             struct nand_bbt_descr *md)
 {
         /* Search the primary table */
         search_bbt(mtd, buf, td);
@@ -634,9 +637,6 @@ static int search_read_bbts(struct mtd_info *mtd, uint8_t * buf, struct nand_bbt
         /* Search the mirror table */
         if (md)
                 search_bbt(mtd, buf, md);
-
-        /* Force result check */
-        return 1;
 }
 
 /**
@@ -1162,14 +1162,13 @@ int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
 
         /* Is the bbt at a given page? */
         if (td->options & NAND_BBT_ABSPAGE) {
-                res = read_abs_bbts(mtd, buf, td, md);
+                read_abs_bbts(mtd, buf, td, md);
         } else {
                 /* Search the bad block table using a pattern in oob */
-                res = search_read_bbts(mtd, buf, td, md);
+                search_read_bbts(mtd, buf, td, md);
         }
 
-        if (res)
-                res = check_create(mtd, buf, bd);
+        res = check_create(mtd, buf, bd);
 
         /* Prevent the bbt regions from erasing / writing */
         mark_bbt_region(mtd, td);
@@ -1260,7 +1259,7 @@ static struct nand_bbt_descr bbt_main_descr = {
         .offs = 8,
         .len = 4,
         .veroffs = 12,
-        .maxblocks = 4,
+        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
         .pattern = bbt_pattern
 };
 
@@ -1270,27 +1269,27 @@ static struct nand_bbt_descr bbt_mirror_descr = {
         .offs = 8,
         .len = 4,
         .veroffs = 12,
-        .maxblocks = 4,
+        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
         .pattern = mirror_pattern
 };
 
-static struct nand_bbt_descr bbt_main_no_bbt_descr = {
+static struct nand_bbt_descr bbt_main_no_oob_descr = {
         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
                 | NAND_BBT_NO_OOB,
         .len = 4,
         .veroffs = 4,
-        .maxblocks = 4,
+        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
         .pattern = bbt_pattern
 };
 
-static struct nand_bbt_descr bbt_mirror_no_bbt_descr = {
+static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
         .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
                 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
                 | NAND_BBT_NO_OOB,
         .len = 4,
         .veroffs = 4,
-        .maxblocks = 4,
+        .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
         .pattern = mirror_pattern
 };
 
@@ -1355,8 +1354,8 @@ int nand_default_bbt(struct mtd_info *mtd)
                 /* Use the default pattern descriptors */
                 if (!this->bbt_td) {
                         if (this->bbt_options & NAND_BBT_NO_OOB) {
-                                this->bbt_td = &bbt_main_no_bbt_descr;
-                                this->bbt_md = &bbt_mirror_no_bbt_descr;
+                                this->bbt_td = &bbt_main_no_oob_descr;
+                                this->bbt_md = &bbt_mirror_no_oob_descr;
                         } else {
                                 this->bbt_td = &bbt_main_descr;
                                 this->bbt_md = &bbt_mirror_descr;
@@ -1406,3 +1405,4 @@ int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
 
 EXPORT_SYMBOL(nand_scan_bbt);
 EXPORT_SYMBOL(nand_default_bbt);
+EXPORT_SYMBOL_GPL(nand_update_bbt);
diff --git a/drivers/mtd/nand/nand_bcm_umi.c b/drivers/mtd/nand/nand_bcm_umi.c
deleted file mode 100644
index 46a6bc9c4b74..000000000000
--- a/drivers/mtd/nand/nand_bcm_umi.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*****************************************************************************
-* Copyright 2004 - 2009 Broadcom Corporation.  All rights reserved.
-*
-* Unless you and Broadcom execute a separate written software license
-* agreement governing use of this software, this software is licensed to you
-* under the terms of the GNU General Public License version 2, available at
-* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
-*
-* Notwithstanding the above, under no circumstances may you combine this
-* software in any way with any other Broadcom software provided under a
-* license other than the GPL, without Broadcom's express prior written
-* consent.
-*****************************************************************************/
-
-/* ---- Include Files ---------------------------------------------------- */
-#include <mach/reg_umi.h>
-#include "nand_bcm_umi.h"
-#ifdef BOOT0_BUILD
-#include <uart.h>
-#endif
-
-/* ---- External Variable Declarations ----------------------------------- */
-/* ---- External Function Prototypes ------------------------------------- */
-/* ---- Public Variables ------------------------------------------------- */
-/* ---- Private Constants and Types -------------------------------------- */
-/* ---- Private Function Prototypes -------------------------------------- */
-/* ---- Private Variables ------------------------------------------------ */
-/* ---- Private Functions ------------------------------------------------ */
-
-#if NAND_ECC_BCH
-/****************************************************************************
-*  nand_bch_ecc_flip_bit - Routine to flip an errored bit
-*
-*  PURPOSE:
-*     This is a helper routine that flips the bit (0 -> 1 or 1 -> 0) of the
-*     errored bit specified
-*
-*  PARAMETERS:
-*     datap - Container that holds the 512 byte data
-*     errorLocation - Location of the bit that needs to be flipped
-*
-*  RETURNS:
-*     None
-****************************************************************************/
-static void nand_bcm_umi_bch_ecc_flip_bit(uint8_t *datap, int errorLocation)
-{
-        int locWithinAByte = (errorLocation & REG_UMI_BCH_ERR_LOC_BYTE) >> 0;
-        int locWithinAWord = (errorLocation & REG_UMI_BCH_ERR_LOC_WORD) >> 3;
-        int locWithinAPage = (errorLocation & REG_UMI_BCH_ERR_LOC_PAGE) >> 5;
-
-        uint8_t errorByte = 0;
-        uint8_t byteMask = 1 << locWithinAByte;
-
-        /* BCH uses big endian, need to change the location
-         * bits to little endian */
-        locWithinAWord = 3 - locWithinAWord;
-
-        errorByte = datap[locWithinAPage * sizeof(uint32_t) + locWithinAWord];
-
-#ifdef BOOT0_BUILD
-        puthexs("\nECC Correct Offset: ",
-                locWithinAPage * sizeof(uint32_t) + locWithinAWord);
-        puthexs(" errorByte:", errorByte);
-        puthex8(" Bit: ", locWithinAByte);
-#endif
-
-        if (errorByte & byteMask) {
-                /* bit needs to be cleared */
-                errorByte &= ~byteMask;
-        } else {
-                /* bit needs to be set */
-                errorByte |= byteMask;
-        }
-
-        /* write back the value with the fixed bit */
-        datap[locWithinAPage * sizeof(uint32_t) + locWithinAWord] = errorByte;
-}
-
-/****************************************************************************
-*  nand_correct_page_bch - Routine to correct bit errors when reading NAND
-*
-*  PURPOSE:
-*     This routine reads the BCH registers to determine if there are any bit
-*     errors during the read of the last 512 bytes of data + ECC bytes.  If
-*     errors exists, the routine fixes it.
-*
-*  PARAMETERS:
-*     datap - Container that holds the 512 byte data
-*
-*  RETURNS:
-*     0 or greater = Number of errors corrected
-*                    (No errors are found or errors have been fixed)
-*    -1 = Error(s) cannot be fixed
-****************************************************************************/
-int nand_bcm_umi_bch_correct_page(uint8_t *datap, uint8_t *readEccData,
-                                  int numEccBytes)
-{
-        int numErrors;
-        int errorLocation;
-        int idx;
-        uint32_t regValue;
-
-        /* wait for read ECC to be valid */
-        regValue = nand_bcm_umi_bch_poll_read_ecc_calc();
-
-        /*
-         * read the control status register to determine if there
-         * are error'ed bits
-         * see if errors are correctible
-         */
-        if ((regValue & REG_UMI_BCH_CTRL_STATUS_UNCORR_ERR) > 0) {
-                int i;
-
-                for (i = 0; i < numEccBytes; i++) {
-                        if (readEccData[i] != 0xff) {
-                                /* errors cannot be fixed, return -1 */
-                                return -1;
-                        }
-                }
-                /* If ECC is unprogrammed then we can't correct,
-                 * assume everything OK */
-                return 0;
-        }
-
-        if ((regValue & REG_UMI_BCH_CTRL_STATUS_CORR_ERR) == 0) {
-                /* no errors */
-                return 0;
-        }
-
-        /*
-         * Fix errored bits by doing the following:
-         * 1. Read the number of errors in the control and status register
-         * 2. Read the error location registers that corresponds to the number
-         *    of errors reported
-         * 3. Invert the bit in the data
-         */
-        numErrors = (regValue & REG_UMI_BCH_CTRL_STATUS_NB_CORR_ERROR) >> 20;
-
-        for (idx = 0; idx < numErrors; idx++) {
-                errorLocation =
-                    REG_UMI_BCH_ERR_LOC_ADDR(idx) & REG_UMI_BCH_ERR_LOC_MASK;
-
-                /* Flip bit */
-                nand_bcm_umi_bch_ecc_flip_bit(datap, errorLocation);
-        }
-        /* Errors corrected */
-        return numErrors;
-}
-#endif
diff --git a/drivers/mtd/nand/nand_bcm_umi.h b/drivers/mtd/nand/nand_bcm_umi.h
deleted file mode 100644
index d90186684db8..000000000000
--- a/drivers/mtd/nand/nand_bcm_umi.h
+++ /dev/null
@@ -1,336 +0,0 @@
-/*****************************************************************************
-* Copyright 2003 - 2009 Broadcom Corporation.  All rights reserved.
-*
-* Unless you and Broadcom execute a separate written software license
-* agreement governing use of this software, this software is licensed to you
-* under the terms of the GNU General Public License version 2, available at
-* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
-*
-* Notwithstanding the above, under no circumstances may you combine this
-* software in any way with any other Broadcom software provided under a
-* license other than the GPL, without Broadcom's express prior written
-* consent.
-*****************************************************************************/
-#ifndef NAND_BCM_UMI_H
-#define NAND_BCM_UMI_H
-
-/* ---- Include Files ---------------------------------------------------- */
-#include <mach/reg_umi.h>
-#include <mach/reg_nand.h>
-#include <mach/cfg_global.h>
-
-/* ---- Constants and Types ---------------------------------------------- */
-#if (CFG_GLOBAL_CHIP_FAMILY == CFG_GLOBAL_CHIP_FAMILY_BCMRING)
-#define NAND_ECC_BCH (CFG_GLOBAL_CHIP_REV > 0xA0)
-#else
-#define NAND_ECC_BCH 0
-#endif
-
-#define CFG_GLOBAL_NAND_ECC_BCH_NUM_BYTES       13
-
-#if NAND_ECC_BCH
-#ifdef BOOT0_BUILD
-#define NAND_ECC_NUM_BYTES 13
-#else
-#define NAND_ECC_NUM_BYTES CFG_GLOBAL_NAND_ECC_BCH_NUM_BYTES
-#endif
-#else
-#define NAND_ECC_NUM_BYTES 3
-#endif
-
-#define NAND_DATA_ACCESS_SIZE 512
-
-/* ---- Variable Externs ------------------------------------------ */
-/* ---- Function Prototypes --------------------------------------- */
-int nand_bcm_umi_bch_correct_page(uint8_t *datap, uint8_t *readEccData,
-                                  int numEccBytes);
-
-/* Check in device is ready */
-static inline int nand_bcm_umi_dev_ready(void)
-{
-        return readl(&REG_UMI_NAND_RCSR) & REG_UMI_NAND_RCSR_RDY;
-}
-
-/* Wait until device is ready */
-static inline void nand_bcm_umi_wait_till_ready(void)
-{
-        while (nand_bcm_umi_dev_ready() == 0)
-                ;
-}
-
-/* Enable Hamming ECC */
-static inline void nand_bcm_umi_hamming_enable_hwecc(void)
-{
-        /* disable and reset ECC, 512 byte page */
-        writel(readl(&REG_UMI_NAND_ECC_CSR) & ~(REG_UMI_NAND_ECC_CSR_ECC_ENABLE |
-                REG_UMI_NAND_ECC_CSR_256BYTE), &REG_UMI_NAND_ECC_CSR);
-        /* enable ECC */
-        writel(readl(&REG_UMI_NAND_ECC_CSR) | REG_UMI_NAND_ECC_CSR_ECC_ENABLE,
-                &REG_UMI_NAND_ECC_CSR);
-}
-
-#if NAND_ECC_BCH
-/* BCH ECC specifics */
-#define ECC_BITS_PER_CORRECTABLE_BIT 13
-
-/* Enable BCH Read ECC */
-static inline void nand_bcm_umi_bch_enable_read_hwecc(void)
-{
-        /* disable and reset ECC */
-        writel(REG_UMI_BCH_CTRL_STATUS_RD_ECC_VALID, &REG_UMI_BCH_CTRL_STATUS);
-        /* Turn on ECC */
-        writel(REG_UMI_BCH_CTRL_STATUS_ECC_RD_EN, &REG_UMI_BCH_CTRL_STATUS);
-}
-
-/* Enable BCH Write ECC */
-static inline void nand_bcm_umi_bch_enable_write_hwecc(void)
-{
-        /* disable and reset ECC */
-        writel(REG_UMI_BCH_CTRL_STATUS_WR_ECC_VALID, &REG_UMI_BCH_CTRL_STATUS);
-        /* Turn on ECC */
-        writel(REG_UMI_BCH_CTRL_STATUS_ECC_WR_EN, &REG_UMI_BCH_CTRL_STATUS);
-}
-
-/* Config number of BCH ECC bytes */
-static inline void nand_bcm_umi_bch_config_ecc(uint8_t numEccBytes)
-{
-        uint32_t nValue;
-        uint32_t tValue;
-        uint32_t kValue;
-        uint32_t numBits = numEccBytes * 8;
-
-        /* disable and reset ECC */
-        writel(REG_UMI_BCH_CTRL_STATUS_WR_ECC_VALID |
-               REG_UMI_BCH_CTRL_STATUS_RD_ECC_VALID,
-               &REG_UMI_BCH_CTRL_STATUS);
-
-        /* Every correctible bit requires 13 ECC bits */
-        tValue = (uint32_t) (numBits / ECC_BITS_PER_CORRECTABLE_BIT);
-
-        /* Total data in number of bits for generating and computing BCH ECC */
-        nValue = (NAND_DATA_ACCESS_SIZE + numEccBytes) * 8;
-
-        /* K parameter is used internally.  K = N - (T * 13) */
-        kValue = nValue - (tValue * ECC_BITS_PER_CORRECTABLE_BIT);
-
-        /* Write the settings */
-        writel(nValue, &REG_UMI_BCH_N);
-        writel(tValue, &REG_UMI_BCH_T);
-        writel(kValue, &REG_UMI_BCH_K);
-}
-
-/* Pause during ECC read calculation to skip bytes in OOB */
-static inline void nand_bcm_umi_bch_pause_read_ecc_calc(void)
-{
-        writel(REG_UMI_BCH_CTRL_STATUS_ECC_RD_EN | REG_UMI_BCH_CTRL_STATUS_PAUSE_ECC_DEC, &REG_UMI_BCH_CTRL_STATUS);
-}
-
-/* Resume during ECC read calculation after skipping bytes in OOB */
-static inline void nand_bcm_umi_bch_resume_read_ecc_calc(void)
-{
-        writel(REG_UMI_BCH_CTRL_STATUS_ECC_RD_EN, &REG_UMI_BCH_CTRL_STATUS);
-}
-
-/* Poll read ECC calc to check when hardware completes */
-static inline uint32_t nand_bcm_umi_bch_poll_read_ecc_calc(void)
-{
-        uint32_t regVal;
-
-        do {
-                /* wait for ECC to be valid */
-                regVal = readl(&REG_UMI_BCH_CTRL_STATUS);
-        } while ((regVal & REG_UMI_BCH_CTRL_STATUS_RD_ECC_VALID) == 0);
-
-        return regVal;
-}
-
-/* Poll write ECC calc to check when hardware completes */
-static inline void nand_bcm_umi_bch_poll_write_ecc_calc(void)
-{
-        /* wait for ECC to be valid */
-        while ((readl(&REG_UMI_BCH_CTRL_STATUS) & REG_UMI_BCH_CTRL_STATUS_WR_ECC_VALID)
-               == 0)
-                ;
-}
-
-/* Read the OOB and ECC, for kernel write OOB to a buffer */
-#if defined(__KERNEL__) && !defined(STANDALONE)
-static inline void nand_bcm_umi_bch_read_oobEcc(uint32_t pageSize,
-        uint8_t *eccCalc, int numEccBytes, uint8_t *oobp)
-#else
-static inline void nand_bcm_umi_bch_read_oobEcc(uint32_t pageSize,
-        uint8_t *eccCalc, int numEccBytes)
-#endif
-{
-        int eccPos = 0;
-        int numToRead = 16;     /* There are 16 bytes per sector in the OOB */
-
-        /* ECC is already paused when this function is called */
-        if (pageSize != NAND_DATA_ACCESS_SIZE) {
-                /* skip BI */
-#if defined(__KERNEL__) && !defined(STANDALONE)
-                *oobp++ = readb(&REG_NAND_DATA8);
-#else
-                readb(&REG_NAND_DATA8);
-#endif
-                numToRead--;
-        }
-
-        while (numToRead > numEccBytes) {
-                /* skip free oob region */
-#if defined(__KERNEL__) && !defined(STANDALONE)
-                *oobp++ = readb(&REG_NAND_DATA8);
-#else
-                readb(&REG_NAND_DATA8);
-#endif
-                numToRead--;
-        }
-
-        if (pageSize == NAND_DATA_ACCESS_SIZE) {
-                /* read ECC bytes before BI */
-                nand_bcm_umi_bch_resume_read_ecc_calc();
-
-                while (numToRead > 11) {
-#if defined(__KERNEL__) && !defined(STANDALONE)
-                        *oobp = readb(&REG_NAND_DATA8);
-                        eccCalc[eccPos++] = *oobp;
-                        oobp++;
-#else
-                        eccCalc[eccPos++] = readb(&REG_NAND_DATA8);
-#endif
-                        numToRead--;
-                }
-
-                nand_bcm_umi_bch_pause_read_ecc_calc();
-
-                if (numToRead == 11) {
-                        /* read BI */
-#if defined(__KERNEL__) && !defined(STANDALONE)
-                        *oobp++ = readb(&REG_NAND_DATA8);
-#else
-                        readb(&REG_NAND_DATA8);
-#endif
-                        numToRead--;
-                }
-
-        }
-        /* read ECC bytes */
-        nand_bcm_umi_bch_resume_read_ecc_calc();
-        while (numToRead) {
-#if defined(__KERNEL__) && !defined(STANDALONE)
-                *oobp = readb(&REG_NAND_DATA8);
-                eccCalc[eccPos++] = *oobp;
-                oobp++;
-#else
-                eccCalc[eccPos++] = readb(&REG_NAND_DATA8);
-#endif
-                numToRead--;
-        }
-}
-
-/* Helper function to write ECC */
-static inline void NAND_BCM_UMI_ECC_WRITE(int numEccBytes, int eccBytePos,
-                                          uint8_t *oobp, uint8_t eccVal)
-{
-        if (eccBytePos <= numEccBytes)
-                *oobp = eccVal;
-}
-
-/* Write OOB with ECC */
-static inline void nand_bcm_umi_bch_write_oobEcc(uint32_t pageSize,
-                                                 uint8_t *oobp, int numEccBytes)
-{
-        uint32_t eccVal = 0xffffffff;
-
-        /* wait for write ECC to be valid */
-        nand_bcm_umi_bch_poll_write_ecc_calc();
-
-        /*
-         ** Get the hardware ecc from the 32-bit result registers.
-         ** Read after 512 byte accesses. Format B3B2B1B0
-         ** where B3 = ecc3, etc.
-         */
-
-        if (pageSize == NAND_DATA_ACCESS_SIZE) {
-                /* Now fill in the ECC bytes */
-                if (numEccBytes >= 13)
-                        eccVal = readl(&REG_UMI_BCH_WR_ECC_3);
-
-                /* Usually we skip CM in oob[0,1] */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 15, &oobp[0],
-                        (eccVal >> 16) & 0xff);
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 14, &oobp[1],
-                        (eccVal >> 8) & 0xff);
-
-                /* Write ECC in oob[2,3,4] */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 13, &oobp[2],
-                        eccVal & 0xff); /* ECC 12 */
-
-                if (numEccBytes >= 9)
-                        eccVal = readl(&REG_UMI_BCH_WR_ECC_2);
-
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 12, &oobp[3],
-                        (eccVal >> 24) & 0xff); /* ECC11 */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 11, &oobp[4],
-                        (eccVal >> 16) & 0xff); /* ECC10 */
-
-                /* Always Skip BI in oob[5] */
-        } else {
-                /* Always Skip BI in oob[0] */
-
-                /* Now fill in the ECC bytes */
-                if (numEccBytes >= 13)
-                        eccVal = readl(&REG_UMI_BCH_WR_ECC_3);
-
-                /* Usually skip CM in oob[1,2] */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 15, &oobp[1],
-                        (eccVal >> 16) & 0xff);
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 14, &oobp[2],
-                        (eccVal >> 8) & 0xff);
-
-                /* Write ECC in oob[3-15] */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 13, &oobp[3],
-                        eccVal & 0xff); /* ECC12 */
-
-                if (numEccBytes >= 9)
-                        eccVal = readl(&REG_UMI_BCH_WR_ECC_2);
-
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 12, &oobp[4],
-                        (eccVal >> 24) & 0xff); /* ECC11 */
-                NAND_BCM_UMI_ECC_WRITE(numEccBytes, 11, &oobp[5],
-                        (eccVal >> 16) & 0xff); /* ECC10 */
-        }
-
-        /* Fill in the remainder of ECC locations */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 10, &oobp[6],
-                (eccVal >> 8) & 0xff);  /* ECC9 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 9, &oobp[7],
-                eccVal & 0xff); /* ECC8 */
-
-        if (numEccBytes >= 5)
-                eccVal = readl(&REG_UMI_BCH_WR_ECC_1);
-
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 8, &oobp[8],
-                (eccVal >> 24) & 0xff); /* ECC7 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 7, &oobp[9],
-                (eccVal >> 16) & 0xff); /* ECC6 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 6, &oobp[10],
-                (eccVal >> 8) & 0xff);  /* ECC5 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 5, &oobp[11],
-                eccVal & 0xff); /* ECC4 */
-
-        if (numEccBytes >= 1)
-                eccVal = readl(&REG_UMI_BCH_WR_ECC_0);
-
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 4, &oobp[12],
-                (eccVal >> 24) & 0xff); /* ECC3 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 3, &oobp[13],
-                (eccVal >> 16) & 0xff); /* ECC2 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 2, &oobp[14],
-                (eccVal >> 8) & 0xff);  /* ECC1 */
-        NAND_BCM_UMI_ECC_WRITE(numEccBytes, 1, &oobp[15],
-                eccVal & 0xff); /* ECC0 */
-}
-#endif
-
-#endif /* NAND_BCM_UMI_H */
diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c
index 621b70b7a159..e3aa2748a6e7 100644
--- a/drivers/mtd/nand/nand_ids.c
+++ b/drivers/mtd/nand/nand_ids.c
@@ -70,7 +70,7 @@ struct nand_flash_dev nand_flash_ids[] = {
          * These are the new chips with large page size. The pagesize and the
          * erasesize is determined from the extended id bytes
          */
-#define LP_OPTIONS (NAND_SAMSUNG_LP_OPTIONS | NAND_NO_READRDY)
+#define LP_OPTIONS NAND_SAMSUNG_LP_OPTIONS
 #define LP_OPTIONS16 (LP_OPTIONS | NAND_BUSWIDTH_16)
 
         /* 512 Megabit */
@@ -157,7 +157,7 @@ struct nand_flash_dev nand_flash_ids[] = {
          * writes possible, but not implemented now
          */
         {"AND 128MiB 3,3V 8-bit",       0x01, 2048, 128, 0x4000,
-         NAND_IS_AND | NAND_NO_READRDY | NAND_4PAGE_ARRAY | BBT_AUTO_REFRESH},
+         NAND_IS_AND | NAND_4PAGE_ARRAY | BBT_AUTO_REFRESH},
 
         {NULL,}
 };
@@ -174,8 +174,9 @@ struct nand_manufacturers nand_manuf_ids[] = {
         {NAND_MFR_STMICRO, "ST Micro"},
         {NAND_MFR_HYNIX, "Hynix"},
         {NAND_MFR_MICRON, "Micron"},
-        {NAND_MFR_AMD, "AMD"},
+        {NAND_MFR_AMD, "AMD/Spansion"},
         {NAND_MFR_MACRONIX, "Macronix"},
+        {NAND_MFR_EON, "Eon"},
         {0x0, "Unknown"}
 };
 
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index cf0cd3146817..a932c485eb04 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -447,8 +447,6 @@ static unsigned int rptwear_cnt = 0;
 /* MTD structure for NAND controller */
 static struct mtd_info *nsmtd;
 
-static u_char ns_verify_buf[NS_LARGEST_PAGE_SIZE];
-
 /*
  * Allocate array of page pointers, create slab allocation for an array
  * and initialize the array by NULL pointers.
@@ -2189,19 +2187,6 @@ static void ns_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         return;
 }
 
-static int ns_nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        ns_nand_read_buf(mtd, (u_char *)&ns_verify_buf[0], len);
-
-        if (!memcmp(buf, &ns_verify_buf[0], len)) {
-                NS_DBG("verify_buf: the buffer is OK\n");
-                return 0;
-        } else {
-                NS_DBG("verify_buf: the buffer is wrong\n");
-                return -EFAULT;
-        }
-}
-
 /*
  * Module initialization function
  */
@@ -2236,7 +2221,6 @@ static int __init ns_init_module(void)
         chip->dev_ready  = ns_device_ready;
         chip->write_buf  = ns_nand_write_buf;
         chip->read_buf   = ns_nand_read_buf;
-        chip->verify_buf = ns_nand_verify_buf;
         chip->read_word  = ns_nand_read_word;
         chip->ecc.mode   = NAND_ECC_SOFT;
         /* The NAND_SKIP_BBTSCAN option is necessary for 'overridesize' */
@@ -2333,6 +2317,7 @@ static int __init ns_init_module(void)
                 uint64_t new_size = (uint64_t)nsmtd->erasesize << overridesize;
                 if (new_size >> overridesize != nsmtd->erasesize) {
                         NS_ERR("overridesize is too big\n");
+                        retval = -EINVAL;
                         goto err_exit;
                 }
                 /* N.B. This relies on nand_scan not doing anything with the size before we change it */
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index 2b6f632cf274..5fd3f010e3ae 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -140,18 +140,6 @@ static void ndfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
                 out_be32(ndfc->ndfcbase + NDFC_DATA, *p++);
 }
 
-static int ndfc_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
-{
-        struct nand_chip *chip = mtd->priv;
-        struct ndfc_controller *ndfc = chip->priv;
-        uint32_t *p = (uint32_t *) buf;
-
-        for(;len > 0; len -= 4)
-                if (*p++ != in_be32(ndfc->ndfcbase + NDFC_DATA))
-                        return -EFAULT;
-        return 0;
-}
-
 /*
  * Initialize chip structure
  */
@@ -172,7 +160,6 @@ static int ndfc_chip_init(struct ndfc_controller *ndfc,
         chip->controller = &ndfc->ndfc_control;
         chip->read_buf = ndfc_read_buf;
         chip->write_buf = ndfc_write_buf;
-        chip->verify_buf = ndfc_verify_buf;
         chip->ecc.correct = nand_correct_data;
         chip->ecc.hwctl = ndfc_enable_hwecc;
         chip->ecc.calculate = ndfc_calculate_ecc;
diff --git a/drivers/mtd/nand/nuc900_nand.c b/drivers/mtd/nand/nuc900_nand.c
index 8febe46e1105..94dc46bc118c 100644
--- a/drivers/mtd/nand/nuc900_nand.c
+++ b/drivers/mtd/nand/nuc900_nand.c
@@ -112,22 +112,6 @@ static void nuc900_nand_write_buf(struct mtd_info *mtd,
                 write_data_reg(nand, buf[i]);
 }
 
-static int nuc900_verify_buf(struct mtd_info *mtd,
-                             const unsigned char *buf, int len)
-{
-        int i;
-        struct nuc900_nand *nand;
-
-        nand = container_of(mtd, struct nuc900_nand, mtd);
-
-        for (i = 0; i < len; i++) {
-                if (buf[i] != (unsigned char)read_data_reg(nand))
-                        return -EFAULT;
-        }
-
-        return 0;
-}
-
 static int nuc900_check_rb(struct nuc900_nand *nand)
 {
         unsigned int val;
@@ -292,7 +276,6 @@ static int __devinit nuc900_nand_probe(struct platform_device *pdev)
         chip->read_byte         = nuc900_nand_read_byte;
         chip->write_buf         = nuc900_nand_write_buf;
         chip->read_buf          = nuc900_nand_read_buf;
-        chip->verify_buf        = nuc900_verify_buf;
         chip->chip_delay        = 50;
         chip->options           = 0;
         chip->ecc.mode          = NAND_ECC_SOFT;
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index fc8111278d12..5b3138620646 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -425,7 +425,7 @@ static void omap_nand_dma_callback(void *data)
 }
 
 /*
- * omap_nand_dma_transfer: configer and start dma transfer
+ * omap_nand_dma_transfer: configure and start dma transfer
  * @mtd: MTD device structure
  * @addr: virtual address in RAM of source/destination
  * @len: number of data bytes to be transferred
@@ -546,7 +546,7 @@ static void omap_write_buf_dma_pref(struct mtd_info *mtd,
 }
 
 /*
- * omap_nand_irq - GMPC irq handler
+ * omap_nand_irq - GPMC irq handler
  * @this_irq: gpmc irq number
  * @dev: omap_nand_info structure pointer is passed here
  */
@@ -698,27 +698,6 @@ out_copy:
 }
 
 /**
- * omap_verify_buf - Verify chip data against buffer
- * @mtd: MTD device structure
- * @buf: buffer containing the data to compare
- * @len: number of bytes to compare
- */
-static int omap_verify_buf(struct mtd_info *mtd, const u_char * buf, int len)
-{
-        struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
-                                                        mtd);
-        u16 *p = (u16 *) buf;
-
-        len >>= 1;
-        while (len--) {
-                if (*p++ != cpu_to_le16(readw(info->nand.IO_ADDR_R)))
-                        return -EFAULT;
-        }
-
-        return 0;
-}
-
-/**
  * gen_true_ecc - This function will generate true ECC value
  * @ecc_buf: buffer to store ecc code
  *
@@ -1326,8 +1305,8 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
 
         /*
          * If RDY/BSY line is connected to OMAP then use the omap ready
-         * funcrtion and the generic nand_wait function which reads the status
-         * register after monitoring the RDY/BSY line.Otherwise use a standard
+         * function and the generic nand_wait function which reads the status
+         * register after monitoring the RDY/BSY line. Otherwise use a standard
          * chip delay which is slightly more than tR (AC Timing) of the NAND
          * device and read status register until you get a failure or success
          */
@@ -1428,9 +1407,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
                 goto out_release_mem_region;
         }
 
-        info->nand.verify_buf = omap_verify_buf;
-
-        /* selsect the ecc type */
+        /* select the ecc type */
         if (pdata->ecc_opt == OMAP_ECC_HAMMING_CODE_DEFAULT)
                 info->nand.ecc.mode = NAND_ECC_SOFT;
         else if ((pdata->ecc_opt == OMAP_ECC_HAMMING_CODE_HW) ||
@@ -1536,7 +1513,8 @@ static int omap_nand_remove(struct platform_device *pdev)
         /* Release NAND device, its internal structures and partitions */
         nand_release(&info->mtd);
         iounmap(info->nand.IO_ADDR_R);
-        kfree(&info->mtd);
+        release_mem_region(info->phys_base, NAND_IO_SIZE);
+        kfree(info);
         return 0;
 }
 
diff --git a/drivers/mtd/nand/orion_nand.c b/drivers/mtd/nand/orion_nand.c
index 131b58a133f1..aefaf8cd31ef 100644
--- a/drivers/mtd/nand/orion_nand.c
+++ b/drivers/mtd/nand/orion_nand.c
@@ -21,7 +21,6 @@
 #include <linux/err.h>
 #include <asm/io.h>
 #include <asm/sizes.h>
-#include <mach/hardware.h>
 #include <linux/platform_data/mtd-orion_nand.h>
 
 static void orion_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
diff --git a/drivers/mtd/nand/plat_nand.c b/drivers/mtd/nand/plat_nand.c
index 1bcb52040422..a47ee68a0cfa 100644
--- a/drivers/mtd/nand/plat_nand.c
+++ b/drivers/mtd/nand/plat_nand.c
@@ -37,6 +37,11 @@ static int __devinit plat_nand_probe(struct platform_device *pdev)
         const char **part_types;
         int err = 0;
 
+        if (!pdata) {
+                dev_err(&pdev->dev, "platform_nand_data is missing\n");
+                return -EINVAL;
+        }
+
         if (pdata->chip.nr_chips < 1) {
                 dev_err(&pdev->dev, "invalid number of chips specified\n");
                 return -EINVAL;
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index c45227173efd..37ee75c7bacb 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -683,11 +683,13 @@ static void pxa3xx_nand_cmdfunc(struct mtd_info *mtd, unsigned command,
         info->state = STATE_IDLE;
 }
 
-static void pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
+static int pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
                 struct nand_chip *chip, const uint8_t *buf, int oob_required)
 {
         chip->write_buf(mtd, buf, mtd->writesize);
         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+
+        return 0;
 }
 
 static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
@@ -771,12 +773,6 @@ static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
         info->buf_start += real_len;
 }
 
-static int pxa3xx_nand_verify_buf(struct mtd_info *mtd,
-                const uint8_t *buf, int len)
-{
-        return 0;
-}
-
 static void pxa3xx_nand_select_chip(struct mtd_info *mtd, int chip)
 {
         return;
@@ -1007,7 +1003,6 @@ KEEP_CONFIG:
         chip->ecc.size = host->page_size;
         chip->ecc.strength = 1;
 
-        chip->options |= NAND_NO_READRDY;
         if (host->reg_ndcr & NDCR_DWIDTH_M)
                 chip->options |= NAND_BUSWIDTH_16;
 
@@ -1070,7 +1065,6 @@ static int alloc_nand_resource(struct platform_device *pdev)
                 chip->read_byte         = pxa3xx_nand_read_byte;
                 chip->read_buf          = pxa3xx_nand_read_buf;
                 chip->write_buf         = pxa3xx_nand_write_buf;
-                chip->verify_buf        = pxa3xx_nand_verify_buf;
         }
 
         spin_lock_init(&chip->controller->lock);
diff --git a/drivers/mtd/nand/r852.c b/drivers/mtd/nand/r852.c
index 8cb627751c9c..4495f8551fa0 100644
--- a/drivers/mtd/nand/r852.c
+++ b/drivers/mtd/nand/r852.c
@@ -309,27 +309,6 @@ static uint8_t r852_read_byte(struct mtd_info *mtd)
         return r852_read_reg(dev, R852_DATALINE);
 }
 
-
-/*
- * Readback the buffer to verify it
- */
-int r852_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
-{
-        struct r852_device *dev = r852_get_dev(mtd);
-
-        /* We can't be sure about anything here... */
-        if (dev->card_unstable)
-                return -1;
-
-        /* This will never happen, unless you wired up a nand chip
-                with > 512 bytes page size to the reader */
-        if (len > SM_SECTOR_SIZE)
-                return 0;
-
-        r852_read_buf(mtd, dev->tmp_buffer, len);
-        return memcmp(buf, dev->tmp_buffer, len);
-}
-
 /*
  * Control several chip lines & send commands
  */
@@ -882,7 +861,6 @@ int  r852_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
         chip->read_byte = r852_read_byte;
         chip->read_buf = r852_read_buf;
         chip->write_buf = r852_write_buf;
-        chip->verify_buf = r852_verify_buf;
 
         /* ecc */
         chip->ecc.mode = NAND_ECC_HW_SYNDROME;
diff --git a/drivers/mtd/nand/s3c2410.c b/drivers/mtd/nand/s3c2410.c
index d8040619ad8d..295e4bedad96 100644
--- a/drivers/mtd/nand/s3c2410.c
+++ b/drivers/mtd/nand/s3c2410.c
@@ -21,6 +21,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
+#define pr_fmt(fmt) "nand-s3c2410: " fmt
+
 #ifdef CONFIG_MTD_NAND_S3C2410_DEBUG
 #define DEBUG
 #endif
@@ -30,6 +32,7 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
@@ -43,24 +46,9 @@
 #include <linux/mtd/nand_ecc.h>
 #include <linux/mtd/partitions.h>
 
-#include <asm/io.h>
-
 #include <plat/regs-nand.h>
 #include <linux/platform_data/mtd-nand-s3c2410.h>
 
-#ifdef CONFIG_MTD_NAND_S3C2410_HWECC
-static int hardware_ecc = 1;
-#else
-static int hardware_ecc = 0;
-#endif
-
-#ifdef CONFIG_MTD_NAND_S3C2410_CLKSTOP
-static const int clock_stop = 1;
-#else
-static const int clock_stop = 0;
-#endif
-
-
 /* new oob placement block for use with hardware ecc generation
  */
 
@@ -109,9 +97,8 @@ enum s3c_nand_clk_state {
  * @mtds: An array of MTD instances on this controoler.
  * @platform: The platform data for this board.
  * @device: The platform device we bound to.
- * @area: The IO area resource that came from request_mem_region().
  * @clk: The clock resource for this controller.
- * @regs: The area mapped for the hardware registers described by @area.
+ * @regs: The area mapped for the hardware registers.
  * @sel_reg: Pointer to the register controlling the NAND selection.
  * @sel_bit: The bit in @sel_reg to select the NAND chip.
  * @mtd_count: The number of MTDs created from this controller.
@@ -128,7 +115,6 @@ struct s3c2410_nand_info {
 
         /* device info */
         struct device                   *device;
-        struct resource                 *area;
         struct clk                      *clk;
         void __iomem                    *regs;
         void __iomem                    *sel_reg;
@@ -169,7 +155,11 @@ static struct s3c2410_platform_nand *to_nand_plat(struct platform_device *dev)
 
 static inline int allow_clk_suspend(struct s3c2410_nand_info *info)
 {
-        return clock_stop;
+#ifdef CONFIG_MTD_NAND_S3C2410_CLKSTOP
+        return 1;
+#else
+        return 0;
+#endif
 }
 
 /**
@@ -215,7 +205,8 @@ static int s3c_nand_calc_rate(int wanted, unsigned long clk, int max)
         pr_debug("result %d from %ld, %d\n", result, clk, wanted);
 
         if (result > max) {
-                printk("%d ns is too big for current clock rate %ld\n", wanted, clk);
+                pr_err("%d ns is too big for current clock rate %ld\n",
+                        wanted, clk);
                 return -1;
         }
 
@@ -225,7 +216,7 @@ static int s3c_nand_calc_rate(int wanted, unsigned long clk, int max)
         return result;
 }
 
-#define to_ns(ticks,clk) (((ticks) * NS_IN_KHZ) / (unsigned int)(clk))
+#define to_ns(ticks, clk) (((ticks) * NS_IN_KHZ) / (unsigned int)(clk))
 
 /* controller setup */
 
@@ -268,7 +259,8 @@ static int s3c2410_nand_setrate(struct s3c2410_nand_info *info)
         }
 
         dev_info(info->device, "Tacls=%d, %dns Twrph0=%d %dns, Twrph1=%d %dns\n",
-               tacls, to_ns(tacls, clkrate), twrph0, to_ns(twrph0, clkrate), twrph1, to_ns(twrph1, clkrate));
+                tacls, to_ns(tacls, clkrate), twrph0, to_ns(twrph0, clkrate),
+                                                twrph1, to_ns(twrph1, clkrate));
 
         switch (info->cpu_type) {
         case TYPE_S3C2410:
@@ -325,13 +317,13 @@ static int s3c2410_nand_inithw(struct s3c2410_nand_info *info)
         if (ret < 0)
                 return ret;
 
-        switch (info->cpu_type) {
-        case TYPE_S3C2410:
+        switch (info->cpu_type) {
+        case TYPE_S3C2410:
         default:
                 break;
 
-        case TYPE_S3C2440:
-        case TYPE_S3C2412:
+        case TYPE_S3C2440:
+        case TYPE_S3C2412:
                 /* enable the controller and de-assert nFCE */
 
                 writel(S3C2440_NFCONT_ENABLE, info->regs + S3C2440_NFCONT);
@@ -450,6 +442,7 @@ static int s3c2412_nand_devready(struct mtd_info *mtd)
 
 /* ECC handling functions */
 
+#ifdef CONFIG_MTD_NAND_S3C2410_HWECC
 static int s3c2410_nand_correct_data(struct mtd_info *mtd, u_char *dat,
                                      u_char *read_ecc, u_char *calc_ecc)
 {
@@ -463,10 +456,8 @@ static int s3c2410_nand_correct_data(struct mtd_info *mtd, u_char *dat,
         diff1 = read_ecc[1] ^ calc_ecc[1];
         diff2 = read_ecc[2] ^ calc_ecc[2];
 
-        pr_debug("%s: rd %02x%02x%02x calc %02x%02x%02x diff %02x%02x%02x\n",
-                 __func__,
-                 read_ecc[0], read_ecc[1], read_ecc[2],
-                 calc_ecc[0], calc_ecc[1], calc_ecc[2],
+        pr_debug("%s: rd %*phN calc %*phN diff %02x%02x%02x\n",
+                 __func__, 3, read_ecc, 3, calc_ecc,
                  diff0, diff1, diff2);
 
         if (diff0 == 0 && diff1 == 0 && diff2 == 0)
@@ -546,7 +537,8 @@ static void s3c2412_nand_enable_hwecc(struct mtd_info *mtd, int mode)
         unsigned long ctrl;
 
         ctrl = readl(info->regs + S3C2440_NFCONT);
-        writel(ctrl | S3C2412_NFCONT_INIT_MAIN_ECC, info->regs + S3C2440_NFCONT);
+        writel(ctrl | S3C2412_NFCONT_INIT_MAIN_ECC,
+               info->regs + S3C2440_NFCONT);
 }
 
 static void s3c2440_nand_enable_hwecc(struct mtd_info *mtd, int mode)
@@ -558,7 +550,8 @@ static void s3c2440_nand_enable_hwecc(struct mtd_info *mtd, int mode)
         writel(ctrl | S3C2440_NFCONT_INITECC, info->regs + S3C2440_NFCONT);
 }
 
-static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
+static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+                                      u_char *ecc_code)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 
@@ -566,13 +559,13 @@ static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u
         ecc_code[1] = readb(info->regs + S3C2410_NFECC + 1);
         ecc_code[2] = readb(info->regs + S3C2410_NFECC + 2);
 
-        pr_debug("%s: returning ecc %02x%02x%02x\n", __func__,
-                 ecc_code[0], ecc_code[1], ecc_code[2]);
+        pr_debug("%s: returning ecc %*phN\n", __func__, 3, ecc_code);
 
         return 0;
 }
 
-static int s3c2412_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
+static int s3c2412_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+                                      u_char *ecc_code)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
         unsigned long ecc = readl(info->regs + S3C2412_NFMECC0);
@@ -581,12 +574,13 @@ static int s3c2412_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u
         ecc_code[1] = ecc >> 8;
         ecc_code[2] = ecc >> 16;
 
-        pr_debug("calculate_ecc: returning ecc %02x,%02x,%02x\n", ecc_code[0], ecc_code[1], ecc_code[2]);
+        pr_debug("%s: returning ecc %*phN\n", __func__, 3, ecc_code);
 
         return 0;
 }
 
-static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
+static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+                                      u_char *ecc_code)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
         unsigned long ecc = readl(info->regs + S3C2440_NFMECC0);
@@ -599,6 +593,7 @@ static int s3c2440_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u
 
         return 0;
 }
+#endif
 
 /* over-ride the standard functions for a little more speed. We can
  * use read/write block to move the data buffers to/from the controller
@@ -625,13 +620,15 @@ static void s3c2440_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         }
 }
 
-static void s3c2410_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
+static void s3c2410_nand_write_buf(struct mtd_info *mtd, const u_char *buf,
+                                   int len)
 {
         struct nand_chip *this = mtd->priv;
         writesb(this->IO_ADDR_W, buf, len);
 }
 
-static void s3c2440_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
+static void s3c2440_nand_write_buf(struct mtd_info *mtd, const u_char *buf,
+                                   int len)
 {
         struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 
@@ -675,7 +672,8 @@ static inline int s3c2410_nand_cpufreq_register(struct s3c2410_nand_info *info)
                                          CPUFREQ_TRANSITION_NOTIFIER);
 }
 
-static inline void s3c2410_nand_cpufreq_deregister(struct s3c2410_nand_info *info)
+static inline void
+s3c2410_nand_cpufreq_deregister(struct s3c2410_nand_info *info)
 {
         cpufreq_unregister_notifier(&info->freq_transition,
                                     CPUFREQ_TRANSITION_NOTIFIER);
@@ -687,7 +685,8 @@ static inline int s3c2410_nand_cpufreq_register(struct s3c2410_nand_info *info)
         return 0;
 }
 
-static inline void s3c2410_nand_cpufreq_deregister(struct s3c2410_nand_info *info)
+static inline void
+s3c2410_nand_cpufreq_deregister(struct s3c2410_nand_info *info)
 {
 }
 #endif
@@ -717,29 +716,12 @@ static int s3c24xx_nand_remove(struct platform_device *pdev)
                         pr_debug("releasing mtd %d (%p)\n", mtdno, ptr);
                         nand_release(&ptr->mtd);
                 }
-
-                kfree(info->mtds);
         }
 
         /* free the common resources */
 
-        if (!IS_ERR(info->clk)) {
+        if (!IS_ERR(info->clk))
                 s3c2410_nand_clk_set_state(info, CLOCK_DISABLE);
-                clk_put(info->clk);
-        }
-
-        if (info->regs != NULL) {
-                iounmap(info->regs);
-                info->regs = NULL;
-        }
-
-        if (info->area != NULL) {
-                release_resource(info->area);
-                kfree(info->area);
-                info->area = NULL;
-        }
-
-        kfree(info);
 
         return 0;
 }
@@ -810,7 +792,7 @@ static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
                         dev_info(info->device, "System booted from NAND\n");
 
                 break;
-        }
+        }
 
         chip->IO_ADDR_R = chip->IO_ADDR_W;
 
@@ -819,32 +801,31 @@ static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
         nmtd->mtd.owner    = THIS_MODULE;
         nmtd->set          = set;
 
-        if (hardware_ecc) {
+#ifdef CONFIG_MTD_NAND_S3C2410_HWECC
+        chip->ecc.calculate = s3c2410_nand_calculate_ecc;
+        chip->ecc.correct   = s3c2410_nand_correct_data;
+        chip->ecc.mode      = NAND_ECC_HW;
+        chip->ecc.strength  = 1;
+
+        switch (info->cpu_type) {
+        case TYPE_S3C2410:
+                chip->ecc.hwctl     = s3c2410_nand_enable_hwecc;
                 chip->ecc.calculate = s3c2410_nand_calculate_ecc;
-                chip->ecc.correct   = s3c2410_nand_correct_data;
-                chip->ecc.mode      = NAND_ECC_HW;
-                chip->ecc.strength  = 1;
-
-                switch (info->cpu_type) {
-                case TYPE_S3C2410:
-                        chip->ecc.hwctl     = s3c2410_nand_enable_hwecc;
-                        chip->ecc.calculate = s3c2410_nand_calculate_ecc;
-                        break;
-
-                case TYPE_S3C2412:
-                        chip->ecc.hwctl     = s3c2412_nand_enable_hwecc;
-                        chip->ecc.calculate = s3c2412_nand_calculate_ecc;
-                        break;
-
-                case TYPE_S3C2440:
-                        chip->ecc.hwctl     = s3c2440_nand_enable_hwecc;
-                        chip->ecc.calculate = s3c2440_nand_calculate_ecc;
-                        break;
+                break;
 
-                }
-        } else {
-                chip->ecc.mode      = NAND_ECC_SOFT;
+        case TYPE_S3C2412:
+                chip->ecc.hwctl     = s3c2412_nand_enable_hwecc;
+                chip->ecc.calculate = s3c2412_nand_calculate_ecc;
+                break;
+
+        case TYPE_S3C2440:
+                chip->ecc.hwctl     = s3c2440_nand_enable_hwecc;
+                chip->ecc.calculate = s3c2440_nand_calculate_ecc;
+                break;
         }
+#else
+        chip->ecc.mode      = NAND_ECC_SOFT;
+#endif
 
         if (set->ecc_layout != NULL)
                 chip->ecc.layout = set->ecc_layout;
@@ -921,7 +902,7 @@ static void s3c2410_nand_update_chip(struct s3c2410_nand_info *info,
 static int s3c24xx_nand_probe(struct platform_device *pdev)
 {
         struct s3c2410_platform_nand *plat = to_nand_plat(pdev);
-        enum s3c_cpu_type cpu_type; 
+        enum s3c_cpu_type cpu_type;
         struct s3c2410_nand_info *info;
         struct s3c2410_nand_mtd *nmtd;
         struct s3c2410_nand_set *sets;
@@ -935,7 +916,7 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
 
         pr_debug("s3c2410_nand_probe(%p)\n", pdev);
 
-        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
         if (info == NULL) {
                 dev_err(&pdev->dev, "no memory for flash info\n");
                 err = -ENOMEM;
@@ -949,7 +930,7 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
 
         /* get the clock source and enable it */
 
-        info->clk = clk_get(&pdev->dev, "nand");
+        info->clk = devm_clk_get(&pdev->dev, "nand");
         if (IS_ERR(info->clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 err = -ENOENT;
@@ -961,22 +942,14 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
         /* allocate and map the resource */
 
         /* currently we assume we have the one resource */
-        res  = pdev->resource;
+        res = pdev->resource;
         size = resource_size(res);
 
-        info->area = request_mem_region(res->start, size, pdev->name);
-
-        if (info->area == NULL) {
-                dev_err(&pdev->dev, "cannot reserve register region\n");
-                err = -ENOENT;
-                goto exit_error;
-        }
-
-        info->device     = &pdev->dev;
-        info->platform   = plat;
-        info->regs       = ioremap(res->start, size);
-        info->cpu_type   = cpu_type;
+        info->device    = &pdev->dev;
+        info->platform  = plat;
+        info->cpu_type  = cpu_type;
 
+        info->regs      = devm_request_and_ioremap(&pdev->dev, res);
         if (info->regs == NULL) {
                 dev_err(&pdev->dev, "cannot reserve register region\n");
                 err = -EIO;
@@ -999,7 +972,7 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
         /* allocate our information */
 
         size = nr_sets * sizeof(*info->mtds);
-        info->mtds = kzalloc(size, GFP_KERNEL);
+        info->mtds = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
         if (info->mtds == NULL) {
                 dev_err(&pdev->dev, "failed to allocate mtd storage\n");
                 err = -ENOMEM;
@@ -1011,7 +984,8 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
         nmtd = info->mtds;
 
         for (setno = 0; setno < nr_sets; setno++, nmtd++) {
-                pr_debug("initialising set %d (%p, info %p)\n", setno, nmtd, info);
+                pr_debug("initialising set %d (%p, info %p)\n",
+                         setno, nmtd, info);
 
                 s3c2410_nand_init_chip(info, nmtd, sets);
 
@@ -1134,20 +1108,7 @@ static struct platform_driver s3c24xx_nand_driver = {
         },
 };
 
-static int __init s3c2410_nand_init(void)
-{
-        printk("S3C24XX NAND Driver, (c) 2004 Simtec Electronics\n");
-
-        return platform_driver_register(&s3c24xx_nand_driver);
-}
-
-static void __exit s3c2410_nand_exit(void)
-{
-        platform_driver_unregister(&s3c24xx_nand_driver);
-}
-
-module_init(s3c2410_nand_init);
-module_exit(s3c2410_nand_exit);
+module_platform_driver(s3c24xx_nand_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
index aa9b8a5e0b8f..4fbfe96e37a1 100644
--- a/drivers/mtd/nand/sh_flctl.c
+++ b/drivers/mtd/nand/sh_flctl.c
@@ -24,10 +24,12 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
+#include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
+#include <linux/string.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
@@ -43,11 +45,17 @@ static struct nand_ecclayout flctl_4secc_oob_16 = {
 };
 
 static struct nand_ecclayout flctl_4secc_oob_64 = {
-        .eccbytes = 10,
-        .eccpos = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
+        .eccbytes = 4 * 10,
+        .eccpos = {
+                 6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+                22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+                54, 55, 56, 57, 58, 59, 60, 61, 62, 63 },
         .oobfree = {
-                {.offset = 60,
-                . length = 4} },
+                {.offset =  2, .length = 4},
+                {.offset = 16, .length = 6},
+                {.offset = 32, .length = 6},
+                {.offset = 48, .length = 6} },
 };
 
 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
@@ -61,15 +69,15 @@ static struct nand_bbt_descr flctl_4secc_smallpage = {
 
 static struct nand_bbt_descr flctl_4secc_largepage = {
         .options = NAND_BBT_SCAN2NDPAGE,
-        .offs = 58,
+        .offs = 0,
         .len = 2,
         .pattern = scan_ff_pattern,
 };
 
 static void empty_fifo(struct sh_flctl *flctl)
 {
-        writel(0x000c0000, FLINTDMACR(flctl));  /* FIFO Clear */
-        writel(0x00000000, FLINTDMACR(flctl));  /* Clear Error flags */
+        writel(flctl->flintdmacr_base | AC1CLR | AC0CLR, FLINTDMACR(flctl));
+        writel(flctl->flintdmacr_base, FLINTDMACR(flctl));
 }
 
 static void start_translation(struct sh_flctl *flctl)
@@ -158,27 +166,56 @@ static void wait_wfifo_ready(struct sh_flctl *flctl)
         timeout_error(flctl, __func__);
 }
 
-static int wait_recfifo_ready(struct sh_flctl *flctl, int sector_number)
+static enum flctl_ecc_res_t wait_recfifo_ready
+                (struct sh_flctl *flctl, int sector_number)
 {
         uint32_t timeout = LOOP_TIMEOUT_MAX;
-        int checked[4];
         void __iomem *ecc_reg[4];
         int i;
+        int state = FL_SUCCESS;
         uint32_t data, size;
 
-        memset(checked, 0, sizeof(checked));
-
+        /*
+         * First this loops checks in FLDTCNTR if we are ready to read out the
+         * oob data. This is the case if either all went fine without errors or
+         * if the bottom part of the loop corrected the errors or marked them as
+         * uncorrectable and the controller is given time to push the data into
+         * the FIFO.
+         */
         while (timeout--) {
+                /* check if all is ok and we can read out the OOB */
                 size = readl(FLDTCNTR(flctl)) >> 24;
-                if (size & 0xFF)
-                        return 0;       /* success */
+                if ((size & 0xFF) == 4)
+                        return state;
+
+                /* check if a correction code has been calculated */
+                if (!(readl(FL4ECCCR(flctl)) & _4ECCEND)) {
+                        /*
+                         * either we wait for the fifo to be filled or a
+                         * correction pattern is being generated
+                         */
+                        udelay(1);
+                        continue;
+                }
 
-                if (readl(FL4ECCCR(flctl)) & _4ECCFA)
-                        return 1;       /* can't correct */
+                /* check for an uncorrectable error */
+                if (readl(FL4ECCCR(flctl)) & _4ECCFA) {
+                        /* check if we face a non-empty page */
+                        for (i = 0; i < 512; i++) {
+                                if (flctl->done_buff[i] != 0xff) {
+                                        state = FL_ERROR; /* can't correct */
+                                        break;
+                                }
+                        }
 
-                udelay(1);
-                if (!(readl(FL4ECCCR(flctl)) & _4ECCEND))
+                        if (state == FL_SUCCESS)
+                                dev_dbg(&flctl->pdev->dev,
+                                "reading empty sector %d, ecc error ignored\n",
+                                sector_number);
+
+                        writel(0, FL4ECCCR(flctl));
                         continue;
+                }
 
                 /* start error correction */
                 ecc_reg[0] = FL4ECCRESULT0(flctl);
@@ -187,28 +224,26 @@ static int wait_recfifo_ready(struct sh_flctl *flctl, int sector_number)
                 ecc_reg[3] = FL4ECCRESULT3(flctl);
 
                 for (i = 0; i < 3; i++) {
+                        uint8_t org;
+                        int index;
+
                         data = readl(ecc_reg[i]);
-                        if (data != INIT_FL4ECCRESULT_VAL && !checked[i]) {
-                                uint8_t org;
-                                int index;
-
-                                if (flctl->page_size)
-                                        index = (512 * sector_number) +
-                                                (data >> 16);
-                                else
-                                        index = data >> 16;
-
-                                org = flctl->done_buff[index];
-                                flctl->done_buff[index] = org ^ (data & 0xFF);
-                                checked[i] = 1;
-                        }
-                }
 
+                        if (flctl->page_size)
+                                index = (512 * sector_number) +
+                                        (data >> 16);
+                        else
+                                index = data >> 16;
+
+                        org = flctl->done_buff[index];
+                        flctl->done_buff[index] = org ^ (data & 0xFF);
+                }
+                state = FL_REPAIRABLE;
                 writel(0, FL4ECCCR(flctl));
         }
 
         timeout_error(flctl, __func__);
-        return 1;       /* timeout */
+        return FL_TIMEOUT;      /* timeout */
 }
 
 static void wait_wecfifo_ready(struct sh_flctl *flctl)
@@ -241,31 +276,33 @@ static void read_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
 {
         int i, len_4align;
         unsigned long *buf = (unsigned long *)&flctl->done_buff[offset];
-        void *fifo_addr = (void *)FLDTFIFO(flctl);
 
         len_4align = (rlen + 3) / 4;
 
         for (i = 0; i < len_4align; i++) {
                 wait_rfifo_ready(flctl);
-                buf[i] = readl(fifo_addr);
+                buf[i] = readl(FLDTFIFO(flctl));
                 buf[i] = be32_to_cpu(buf[i]);
         }
 }
 
-static int read_ecfiforeg(struct sh_flctl *flctl, uint8_t *buff, int sector)
+static enum flctl_ecc_res_t read_ecfiforeg
+                (struct sh_flctl *flctl, uint8_t *buff, int sector)
 {
         int i;
+        enum flctl_ecc_res_t res;
         unsigned long *ecc_buf = (unsigned long *)buff;
-        void *fifo_addr = (void *)FLECFIFO(flctl);
 
-        for (i = 0; i < 4; i++) {
-                if (wait_recfifo_ready(flctl , sector))
-                        return 1;
-                ecc_buf[i] = readl(fifo_addr);
-                ecc_buf[i] = be32_to_cpu(ecc_buf[i]);
+        res = wait_recfifo_ready(flctl , sector);
+
+        if (res != FL_ERROR) {
+                for (i = 0; i < 4; i++) {
+                        ecc_buf[i] = readl(FLECFIFO(flctl));
+                        ecc_buf[i] = be32_to_cpu(ecc_buf[i]);
+                }
         }
 
-        return 0;
+        return res;
 }
 
 static void write_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
@@ -281,6 +318,18 @@ static void write_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
         }
 }
 
+static void write_ec_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
+{
+        int i, len_4align;
+        unsigned long *data = (unsigned long *)&flctl->done_buff[offset];
+
+        len_4align = (rlen + 3) / 4;
+        for (i = 0; i < len_4align; i++) {
+                wait_wecfifo_ready(flctl);
+                writel(cpu_to_be32(data[i]), FLECFIFO(flctl));
+        }
+}
+
 static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_val)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
@@ -346,73 +395,65 @@ 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)
 {
-        int i, eccsize = chip->ecc.size;
-        int eccbytes = chip->ecc.bytes;
-        int eccsteps = chip->ecc.steps;
-        uint8_t *p = buf;
-        struct sh_flctl *flctl = mtd_to_flctl(mtd);
-
-        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
-                chip->read_buf(mtd, p, eccsize);
-
-        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
-                if (flctl->hwecc_cant_correct[i])
-                        mtd->ecc_stats.failed++;
-                else
-                        mtd->ecc_stats.corrected += 0; /* FIXME */
-        }
-
+        chip->read_buf(mtd, buf, mtd->writesize);
+        if (oob_required)
+                chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
         return 0;
 }
 
-static void flctl_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+static int flctl_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                                    const uint8_t *buf, int oob_required)
 {
-        int i, eccsize = chip->ecc.size;
-        int eccbytes = chip->ecc.bytes;
-        int eccsteps = chip->ecc.steps;
-        const uint8_t *p = buf;
-
-        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
-                chip->write_buf(mtd, p, eccsize);
+        chip->write_buf(mtd, buf, mtd->writesize);
+        chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return 0;
 }
 
 static void execmd_read_page_sector(struct mtd_info *mtd, int page_addr)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
         int sector, page_sectors;
+        enum flctl_ecc_res_t ecc_result;
 
-        if (flctl->page_size)
-                page_sectors = 4;
-        else
-                page_sectors = 1;
-
-        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE | _4ECCCORRECT,
-                 FLCMNCR(flctl));
+        page_sectors = flctl->page_size ? 4 : 1;
 
         set_cmd_regs(mtd, NAND_CMD_READ0,
                 (NAND_CMD_READSTART << 8) | NAND_CMD_READ0);
 
-        for (sector = 0; sector < page_sectors; sector++) {
-                int ret;
+        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE | _4ECCCORRECT,
+                 FLCMNCR(flctl));
+        writel(readl(FLCMDCR(flctl)) | page_sectors, FLCMDCR(flctl));
+        writel(page_addr << 2, FLADR(flctl));
 
-                empty_fifo(flctl);
-                writel(readl(FLCMDCR(flctl)) | 1, FLCMDCR(flctl));
-                writel(page_addr << 2 | sector, FLADR(flctl));
+        empty_fifo(flctl);
+        start_translation(flctl);
 
-                start_translation(flctl);
+        for (sector = 0; sector < page_sectors; sector++) {
                 read_fiforeg(flctl, 512, 512 * sector);
 
-                ret = read_ecfiforeg(flctl,
+                ecc_result = read_ecfiforeg(flctl,
                         &flctl->done_buff[mtd->writesize + 16 * sector],
                         sector);
 
-                if (ret)
-                        flctl->hwecc_cant_correct[sector] = 1;
-
-                writel(0x0, FL4ECCCR(flctl));
-                wait_completion(flctl);
+                switch (ecc_result) {
+                case FL_REPAIRABLE:
+                        dev_info(&flctl->pdev->dev,
+                                "applied ecc on page 0x%x", page_addr);
+                        flctl->mtd.ecc_stats.corrected++;
+                        break;
+                case FL_ERROR:
+                        dev_warn(&flctl->pdev->dev,
+                                "page 0x%x contains corrupted data\n",
+                                page_addr);
+                        flctl->mtd.ecc_stats.failed++;
+                        break;
+                default:
+                        ;
+                }
         }
+
+        wait_completion(flctl);
+
         writel(readl(FLCMNCR(flctl)) & ~(ACM_SACCES_MODE | _4ECCCORRECT),
                         FLCMNCR(flctl));
 }
@@ -420,30 +461,20 @@ static void execmd_read_page_sector(struct mtd_info *mtd, int page_addr)
 static void execmd_read_oob(struct mtd_info *mtd, int page_addr)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int page_sectors = flctl->page_size ? 4 : 1;
+        int i;
 
         set_cmd_regs(mtd, NAND_CMD_READ0,
                 (NAND_CMD_READSTART << 8) | NAND_CMD_READ0);
 
         empty_fifo(flctl);
-        if (flctl->page_size) {
-                int i;
-                /* In case that the page size is 2k */
-                for (i = 0; i < 16 * 3; i++)
-                        flctl->done_buff[i] = 0xFF;
-
-                set_addr(mtd, 3 * 528 + 512, page_addr);
-                writel(16, FLDTCNTR(flctl));
 
-                start_translation(flctl);
-                read_fiforeg(flctl, 16, 16 * 3);
-                wait_completion(flctl);
-        } else {
-                /* In case that the page size is 512b */
-                set_addr(mtd, 512, page_addr);
+        for (i = 0; i < page_sectors; i++) {
+                set_addr(mtd, (512 + 16) * i + 512 , page_addr);
                 writel(16, FLDTCNTR(flctl));
 
                 start_translation(flctl);
-                read_fiforeg(flctl, 16, 0);
+                read_fiforeg(flctl, 16, 16 * i);
                 wait_completion(flctl);
         }
 }
@@ -451,34 +482,26 @@ static void execmd_read_oob(struct mtd_info *mtd, int page_addr)
 static void execmd_write_page_sector(struct mtd_info *mtd)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
-        int i, page_addr = flctl->seqin_page_addr;
+        int page_addr = flctl->seqin_page_addr;
         int sector, page_sectors;
 
-        if (flctl->page_size)
-                page_sectors = 4;
-        else
-                page_sectors = 1;
-
-        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE, FLCMNCR(flctl));
+        page_sectors = flctl->page_size ? 4 : 1;
 
         set_cmd_regs(mtd, NAND_CMD_PAGEPROG,
                         (NAND_CMD_PAGEPROG << 8) | NAND_CMD_SEQIN);
 
-        for (sector = 0; sector < page_sectors; sector++) {
-                empty_fifo(flctl);
-                writel(readl(FLCMDCR(flctl)) | 1, FLCMDCR(flctl));
-                writel(page_addr << 2 | sector, FLADR(flctl));
+        empty_fifo(flctl);
+        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE, FLCMNCR(flctl));
+        writel(readl(FLCMDCR(flctl)) | page_sectors, FLCMDCR(flctl));
+        writel(page_addr << 2, FLADR(flctl));
+        start_translation(flctl);
 
-                start_translation(flctl);
+        for (sector = 0; sector < page_sectors; sector++) {
                 write_fiforeg(flctl, 512, 512 * sector);
-
-                for (i = 0; i < 4; i++) {
-                        wait_wecfifo_ready(flctl); /* wait for write ready */
-                        writel(0xFFFFFFFF, FLECFIFO(flctl));
-                }
-                wait_completion(flctl);
+                write_ec_fiforeg(flctl, 16, mtd->writesize + 16 * sector);
         }
 
+        wait_completion(flctl);
         writel(readl(FLCMNCR(flctl)) & ~ACM_SACCES_MODE, FLCMNCR(flctl));
 }
 
@@ -488,18 +511,12 @@ static void execmd_write_oob(struct mtd_info *mtd)
         int page_addr = flctl->seqin_page_addr;
         int sector, page_sectors;
 
-        if (flctl->page_size) {
-                sector = 3;
-                page_sectors = 4;
-        } else {
-                sector = 0;
-                page_sectors = 1;
-        }
+        page_sectors = flctl->page_size ? 4 : 1;
 
         set_cmd_regs(mtd, NAND_CMD_PAGEPROG,
                         (NAND_CMD_PAGEPROG << 8) | NAND_CMD_SEQIN);
 
-        for (; sector < page_sectors; sector++) {
+        for (sector = 0; sector < page_sectors; sector++) {
                 empty_fifo(flctl);
                 set_addr(mtd, sector * 528 + 512, page_addr);
                 writel(16, FLDTCNTR(flctl));    /* set read size */
@@ -731,10 +748,9 @@ static void flctl_select_chip(struct mtd_info *mtd, int chipnr)
 static void flctl_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
-        int i, index = flctl->index;
+        int index = flctl->index;
 
-        for (i = 0; i < len; i++)
-                flctl->done_buff[index + i] = buf[i];
+        memcpy(&flctl->done_buff[index], buf, len);
         flctl->index += len;
 }
 
@@ -763,20 +779,11 @@ static uint16_t flctl_read_word(struct mtd_info *mtd)
 
 static void flctl_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-        int i;
-
-        for (i = 0; i < len; i++)
-                buf[i] = flctl_read_byte(mtd);
-}
-
-static int flctl_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        int i;
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int index = flctl->index;
 
-        for (i = 0; i < len; i++)
-                if (buf[i] != flctl_read_byte(mtd))
-                        return -EFAULT;
-        return 0;
+        memcpy(buf, &flctl->done_buff[index], len);
+        flctl->index += len;
 }
 
 static int flctl_chip_init_tail(struct mtd_info *mtd)
@@ -831,7 +838,7 @@ static int flctl_chip_init_tail(struct mtd_info *mtd)
                 chip->ecc.mode = NAND_ECC_HW;
 
                 /* 4 symbols ECC enabled */
-                flctl->flcmncr_base |= _4ECCEN | ECCPOS2 | ECCPOS_02;
+                flctl->flcmncr_base |= _4ECCEN;
         } else {
                 chip->ecc.mode = NAND_ECC_SOFT;
         }
@@ -839,6 +846,16 @@ static int flctl_chip_init_tail(struct mtd_info *mtd)
         return 0;
 }
 
+static irqreturn_t flctl_handle_flste(int irq, void *dev_id)
+{
+        struct sh_flctl *flctl = dev_id;
+
+        dev_err(&flctl->pdev->dev, "flste irq: %x\n", readl(FLINTDMACR(flctl)));
+        writel(flctl->flintdmacr_base, FLINTDMACR(flctl));
+
+        return IRQ_HANDLED;
+}
+
 static int __devinit flctl_probe(struct platform_device *pdev)
 {
         struct resource *res;
@@ -847,6 +864,7 @@ static int __devinit flctl_probe(struct platform_device *pdev)
         struct nand_chip *nand;
         struct sh_flctl_platform_data *pdata;
         int ret = -ENXIO;
+        int irq;
 
         pdata = pdev->dev.platform_data;
         if (pdata == NULL) {
@@ -872,14 +890,27 @@ static int __devinit flctl_probe(struct platform_device *pdev)
                 goto err_iomap;
         }
 
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get flste irq data\n");
+                goto err_flste;
+        }
+
+        ret = request_irq(irq, flctl_handle_flste, IRQF_SHARED, "flste", flctl);
+        if (ret) {
+                dev_err(&pdev->dev, "request interrupt failed.\n");
+                goto err_flste;
+        }
+
         platform_set_drvdata(pdev, flctl);
         flctl_mtd = &flctl->mtd;
         nand = &flctl->chip;
         flctl_mtd->priv = nand;
         flctl->pdev = pdev;
-        flctl->flcmncr_base = pdata->flcmncr_val;
         flctl->hwecc = pdata->has_hwecc;
         flctl->holden = pdata->use_holden;
+        flctl->flcmncr_base = pdata->flcmncr_val;
+        flctl->flintdmacr_base = flctl->hwecc ? (STERINTE | ECERB) : STERINTE;
 
         /* Set address of hardware control function */
         /* 20 us command delay time */
@@ -888,7 +919,6 @@ static int __devinit flctl_probe(struct platform_device *pdev)
         nand->read_byte = flctl_read_byte;
         nand->write_buf = flctl_write_buf;
         nand->read_buf = flctl_read_buf;
-        nand->verify_buf = flctl_verify_buf;
         nand->select_chip = flctl_select_chip;
         nand->cmdfunc = flctl_cmdfunc;
 
@@ -918,6 +948,9 @@ static int __devinit flctl_probe(struct platform_device *pdev)
 
 err_chip:
         pm_runtime_disable(&pdev->dev);
+        free_irq(irq, flctl);
+err_flste:
+        iounmap(flctl->reg);
 err_iomap:
         kfree(flctl);
         return ret;
@@ -929,6 +962,8 @@ static int __devexit flctl_remove(struct platform_device *pdev)
 
         nand_release(&flctl->mtd);
         pm_runtime_disable(&pdev->dev);
+        free_irq(platform_get_irq(pdev, 0), flctl);
+        iounmap(flctl->reg);
         kfree(flctl);
 
         return 0;
diff --git a/drivers/mtd/nand/socrates_nand.c b/drivers/mtd/nand/socrates_nand.c
index e02b08bcf0c0..f3f28fafbf7a 100644
--- a/drivers/mtd/nand/socrates_nand.c
+++ b/drivers/mtd/nand/socrates_nand.c
@@ -98,24 +98,6 @@ static uint16_t socrates_nand_read_word(struct mtd_info *mtd)
         return word;
 }
 
-/**
- * socrates_nand_verify_buf -  Verify chip data against buffer
- * @mtd:        MTD device structure
- * @buf:        buffer containing the data to compare
- * @len:        number of bytes to compare
- */
-static int socrates_nand_verify_buf(struct mtd_info *mtd, const u8 *buf,
-                int len)
-{
-        int i;
-
-        for (i = 0; i < len; i++) {
-                if (buf[i] != socrates_nand_read_byte(mtd))
-                        return -EFAULT;
-        }
-        return 0;
-}
-
 /*
  * Hardware specific access to control-lines
  */
@@ -201,7 +183,6 @@ static int __devinit socrates_nand_probe(struct platform_device *ofdev)
         nand_chip->read_word = socrates_nand_read_word;
         nand_chip->write_buf = socrates_nand_write_buf;
         nand_chip->read_buf = socrates_nand_read_buf;
-        nand_chip->verify_buf = socrates_nand_verify_buf;
         nand_chip->dev_ready = socrates_nand_device_ready;
 
         nand_chip->ecc.mode = NAND_ECC_SOFT;    /* enable ECC */
diff --git a/drivers/mtd/nand/tmio_nand.c b/drivers/mtd/nand/tmio_nand.c
index 5aa518081c51..508e9e04b092 100644
--- a/drivers/mtd/nand/tmio_nand.c
+++ b/drivers/mtd/nand/tmio_nand.c
@@ -256,18 +256,6 @@ static void tmio_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
         tmio_ioread16_rep(tmio->fcr + FCR_DATA, buf, len >> 1);
 }
 
-static int
-tmio_nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
-{
-        struct tmio_nand *tmio = mtd_to_tmio(mtd);
-        u16                             *p = (u16 *) buf;
-
-        for (len >>= 1; len; len--)
-                if (*(p++) != tmio_ioread16(tmio->fcr + FCR_DATA))
-                        return -EFAULT;
-        return 0;
-}
-
 static void tmio_nand_enable_hwecc(struct mtd_info *mtd, int mode)
 {
         struct tmio_nand *tmio = mtd_to_tmio(mtd);
@@ -424,7 +412,6 @@ static int tmio_probe(struct platform_device *dev)
         nand_chip->read_byte = tmio_nand_read_byte;
         nand_chip->write_buf = tmio_nand_write_buf;
         nand_chip->read_buf = tmio_nand_read_buf;
-        nand_chip->verify_buf = tmio_nand_verify_buf;
 
         /* set eccmode using hardware ECC */
         nand_chip->ecc.mode = NAND_ECC_HW;
diff --git a/drivers/mtd/nand/txx9ndfmc.c b/drivers/mtd/nand/txx9ndfmc.c
index 26398dcf21cf..e3d7266e256f 100644
--- a/drivers/mtd/nand/txx9ndfmc.c
+++ b/drivers/mtd/nand/txx9ndfmc.c
@@ -131,18 +131,6 @@ static void txx9ndfmc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
                 *buf++ = __raw_readl(ndfdtr);
 }
 
-static int txx9ndfmc_verify_buf(struct mtd_info *mtd, const uint8_t *buf,
-                                int len)
-{
-        struct platform_device *dev = mtd_to_platdev(mtd);
-        void __iomem *ndfdtr = ndregaddr(dev, TXX9_NDFDTR);
-
-        while (len--)
-                if (*buf++ != (uint8_t)__raw_readl(ndfdtr))
-                        return -EFAULT;
-        return 0;
-}
-
 static void txx9ndfmc_cmd_ctrl(struct mtd_info *mtd, int cmd,
                                unsigned int ctrl)
 {
@@ -346,7 +334,6 @@ static int __init txx9ndfmc_probe(struct platform_device *dev)
                 chip->read_byte = txx9ndfmc_read_byte;
                 chip->read_buf = txx9ndfmc_read_buf;
                 chip->write_buf = txx9ndfmc_write_buf;
-                chip->verify_buf = txx9ndfmc_verify_buf;
                 chip->cmd_ctrl = txx9ndfmc_cmd_ctrl;
                 chip->dev_ready = txx9ndfmc_dev_ready;
                 chip->ecc.calculate = txx9ndfmc_calculate_ecc;
diff --git a/drivers/mtd/nand/xway_nand.c b/drivers/mtd/nand/xway_nand.c
new file mode 100644
index 000000000000..3f81dc8f214c
--- /dev/null
+++ b/drivers/mtd/nand/xway_nand.c
@@ -0,0 +1,201 @@
+/*
+ *  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.
+ *
+ *  Copyright © 2012 John Crispin <blogic@openwrt.org>
+ */
+
+#include <linux/mtd/nand.h>
+#include <linux/of_gpio.h>
+#include <linux/of_platform.h>
+
+#include <lantiq_soc.h>
+
+/* nand registers */
+#define EBU_ADDSEL1             0x24
+#define EBU_NAND_CON            0xB0
+#define EBU_NAND_WAIT           0xB4
+#define EBU_NAND_ECC0           0xB8
+#define EBU_NAND_ECC_AC         0xBC
+
+/* nand commands */
+#define NAND_CMD_ALE            (1 << 2)
+#define NAND_CMD_CLE            (1 << 3)
+#define NAND_CMD_CS             (1 << 4)
+#define NAND_WRITE_CMD_RESET    0xff
+#define NAND_WRITE_CMD          (NAND_CMD_CS | NAND_CMD_CLE)
+#define NAND_WRITE_ADDR         (NAND_CMD_CS | NAND_CMD_ALE)
+#define NAND_WRITE_DATA         (NAND_CMD_CS)
+#define NAND_READ_DATA          (NAND_CMD_CS)
+#define NAND_WAIT_WR_C          (1 << 3)
+#define NAND_WAIT_RD            (0x1)
+
+/* we need to tel the ebu which addr we mapped the nand to */
+#define ADDSEL1_MASK(x)         (x << 4)
+#define ADDSEL1_REGEN           1
+
+/* we need to tell the EBU that we have nand attached and set it up properly */
+#define BUSCON1_SETUP           (1 << 22)
+#define BUSCON1_BCGEN_RES       (0x3 << 12)
+#define BUSCON1_WAITWRC2        (2 << 8)
+#define BUSCON1_WAITRDC2        (2 << 6)
+#define BUSCON1_HOLDC1          (1 << 4)
+#define BUSCON1_RECOVC1         (1 << 2)
+#define BUSCON1_CMULT4          1
+
+#define NAND_CON_CE             (1 << 20)
+#define NAND_CON_OUT_CS1        (1 << 10)
+#define NAND_CON_IN_CS1         (1 << 8)
+#define NAND_CON_PRE_P          (1 << 7)
+#define NAND_CON_WP_P           (1 << 6)
+#define NAND_CON_SE_P           (1 << 5)
+#define NAND_CON_CS_P           (1 << 4)
+#define NAND_CON_CSMUX          (1 << 1)
+#define NAND_CON_NANDM          1
+
+static void xway_reset_chip(struct nand_chip *chip)
+{
+        unsigned long nandaddr = (unsigned long) chip->IO_ADDR_W;
+        unsigned long flags;
+
+        nandaddr &= ~NAND_WRITE_ADDR;
+        nandaddr |= NAND_WRITE_CMD;
+
+        /* finish with a reset */
+        spin_lock_irqsave(&ebu_lock, flags);
+        writeb(NAND_WRITE_CMD_RESET, (void __iomem *) nandaddr);
+        while ((ltq_ebu_r32(EBU_NAND_WAIT) & NAND_WAIT_WR_C) == 0)
+                ;
+        spin_unlock_irqrestore(&ebu_lock, flags);
+}
+
+static void xway_select_chip(struct mtd_info *mtd, int chip)
+{
+
+        switch (chip) {
+        case -1:
+                ltq_ebu_w32_mask(NAND_CON_CE, 0, EBU_NAND_CON);
+                ltq_ebu_w32_mask(NAND_CON_NANDM, 0, EBU_NAND_CON);
+                break;
+        case 0:
+                ltq_ebu_w32_mask(0, NAND_CON_NANDM, EBU_NAND_CON);
+                ltq_ebu_w32_mask(0, NAND_CON_CE, EBU_NAND_CON);
+                break;
+        default:
+                BUG();
+        }
+}
+
+static void xway_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
+{
+        struct nand_chip *this = mtd->priv;
+        unsigned long nandaddr = (unsigned long) this->IO_ADDR_W;
+        unsigned long flags;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                nandaddr &= ~(NAND_WRITE_CMD | NAND_WRITE_ADDR);
+                if (ctrl & NAND_CLE)
+                        nandaddr |= NAND_WRITE_CMD;
+                else
+                        nandaddr |= NAND_WRITE_ADDR;
+                this->IO_ADDR_W = (void __iomem *) nandaddr;
+        }
+
+        if (cmd != NAND_CMD_NONE) {
+                spin_lock_irqsave(&ebu_lock, flags);
+                writeb(cmd, this->IO_ADDR_W);
+                while ((ltq_ebu_r32(EBU_NAND_WAIT) & NAND_WAIT_WR_C) == 0)
+                        ;
+                spin_unlock_irqrestore(&ebu_lock, flags);
+        }
+}
+
+static int xway_dev_ready(struct mtd_info *mtd)
+{
+        return ltq_ebu_r32(EBU_NAND_WAIT) & NAND_WAIT_RD;
+}
+
+static unsigned char xway_read_byte(struct mtd_info *mtd)
+{
+        struct nand_chip *this = mtd->priv;
+        unsigned long nandaddr = (unsigned long) this->IO_ADDR_R;
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&ebu_lock, flags);
+        ret = ltq_r8((void __iomem *)(nandaddr + NAND_READ_DATA));
+        spin_unlock_irqrestore(&ebu_lock, flags);
+
+        return ret;
+}
+
+static int xway_nand_probe(struct platform_device *pdev)
+{
+        struct nand_chip *this = platform_get_drvdata(pdev);
+        unsigned long nandaddr = (unsigned long) this->IO_ADDR_W;
+        const __be32 *cs = of_get_property(pdev->dev.of_node,
+                                        "lantiq,cs", NULL);
+        u32 cs_flag = 0;
+
+        /* load our CS from the DT. Either we find a valid 1 or default to 0 */
+        if (cs && (*cs == 1))
+                cs_flag = NAND_CON_IN_CS1 | NAND_CON_OUT_CS1;
+
+        /* setup the EBU to run in NAND mode on our base addr */
+        ltq_ebu_w32(CPHYSADDR(nandaddr)
+                | ADDSEL1_MASK(3) | ADDSEL1_REGEN, EBU_ADDSEL1);
+
+        ltq_ebu_w32(BUSCON1_SETUP | BUSCON1_BCGEN_RES | BUSCON1_WAITWRC2
+                | BUSCON1_WAITRDC2 | BUSCON1_HOLDC1 | BUSCON1_RECOVC1
+                | BUSCON1_CMULT4, LTQ_EBU_BUSCON1);
+
+        ltq_ebu_w32(NAND_CON_NANDM | NAND_CON_CSMUX | NAND_CON_CS_P
+                | NAND_CON_SE_P | NAND_CON_WP_P | NAND_CON_PRE_P
+                | cs_flag, EBU_NAND_CON);
+
+        /* finish with a reset */
+        xway_reset_chip(this);
+
+        return 0;
+}
+
+/* allow users to override the partition in DT using the cmdline */
+static const char *part_probes[] = { "cmdlinepart", "ofpart", NULL };
+
+static struct platform_nand_data xway_nand_data = {
+        .chip = {
+                .nr_chips               = 1,
+                .chip_delay             = 30,
+                .part_probe_types       = part_probes,
+        },
+        .ctrl = {
+                .probe          = xway_nand_probe,
+                .cmd_ctrl       = xway_cmd_ctrl,
+                .dev_ready      = xway_dev_ready,
+                .select_chip    = xway_select_chip,
+                .read_byte      = xway_read_byte,
+        }
+};
+
+/*
+ * Try to find the node inside the DT. If it is available attach out
+ * platform_nand_data
+ */
+static int __init xway_register_nand(void)
+{
+        struct device_node *node;
+        struct platform_device *pdev;
+
+        node = of_find_compatible_node(NULL, NULL, "lantiq,nand-xway");
+        if (!node)
+                return -ENOENT;
+        pdev = of_find_device_by_node(node);
+        if (!pdev)
+                return -EINVAL;
+        pdev->dev.platform_data = &xway_nand_data;
+        of_node_put(node);
+        return 0;
+}
+
+subsys_initcall(xway_register_nand);
diff --git a/drivers/mtd/sm_ftl.c b/drivers/mtd/sm_ftl.c
index 9e2dfd517aa5..8dd6ba52404a 100644
--- a/drivers/mtd/sm_ftl.c
+++ b/drivers/mtd/sm_ftl.c
@@ -346,7 +346,6 @@ static int sm_write_sector(struct sm_ftl *ftl,
         ret = mtd_write_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
 
         /* Now we assume that hardware will catch write bitflip errors */
-        /* If you are paranoid, use CONFIG_MTD_NAND_VERIFY_WRITE */
 
         if (ret) {
                 dbg("write to block %d at zone %d, failed with error %d",
diff --git a/drivers/mtd/tests/Makefile b/drivers/mtd/tests/Makefile
index b44dcab940d8..bd0065c0d359 100644
--- a/drivers/mtd/tests/Makefile
+++ b/drivers/mtd/tests/Makefile
@@ -6,3 +6,4 @@ obj-$(CONFIG_MTD_TESTS) += mtd_stresstest.o
 obj-$(CONFIG_MTD_TESTS) += mtd_subpagetest.o
 obj-$(CONFIG_MTD_TESTS) += mtd_torturetest.o
 obj-$(CONFIG_MTD_TESTS) += mtd_nandecctest.o
+obj-$(CONFIG_MTD_TESTS) += mtd_nandbiterrs.o
diff --git a/drivers/mtd/tests/mtd_nandbiterrs.c b/drivers/mtd/tests/mtd_nandbiterrs.c
new file mode 100644
index 000000000000..cc8d62cb280c
--- /dev/null
+++ b/drivers/mtd/tests/mtd_nandbiterrs.c
@@ -0,0 +1,460 @@
+/*
+ * Copyright © 2012 NetCommWireless
+ * Iwo Mergler <Iwo.Mergler@netcommwireless.com.au>
+ *
+ * Test for multi-bit error recovery on a NAND page This mostly tests the
+ * ECC controller / driver.
+ *
+ * There are two test modes:
+ *
+ *      0 - artificially inserting bit errors until the ECC fails
+ *          This is the default method and fairly quick. It should
+ *          be independent of the quality of the FLASH.
+ *
+ *      1 - re-writing the same pattern repeatedly until the ECC fails.
+ *          This method relies on the physics of NAND FLASH to eventually
+ *          generate '0' bits if '1' has been written sufficient times.
+ *          Depending on the NAND, the first bit errors will appear after
+ *          1000 or more writes and then will usually snowball, reaching the
+ *          limits of the ECC quickly.
+ *
+ *          The test stops after 10000 cycles, should your FLASH be
+ *          exceptionally good and not generate bit errors before that. Try
+ *          a different page in that case.
+ *
+ * Please note that neither of these tests will significantly 'use up' any
+ * FLASH endurance. Only a maximum of two erase operations will be performed.
+ *
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; see the file COPYING. If not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/mtd/mtd.h>
+#include <linux/err.h>
+#include <linux/mtd/nand.h>
+#include <linux/slab.h>
+
+#define msg(FMT, VA...) pr_info("mtd_nandbiterrs: "FMT, ##VA)
+
+static int dev;
+module_param(dev, int, S_IRUGO);
+MODULE_PARM_DESC(dev, "MTD device number to use");
+
+static unsigned page_offset;
+module_param(page_offset, uint, S_IRUGO);
+MODULE_PARM_DESC(page_offset, "Page number relative to dev start");
+
+static unsigned seed;
+module_param(seed, uint, S_IRUGO);
+MODULE_PARM_DESC(seed, "Random seed");
+
+static int mode;
+module_param(mode, int, S_IRUGO);
+MODULE_PARM_DESC(mode, "0=incremental errors, 1=overwrite test");
+
+static unsigned max_overwrite = 10000;
+
+static loff_t   offset;     /* Offset of the page we're using. */
+static unsigned eraseblock; /* Eraseblock number for our page. */
+
+/* We assume that the ECC can correct up to a certain number
+ * of biterrors per subpage. */
+static unsigned subsize;  /* Size of subpages */
+static unsigned subcount; /* Number of subpages per page */
+
+static struct mtd_info *mtd;   /* MTD device */
+
+static uint8_t *wbuffer; /* One page write / compare buffer */
+static uint8_t *rbuffer; /* One page read buffer */
+
+/* 'random' bytes from known offsets */
+static uint8_t hash(unsigned offset)
+{
+        unsigned v = offset;
+        unsigned char c;
+        v ^= 0x7f7edfd3;
+        v = v ^ (v >> 3);
+        v = v ^ (v >> 5);
+        v = v ^ (v >> 13);
+        c = v & 0xFF;
+        /* Reverse bits of result. */
+        c = (c & 0x0F) << 4 | (c & 0xF0) >> 4;
+        c = (c & 0x33) << 2 | (c & 0xCC) >> 2;
+        c = (c & 0x55) << 1 | (c & 0xAA) >> 1;
+        return c;
+}
+
+static int erase_block(void)
+{
+        int err;
+        struct erase_info ei;
+        loff_t addr = eraseblock * mtd->erasesize;
+
+        msg("erase_block\n");
+
+        memset(&ei, 0, sizeof(struct erase_info));
+        ei.mtd  = mtd;
+        ei.addr = addr;
+        ei.len  = mtd->erasesize;
+
+        err = mtd_erase(mtd, &ei);
+        if (err || ei.state == MTD_ERASE_FAILED) {
+                msg("error %d while erasing\n", err);
+                if (!err)
+                        err = -EIO;
+                return err;
+        }
+
+        return 0;
+}
+
+/* Writes wbuffer to page */
+static int write_page(int log)
+{
+        int err = 0;
+        size_t written;
+
+        if (log)
+                msg("write_page\n");
+
+        err = mtd_write(mtd, offset, mtd->writesize, &written, wbuffer);
+        if (err || written != mtd->writesize) {
+                msg("error: write failed at %#llx\n", (long long)offset);
+                if (!err)
+                        err = -EIO;
+        }
+
+        return err;
+}
+
+/* Re-writes the data area while leaving the OOB alone. */
+static int rewrite_page(int log)
+{
+        int err = 0;
+        struct mtd_oob_ops ops;
+
+        if (log)
+                msg("rewrite page\n");
+
+        ops.mode      = MTD_OPS_RAW; /* No ECC */
+        ops.len       = mtd->writesize;
+        ops.retlen    = 0;
+        ops.ooblen    = 0;
+        ops.oobretlen = 0;
+        ops.ooboffs   = 0;
+        ops.datbuf    = wbuffer;
+        ops.oobbuf    = NULL;
+
+        err = mtd_write_oob(mtd, offset, &ops);
+        if (err || ops.retlen != mtd->writesize) {
+                msg("error: write_oob failed (%d)\n", err);
+                if (!err)
+                        err = -EIO;
+        }
+
+        return err;
+}
+
+/* Reads page into rbuffer. Returns number of corrected bit errors (>=0)
+ * or error (<0) */
+static int read_page(int log)
+{
+        int err = 0;
+        size_t read;
+        struct mtd_ecc_stats oldstats;
+
+        if (log)
+                msg("read_page\n");
+
+        /* Saving last mtd stats */
+        memcpy(&oldstats, &mtd->ecc_stats, sizeof(oldstats));
+
+        err = mtd_read(mtd, offset, mtd->writesize, &read, rbuffer);
+        if (err == -EUCLEAN)
+                err = mtd->ecc_stats.corrected - oldstats.corrected;
+
+        if (err < 0 || read != mtd->writesize) {
+                msg("error: read failed at %#llx\n", (long long)offset);
+                if (err >= 0)
+                        err = -EIO;
+        }
+
+        return err;
+}
+
+/* Verifies rbuffer against random sequence */
+static int verify_page(int log)
+{
+        unsigned i, errs = 0;
+
+        if (log)
+                msg("verify_page\n");
+
+        for (i = 0; i < mtd->writesize; i++) {
+                if (rbuffer[i] != hash(i+seed)) {
+                        msg("Error: page offset %u, expected %02x, got %02x\n",
+                                i, hash(i+seed), rbuffer[i]);
+                        errs++;
+                }
+        }
+
+        if (errs)
+                return -EIO;
+        else
+                return 0;
+}
+
+#define CBIT(v, n) ((v) & (1 << (n)))
+#define BCLR(v, n) ((v) = (v) & ~(1 << (n)))
+
+/* Finds the first '1' bit in wbuffer starting at offset 'byte'
+ * and sets it to '0'. */
+static int insert_biterror(unsigned byte)
+{
+        int bit;
+
+        while (byte < mtd->writesize) {
+                for (bit = 7; bit >= 0; bit--) {
+                        if (CBIT(wbuffer[byte], bit)) {
+                                BCLR(wbuffer[byte], bit);
+                                msg("Inserted biterror @ %u/%u\n", byte, bit);
+                                return 0;
+                        }
+                }
+                byte++;
+        }
+        msg("biterror: Failed to find a '1' bit\n");
+        return -EIO;
+}
+
+/* Writes 'random' data to page and then introduces deliberate bit
+ * errors into the page, while verifying each step. */
+static int incremental_errors_test(void)
+{
+        int err = 0;
+        unsigned i;
+        unsigned errs_per_subpage = 0;
+
+        msg("incremental biterrors test\n");
+
+        for (i = 0; i < mtd->writesize; i++)
+                wbuffer[i] = hash(i+seed);
+
+        err = write_page(1);
+        if (err)
+                goto exit;
+
+        while (1) {
+
+                err = rewrite_page(1);
+                if (err)
+                        goto exit;
+
+                err = read_page(1);
+                if (err > 0)
+                        msg("Read reported %d corrected bit errors\n", err);
+                if (err < 0) {
+                        msg("After %d biterrors per subpage, read reported error %d\n",
+                                errs_per_subpage, err);
+                        err = 0;
+                        goto exit;
+                }
+
+                err = verify_page(1);
+                if (err) {
+                        msg("ECC failure, read data is incorrect despite read success\n");
+                        goto exit;
+                }
+
+                msg("Successfully corrected %d bit errors per subpage\n",
+                        errs_per_subpage);
+
+                for (i = 0; i < subcount; i++) {
+                        err = insert_biterror(i * subsize);
+                        if (err < 0)
+                                goto exit;
+                }
+                errs_per_subpage++;
+        }
+
+exit:
+        return err;
+}
+
+
+/* Writes 'random' data to page and then re-writes that same data repeatedly.
+   This eventually develops bit errors (bits written as '1' will slowly become
+   '0'), which are corrected as far as the ECC is capable of. */
+static int overwrite_test(void)
+{
+        int err = 0;
+        unsigned i;
+        unsigned max_corrected = 0;
+        unsigned opno = 0;
+        /* We don't expect more than this many correctable bit errors per
+         * page. */
+        #define MAXBITS 512
+        static unsigned bitstats[MAXBITS]; /* bit error histogram. */
+
+        memset(bitstats, 0, sizeof(bitstats));
+
+        msg("overwrite biterrors test\n");
+
+        for (i = 0; i < mtd->writesize; i++)
+                wbuffer[i] = hash(i+seed);
+
+        err = write_page(1);
+        if (err)
+                goto exit;
+
+        while (opno < max_overwrite) {
+
+                err = rewrite_page(0);
+                if (err)
+                        break;
+
+                err = read_page(0);
+                if (err >= 0) {
+                        if (err >= MAXBITS) {
+                                msg("Implausible number of bit errors corrected\n");
+                                err = -EIO;
+                                break;
+                        }
+                        bitstats[err]++;
+                        if (err > max_corrected) {
+                                max_corrected = err;
+                                msg("Read reported %d corrected bit errors\n",
+                                        err);
+                        }
+                } else { /* err < 0 */
+                        msg("Read reported error %d\n", err);
+                        err = 0;
+                        break;
+                }
+
+                err = verify_page(0);
+                if (err) {
+                        bitstats[max_corrected] = opno;
+                        msg("ECC failure, read data is incorrect despite read success\n");
+                        break;
+                }
+
+                opno++;
+        }
+
+        /* At this point bitstats[0] contains the number of ops with no bit
+         * errors, bitstats[1] the number of ops with 1 bit error, etc. */
+        msg("Bit error histogram (%d operations total):\n", opno);
+        for (i = 0; i < max_corrected; i++)
+                msg("Page reads with %3d corrected bit errors: %d\n",
+                        i, bitstats[i]);
+
+exit:
+        return err;
+}
+
+static int __init mtd_nandbiterrs_init(void)
+{
+        int err = 0;
+
+        msg("\n");
+        msg("==================================================\n");
+        msg("MTD device: %d\n", dev);
+
+        mtd = get_mtd_device(NULL, dev);
+        if (IS_ERR(mtd)) {
+                err = PTR_ERR(mtd);
+                msg("error: cannot get MTD device\n");
+                goto exit_mtddev;
+        }
+
+        if (mtd->type != MTD_NANDFLASH) {
+                msg("this test requires NAND flash\n");
+                err = -ENODEV;
+                goto exit_nand;
+        }
+
+        msg("MTD device size %llu, eraseblock=%u, page=%u, oob=%u\n",
+                (unsigned long long)mtd->size, mtd->erasesize,
+                mtd->writesize, mtd->oobsize);
+
+        subsize  = mtd->writesize >> mtd->subpage_sft;
+        subcount = mtd->writesize / subsize;
+
+        msg("Device uses %d subpages of %d bytes\n", subcount, subsize);
+
+        offset     = page_offset * mtd->writesize;
+        eraseblock = mtd_div_by_eb(offset, mtd);
+
+        msg("Using page=%u, offset=%llu, eraseblock=%u\n",
+                page_offset, offset, eraseblock);
+
+        wbuffer = kmalloc(mtd->writesize, GFP_KERNEL);
+        if (!wbuffer) {
+                err = -ENOMEM;
+                goto exit_wbuffer;
+        }
+
+        rbuffer = kmalloc(mtd->writesize, GFP_KERNEL);
+        if (!rbuffer) {
+                err = -ENOMEM;
+                goto exit_rbuffer;
+        }
+
+        err = erase_block();
+        if (err)
+                goto exit_error;
+
+        if (mode == 0)
+                err = incremental_errors_test();
+        else
+                err = overwrite_test();
+
+        if (err)
+                goto exit_error;
+
+        /* We leave the block un-erased in case of test failure. */
+        err = erase_block();
+        if (err)
+                goto exit_error;
+
+        err = -EIO;
+        msg("finished successfully.\n");
+        msg("==================================================\n");
+
+exit_error:
+        kfree(rbuffer);
+exit_rbuffer:
+        kfree(wbuffer);
+exit_wbuffer:
+        /* Nothing */
+exit_nand:
+        put_mtd_device(mtd);
+exit_mtddev:
+        return err;
+}
+
+static void __exit mtd_nandbiterrs_exit(void)
+{
+        return;
+}
+
+module_init(mtd_nandbiterrs_init);
+module_exit(mtd_nandbiterrs_exit);
+
+MODULE_DESCRIPTION("NAND bit error recovery test");
+MODULE_AUTHOR("Iwo Mergler");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/tests/mtd_nandecctest.c b/drivers/mtd/tests/mtd_nandecctest.c
index 70d6d7d0d656..b437fa425077 100644
--- a/drivers/mtd/tests/mtd_nandecctest.c
+++ b/drivers/mtd/tests/mtd_nandecctest.c
@@ -4,60 +4,287 @@
 #include <linux/random.h>
 #include <linux/string.h>
 #include <linux/bitops.h>
-#include <linux/jiffies.h>
+#include <linux/slab.h>
 #include <linux/mtd/nand_ecc.h>
 
+/*
+ * Test the implementation for software ECC
+ *
+ * No actual MTD device is needed, So we don't need to warry about losing
+ * important data by human error.
+ *
+ * This covers possible patterns of corruption which can be reliably corrected
+ * or detected.
+ */
+
 #if defined(CONFIG_MTD_NAND) || defined(CONFIG_MTD_NAND_MODULE)
 
-static void inject_single_bit_error(void *data, size_t size)
+struct nand_ecc_test {
+        const char *name;
+        void (*prepare)(void *, void *, void *, void *, const size_t);
+        int (*verify)(void *, void *, void *, const size_t);
+};
+
+/*
+ * The reason for this __change_bit_le() instead of __change_bit() is to inject
+ * bit error properly within the region which is not a multiple of
+ * sizeof(unsigned long) on big-endian systems
+ */
+#ifdef __LITTLE_ENDIAN
+#define __change_bit_le(nr, addr) __change_bit(nr, addr)
+#elif defined(__BIG_ENDIAN)
+#define __change_bit_le(nr, addr) \
+                __change_bit((nr) ^ ((BITS_PER_LONG - 1) & ~0x7), addr)
+#else
+#error "Unknown byte order"
+#endif
+
+static void single_bit_error_data(void *error_data, void *correct_data,
+                                size_t size)
 {
-        unsigned long offset = random32() % (size * BITS_PER_BYTE);
+        unsigned int offset = random32() % (size * BITS_PER_BYTE);
 
-        __change_bit(offset, data);
+        memcpy(error_data, correct_data, size);
+        __change_bit_le(offset, error_data);
 }
 
-static unsigned char data[512];
-static unsigned char error_data[512];
+static void double_bit_error_data(void *error_data, void *correct_data,
+                                size_t size)
+{
+        unsigned int offset[2];
+
+        offset[0] = random32() % (size * BITS_PER_BYTE);
+        do {
+                offset[1] = random32() % (size * BITS_PER_BYTE);
+        } while (offset[0] == offset[1]);
 
-static int nand_ecc_test(const size_t size)
+        memcpy(error_data, correct_data, size);
+
+        __change_bit_le(offset[0], error_data);
+        __change_bit_le(offset[1], error_data);
+}
+
+static unsigned int random_ecc_bit(size_t size)
 {
-        unsigned char code[3];
-        unsigned char error_code[3];
-        char testname[30];
+        unsigned int offset = random32() % (3 * BITS_PER_BYTE);
+
+        if (size == 256) {
+                /*
+                 * Don't inject a bit error into the insignificant bits (16th
+                 * and 17th bit) in ECC code for 256 byte data block
+                 */
+                while (offset == 16 || offset == 17)
+                        offset = random32() % (3 * BITS_PER_BYTE);
+        }
 
-        BUG_ON(sizeof(data) < size);
+        return offset;
+}
 
-        sprintf(testname, "nand-ecc-%zu", size);
+static void single_bit_error_ecc(void *error_ecc, void *correct_ecc,
+                                size_t size)
+{
+        unsigned int offset = random_ecc_bit(size);
 
-        get_random_bytes(data, size);
+        memcpy(error_ecc, correct_ecc, 3);
+        __change_bit_le(offset, error_ecc);
+}
 
-        memcpy(error_data, data, size);
-        inject_single_bit_error(error_data, size);
+static void double_bit_error_ecc(void *error_ecc, void *correct_ecc,
+                                size_t size)
+{
+        unsigned int offset[2];
 
-        __nand_calculate_ecc(data, size, code);
-        __nand_calculate_ecc(error_data, size, error_code);
-        __nand_correct_data(error_data, code, error_code, size);
+        offset[0] = random_ecc_bit(size);
+        do {
+                offset[1] = random_ecc_bit(size);
+        } while (offset[0] == offset[1]);
 
-        if (!memcmp(data, error_data, size)) {
-                printk(KERN_INFO "mtd_nandecctest: ok - %s\n", testname);
+        memcpy(error_ecc, correct_ecc, 3);
+        __change_bit_le(offset[0], error_ecc);
+        __change_bit_le(offset[1], error_ecc);
+}
+
+static void no_bit_error(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        memcpy(error_data, correct_data, size);
+        memcpy(error_ecc, correct_ecc, 3);
+}
+
+static int no_bit_error_verify(void *error_data, void *error_ecc,
+                                void *correct_data, const size_t size)
+{
+        unsigned char calc_ecc[3];
+        int ret;
+
+        __nand_calculate_ecc(error_data, size, calc_ecc);
+        ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size);
+        if (ret == 0 && !memcmp(correct_data, error_data, size))
                 return 0;
-        }
 
-        printk(KERN_ERR "mtd_nandecctest: not ok - %s\n", testname);
+        return -EINVAL;
+}
+
+static void single_bit_error_in_data(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        single_bit_error_data(error_data, correct_data, size);
+        memcpy(error_ecc, correct_ecc, 3);
+}
+
+static void single_bit_error_in_ecc(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        memcpy(error_data, correct_data, size);
+        single_bit_error_ecc(error_ecc, correct_ecc, size);
+}
+
+static int single_bit_error_correct(void *error_data, void *error_ecc,
+                                void *correct_data, const size_t size)
+{
+        unsigned char calc_ecc[3];
+        int ret;
 
-        printk(KERN_DEBUG "hexdump of data:\n");
-        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4,
-                        data, size, false);
-        printk(KERN_DEBUG "hexdump of error data:\n");
-        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 4,
+        __nand_calculate_ecc(error_data, size, calc_ecc);
+        ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size);
+        if (ret == 1 && !memcmp(correct_data, error_data, size))
+                return 0;
+
+        return -EINVAL;
+}
+
+static void double_bit_error_in_data(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        double_bit_error_data(error_data, correct_data, size);
+        memcpy(error_ecc, correct_ecc, 3);
+}
+
+static void single_bit_error_in_data_and_ecc(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        single_bit_error_data(error_data, correct_data, size);
+        single_bit_error_ecc(error_ecc, correct_ecc, size);
+}
+
+static void double_bit_error_in_ecc(void *error_data, void *error_ecc,
+                void *correct_data, void *correct_ecc, const size_t size)
+{
+        memcpy(error_data, correct_data, size);
+        double_bit_error_ecc(error_ecc, correct_ecc, size);
+}
+
+static int double_bit_error_detect(void *error_data, void *error_ecc,
+                                void *correct_data, const size_t size)
+{
+        unsigned char calc_ecc[3];
+        int ret;
+
+        __nand_calculate_ecc(error_data, size, calc_ecc);
+        ret = __nand_correct_data(error_data, error_ecc, calc_ecc, size);
+
+        return (ret == -1) ? 0 : -EINVAL;
+}
+
+static const struct nand_ecc_test nand_ecc_test[] = {
+        {
+                .name = "no-bit-error",
+                .prepare = no_bit_error,
+                .verify = no_bit_error_verify,
+        },
+        {
+                .name = "single-bit-error-in-data-correct",
+                .prepare = single_bit_error_in_data,
+                .verify = single_bit_error_correct,
+        },
+        {
+                .name = "single-bit-error-in-ecc-correct",
+                .prepare = single_bit_error_in_ecc,
+                .verify = single_bit_error_correct,
+        },
+        {
+                .name = "double-bit-error-in-data-detect",
+                .prepare = double_bit_error_in_data,
+                .verify = double_bit_error_detect,
+        },
+        {
+                .name = "single-bit-error-in-data-and-ecc-detect",
+                .prepare = single_bit_error_in_data_and_ecc,
+                .verify = double_bit_error_detect,
+        },
+        {
+                .name = "double-bit-error-in-ecc-detect",
+                .prepare = double_bit_error_in_ecc,
+                .verify = double_bit_error_detect,
+        },
+};
+
+static void dump_data_ecc(void *error_data, void *error_ecc, void *correct_data,
+                        void *correct_ecc, const size_t size)
+{
+        pr_info("hexdump of error data:\n");
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4,
                         error_data, size, false);
+        print_hex_dump(KERN_INFO, "hexdump of error ecc: ",
+                        DUMP_PREFIX_NONE, 16, 1, error_ecc, 3, false);
+
+        pr_info("hexdump of correct data:\n");
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 4,
+                        correct_data, size, false);
+        print_hex_dump(KERN_INFO, "hexdump of correct ecc: ",
+                        DUMP_PREFIX_NONE, 16, 1, correct_ecc, 3, false);
+}
+
+static int nand_ecc_test_run(const size_t size)
+{
+        int i;
+        int err = 0;
+        void *error_data;
+        void *error_ecc;
+        void *correct_data;
+        void *correct_ecc;
 
-        return -1;
+        error_data = kmalloc(size, GFP_KERNEL);
+        error_ecc = kmalloc(3, GFP_KERNEL);
+        correct_data = kmalloc(size, GFP_KERNEL);
+        correct_ecc = kmalloc(3, GFP_KERNEL);
+
+        if (!error_data || !error_ecc || !correct_data || !correct_ecc) {
+                err = -ENOMEM;
+                goto error;
+        }
+
+        get_random_bytes(correct_data, size);
+        __nand_calculate_ecc(correct_data, size, correct_ecc);
+
+        for (i = 0; i < ARRAY_SIZE(nand_ecc_test); i++) {
+                nand_ecc_test[i].prepare(error_data, error_ecc,
+                                correct_data, correct_ecc, size);
+                err = nand_ecc_test[i].verify(error_data, error_ecc,
+                                                correct_data, size);
+
+                if (err) {
+                        pr_err("mtd_nandecctest: not ok - %s-%zd\n",
+                                nand_ecc_test[i].name, size);
+                        dump_data_ecc(error_data, error_ecc,
+                                correct_data, correct_ecc, size);
+                        break;
+                }
+                pr_info("mtd_nandecctest: ok - %s-%zd\n",
+                        nand_ecc_test[i].name, size);
+        }
+error:
+        kfree(error_data);
+        kfree(error_ecc);
+        kfree(correct_data);
+        kfree(correct_ecc);
+
+        return err;
 }
 
 #else
 
-static int nand_ecc_test(const size_t size)
+static int nand_ecc_test_run(const size_t size)
 {
         return 0;
 }
@@ -66,12 +293,13 @@ static int nand_ecc_test(const size_t size)
 
 static int __init ecc_test_init(void)
 {
-        srandom32(jiffies);
+        int err;
 
-        nand_ecc_test(256);
-        nand_ecc_test(512);
+        err = nand_ecc_test_run(256);
+        if (err)
+                return err;
 
-        return 0;
+        return nand_ecc_test_run(512);
 }
 
 static void __exit ecc_test_exit(void)
diff --git a/drivers/mtd/tests/mtd_speedtest.c b/drivers/mtd/tests/mtd_speedtest.c
index 2aec4f3b72be..42b0f7456fc4 100644
--- a/drivers/mtd/tests/mtd_speedtest.c
+++ b/drivers/mtd/tests/mtd_speedtest.c
@@ -26,6 +26,7 @@
 #include <linux/mtd/mtd.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/random.h>
 
 #define PRINT_PREF KERN_INFO "mtd_speedtest: "
 
@@ -47,25 +48,13 @@ static int ebcnt;
 static int pgcnt;
 static int goodebcnt;
 static struct timeval start, finish;
-static unsigned long next = 1;
-
-static inline unsigned int simple_rand(void)
-{
-        next = next * 1103515245 + 12345;
-        return (unsigned int)((next / 65536) % 32768);
-}
-
-static inline void simple_srand(unsigned long seed)
-{
-        next = seed;
-}
 
 static void set_random_data(unsigned char *buf, size_t len)
 {
         size_t i;
 
         for (i = 0; i < len; ++i)
-                buf[i] = simple_rand();
+                buf[i] = random32();
 }
 
 static int erase_eraseblock(int ebnum)
@@ -407,7 +396,6 @@ static int __init mtd_speedtest_init(void)
                 goto out;
         }
 
-        simple_srand(1);
         set_random_data(iobuf, mtd->erasesize);
 
         err = scan_for_bad_eraseblocks();
diff --git a/drivers/mtd/tests/mtd_stresstest.c b/drivers/mtd/tests/mtd_stresstest.c
index 7b33f22d0b58..cb268cebf01a 100644
--- a/drivers/mtd/tests/mtd_stresstest.c
+++ b/drivers/mtd/tests/mtd_stresstest.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/vmalloc.h>
+#include <linux/random.h>
 
 #define PRINT_PREF KERN_INFO "mtd_stresstest: "
 
@@ -48,28 +49,13 @@ static int pgsize;
 static int bufsize;
 static int ebcnt;
 static int pgcnt;
-static unsigned long next = 1;
-
-static inline unsigned int simple_rand(void)
-{
-        next = next * 1103515245 + 12345;
-        return (unsigned int)((next / 65536) % 32768);
-}
-
-static inline void simple_srand(unsigned long seed)
-{
-        next = seed;
-}
 
 static int rand_eb(void)
 {
-        int eb;
+        unsigned int eb;
 
 again:
-        if (ebcnt < 32768)
-                eb = simple_rand();
-        else
-                eb = (simple_rand() << 15) | simple_rand();
+        eb = random32();
         /* Read or write up 2 eraseblocks at a time - hence 'ebcnt - 1' */
         eb %= (ebcnt - 1);
         if (bbt[eb])
@@ -79,24 +65,18 @@ again:
 
 static int rand_offs(void)
 {
-        int offs;
+        unsigned int offs;
 
-        if (bufsize < 32768)
-                offs = simple_rand();
-        else
-                offs = (simple_rand() << 15) | simple_rand();
+        offs = random32();
         offs %= bufsize;
         return offs;
 }
 
 static int rand_len(int offs)
 {
-        int len;
+        unsigned int len;
 
-        if (bufsize < 32768)
-                len = simple_rand();
-        else
-                len = (simple_rand() << 15) | simple_rand();
+        len = random32();
         len %= (bufsize - offs);
         return len;
 }
@@ -211,7 +191,7 @@ static int do_write(void)
 
 static int do_operation(void)
 {
-        if (simple_rand() & 1)
+        if (random32() & 1)
                 return do_read();
         else
                 return do_write();
@@ -302,9 +282,8 @@ static int __init mtd_stresstest_init(void)
         }
         for (i = 0; i < ebcnt; i++)
                 offsets[i] = mtd->erasesize;
-        simple_srand(current->pid);
         for (i = 0; i < bufsize; i++)
-                writebuf[i] = simple_rand();
+                writebuf[i] = random32();
 
         err = scan_for_bad_eraseblocks();
         if (err)
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 8c2ff2490d99..1acae359cabe 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -134,6 +134,7 @@ config SPI_DAVINCI
         tristate "Texas Instruments DaVinci/DA8x/OMAP-L/AM1x SoC SPI controller"
         depends on ARCH_DAVINCI
         select SPI_BITBANG
+        select TI_EDMA
         help
           SPI master controller for DaVinci/DA8x/OMAP-L/AM1x SPI modules.
 
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index 3afe2f4f5b8e..147dfa87a64b 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -25,13 +25,14 @@
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/clk.h>
+#include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
+#include <linux/edma.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 #include <linux/slab.h>
 
 #include <linux/platform_data/spi-davinci.h>
-#include <mach/edma.h>
 
 #define SPI_NO_RESOURCE         ((resource_size_t)-1)
 
@@ -113,14 +114,6 @@
 #define SPIDEF          0x4c
 #define SPIFMT0         0x50
 
-/* We have 2 DMA channels per CS, one for RX and one for TX */
-struct davinci_spi_dma {
-        int                     tx_channel;
-        int                     rx_channel;
-        int                     dummy_param_slot;
-        enum dma_event_q        eventq;
-};
-
 /* SPI Controller driver's private data. */
 struct davinci_spi {
         struct spi_bitbang      bitbang;
@@ -134,11 +127,14 @@ struct davinci_spi {
 
         const void              *tx;
         void                    *rx;
-#define SPI_TMP_BUFSZ   (SMP_CACHE_BYTES + 1)
-        u8                      rx_tmp_buf[SPI_TMP_BUFSZ];
         int                     rcount;
         int                     wcount;
-        struct davinci_spi_dma  dma;
+
+        struct dma_chan         *dma_rx;
+        struct dma_chan         *dma_tx;
+        int                     dma_rx_chnum;
+        int                     dma_tx_chnum;
+
         struct davinci_spi_platform_data *pdata;
 
         void                    (*get_rx)(u32 rx_data, struct davinci_spi *);
@@ -496,21 +492,23 @@ out:
         return errors;
 }
 
-static void davinci_spi_dma_callback(unsigned lch, u16 status, void *data)
+static void davinci_spi_dma_rx_callback(void *data)
 {
-        struct davinci_spi *dspi = data;
-        struct davinci_spi_dma *dma = &dspi->dma;
+        struct davinci_spi *dspi = (struct davinci_spi *)data;
 
-        edma_stop(lch);
+        dspi->rcount = 0;
 
-        if (status == DMA_COMPLETE) {
-                if (lch == dma->rx_channel)
-                        dspi->rcount = 0;
-                if (lch == dma->tx_channel)
-                        dspi->wcount = 0;
-        }
+        if (!dspi->wcount && !dspi->rcount)
+                complete(&dspi->done);
+}
 
-        if ((!dspi->wcount && !dspi->rcount) || (status != DMA_COMPLETE))
+static void davinci_spi_dma_tx_callback(void *data)
+{
+        struct davinci_spi *dspi = (struct davinci_spi *)data;
+
+        dspi->wcount = 0;
+
+        if (!dspi->wcount && !dspi->rcount)
                 complete(&dspi->done);
 }
 
@@ -526,20 +524,20 @@ static void davinci_spi_dma_callback(unsigned lch, u16 status, void *data)
 static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 {
         struct davinci_spi *dspi;
-        int data_type, ret;
+        int data_type, ret = -ENOMEM;
         u32 tx_data, spidat1;
         u32 errors = 0;
         struct davinci_spi_config *spicfg;
         struct davinci_spi_platform_data *pdata;
         unsigned uninitialized_var(rx_buf_count);
-        struct device *sdev;
+        void *dummy_buf = NULL;
+        struct scatterlist sg_rx, sg_tx;
 
         dspi = spi_master_get_devdata(spi->master);
         pdata = dspi->pdata;
         spicfg = (struct davinci_spi_config *)spi->controller_data;
         if (!spicfg)
                 spicfg = &davinci_spi_default_cfg;
-        sdev = dspi->bitbang.master->dev.parent;
 
         /* convert len to words based on bits_per_word */
         data_type = dspi->bytes_per_word[spi->chip_select];
@@ -567,112 +565,83 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
                 spidat1 |= tx_data & 0xFFFF;
                 iowrite32(spidat1, dspi->base + SPIDAT1);
         } else {
-                struct davinci_spi_dma *dma;
-                unsigned long tx_reg, rx_reg;
-                struct edmacc_param param;
-                void *rx_buf;
-                int b, c;
-
-                dma = &dspi->dma;
-
-                tx_reg = (unsigned long)dspi->pbase + SPIDAT1;
-                rx_reg = (unsigned long)dspi->pbase + SPIBUF;
-
-                /*
-                 * Transmit DMA setup
-                 *
-                 * If there is transmit data, map the transmit buffer, set it
-                 * as the source of data and set the source B index to data
-                 * size. If there is no transmit data, set the transmit register
-                 * as the source of data, and set the source B index to zero.
-                 *
-                 * The destination is always the transmit register itself. And
-                 * the destination never increments.
-                 */
-
-                if (t->tx_buf) {
-                        t->tx_dma = dma_map_single(&spi->dev, (void *)t->tx_buf,
-                                                t->len, DMA_TO_DEVICE);
-                        if (dma_mapping_error(&spi->dev, t->tx_dma)) {
-                                dev_dbg(sdev, "Unable to DMA map %d bytes"
-                                                "TX buffer\n", t->len);
-                                return -ENOMEM;
-                        }
-                }
-
-                /*
-                 * If number of words is greater than 65535, then we need
-                 * to configure a 3 dimension transfer.  Use the BCNTRLD
-                 * feature to allow for transfers that aren't even multiples
-                 * of 65535 (or any other possible b size) by first transferring
-                 * the remainder amount then grabbing the next N blocks of
-                 * 65535 words.
-                 */
-
-                c = dspi->wcount / (SZ_64K - 1);        /* N 65535 Blocks */
-                b = dspi->wcount - c * (SZ_64K - 1);    /* Remainder */
-                if (b)
-                        c++;
+                struct dma_slave_config dma_rx_conf = {
+                        .direction = DMA_DEV_TO_MEM,
+                        .src_addr = (unsigned long)dspi->pbase + SPIBUF,
+                        .src_addr_width = data_type,
+                        .src_maxburst = 1,
+                };
+                struct dma_slave_config dma_tx_conf = {
+                        .direction = DMA_MEM_TO_DEV,
+                        .dst_addr = (unsigned long)dspi->pbase + SPIDAT1,
+                        .dst_addr_width = data_type,
+                        .dst_maxburst = 1,
+                };
+                struct dma_async_tx_descriptor *rxdesc;
+                struct dma_async_tx_descriptor *txdesc;
+                void *buf;
+
+                dummy_buf = kzalloc(t->len, GFP_KERNEL);
+                if (!dummy_buf)
+                        goto err_alloc_dummy_buf;
+
+                dmaengine_slave_config(dspi->dma_rx, &dma_rx_conf);
+                dmaengine_slave_config(dspi->dma_tx, &dma_tx_conf);
+
+                sg_init_table(&sg_rx, 1);
+                if (!t->rx_buf)
+                        buf = dummy_buf;
                 else
-                        b = SZ_64K - 1;
-
-                param.opt = TCINTEN | EDMA_TCC(dma->tx_channel);
-                param.src = t->tx_buf ? t->tx_dma : tx_reg;
-                param.a_b_cnt = b << 16 | data_type;
-                param.dst = tx_reg;
-                param.src_dst_bidx = t->tx_buf ? data_type : 0;
-                param.link_bcntrld = 0xffffffff;
-                param.src_dst_cidx = t->tx_buf ? data_type : 0;
-                param.ccnt = c;
-                edma_write_slot(dma->tx_channel, &param);
-                edma_link(dma->tx_channel, dma->dummy_param_slot);
-
-                /*
-                 * Receive DMA setup
-                 *
-                 * If there is receive buffer, use it to receive data. If there
-                 * is none provided, use a temporary receive buffer. Set the
-                 * destination B index to 0 so effectively only one byte is used
-                 * in the temporary buffer (address does not increment).
-                 *
-                 * The source of receive data is the receive data register. The
-                 * source address never increments.
-                 */
-
-                if (t->rx_buf) {
-                        rx_buf = t->rx_buf;
-                        rx_buf_count = t->len;
-                } else {
-                        rx_buf = dspi->rx_tmp_buf;
-                        rx_buf_count = sizeof(dspi->rx_tmp_buf);
+                        buf = t->rx_buf;
+                t->rx_dma = dma_map_single(&spi->dev, buf,
+                                t->len, DMA_FROM_DEVICE);
+                if (!t->rx_dma) {
+                        ret = -EFAULT;
+                        goto err_rx_map;
                 }
+                sg_dma_address(&sg_rx) = t->rx_dma;
+                sg_dma_len(&sg_rx) = t->len;
 
-                t->rx_dma = dma_map_single(&spi->dev, rx_buf, rx_buf_count,
-                                                        DMA_FROM_DEVICE);
-                if (dma_mapping_error(&spi->dev, t->rx_dma)) {
-                        dev_dbg(sdev, "Couldn't DMA map a %d bytes RX buffer\n",
-                                                                rx_buf_count);
-                        if (t->tx_buf)
-                                dma_unmap_single(&spi->dev, t->tx_dma, t->len,
-                                                                DMA_TO_DEVICE);
-                        return -ENOMEM;
+                sg_init_table(&sg_tx, 1);
+                if (!t->tx_buf)
+                        buf = dummy_buf;
+                else
+                        buf = (void *)t->tx_buf;
+                t->tx_dma = dma_map_single(&spi->dev, buf,
+                                t->len, DMA_FROM_DEVICE);
+                if (!t->tx_dma) {
+                        ret = -EFAULT;
+                        goto err_tx_map;
                 }
-
-                param.opt = TCINTEN | EDMA_TCC(dma->rx_channel);
-                param.src = rx_reg;
-                param.a_b_cnt = b << 16 | data_type;
-                param.dst = t->rx_dma;
-                param.src_dst_bidx = (t->rx_buf ? data_type : 0) << 16;
-                param.link_bcntrld = 0xffffffff;
-                param.src_dst_cidx = (t->rx_buf ? data_type : 0) << 16;
-                param.ccnt = c;
-                edma_write_slot(dma->rx_channel, &param);
+                sg_dma_address(&sg_tx) = t->tx_dma;
+                sg_dma_len(&sg_tx) = t->len;
+
+                rxdesc = dmaengine_prep_slave_sg(dspi->dma_rx,
+                                &sg_rx, 1, DMA_DEV_TO_MEM,
+                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                if (!rxdesc)
+                        goto err_desc;
+
+                txdesc = dmaengine_prep_slave_sg(dspi->dma_tx,
+                                &sg_tx, 1, DMA_MEM_TO_DEV,
+                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                if (!txdesc)
+                        goto err_desc;
+
+                rxdesc->callback = davinci_spi_dma_rx_callback;
+                rxdesc->callback_param = (void *)dspi;
+                txdesc->callback = davinci_spi_dma_tx_callback;
+                txdesc->callback_param = (void *)dspi;
 
                 if (pdata->cshold_bug)
                         iowrite16(spidat1 >> 16, dspi->base + SPIDAT1 + 2);
 
-                edma_start(dma->rx_channel);
-                edma_start(dma->tx_channel);
+                dmaengine_submit(rxdesc);
+                dmaengine_submit(txdesc);
+
+                dma_async_issue_pending(dspi->dma_rx);
+                dma_async_issue_pending(dspi->dma_tx);
+
                 set_io_bits(dspi->base + SPIINT, SPIINT_DMA_REQ_EN);
         }
 
@@ -690,15 +659,13 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 
         clear_io_bits(dspi->base + SPIINT, SPIINT_MASKALL);
         if (spicfg->io_type == SPI_IO_TYPE_DMA) {
-
-                if (t->tx_buf)
-                        dma_unmap_single(&spi->dev, t->tx_dma, t->len,
-                                                                DMA_TO_DEVICE);
-
-                dma_unmap_single(&spi->dev, t->rx_dma, rx_buf_count,
-                                                        DMA_FROM_DEVICE);
-
                 clear_io_bits(dspi->base + SPIINT, SPIINT_DMA_REQ_EN);
+
+                dma_unmap_single(&spi->dev, t->rx_dma,
+                                t->len, DMA_FROM_DEVICE);
+                dma_unmap_single(&spi->dev, t->tx_dma,
+                                t->len, DMA_TO_DEVICE);
+                kfree(dummy_buf);
         }
 
         clear_io_bits(dspi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
@@ -716,11 +683,20 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
         }
 
         if (dspi->rcount != 0 || dspi->wcount != 0) {
-                dev_err(sdev, "SPI data transfer error\n");
+                dev_err(&spi->dev, "SPI data transfer error\n");
                 return -EIO;
         }
 
         return t->len;
+
+err_desc:
+        dma_unmap_single(&spi->dev, t->tx_dma, t->len, DMA_TO_DEVICE);
+err_tx_map:
+        dma_unmap_single(&spi->dev, t->rx_dma, t->len, DMA_FROM_DEVICE);
+err_rx_map:
+        kfree(dummy_buf);
+err_alloc_dummy_buf:
+        return ret;
 }
 
 /**
@@ -751,39 +727,33 @@ static irqreturn_t davinci_spi_irq(s32 irq, void *data)
 
 static int davinci_spi_request_dma(struct davinci_spi *dspi)
 {
+        dma_cap_mask_t mask;
+        struct device *sdev = dspi->bitbang.master->dev.parent;
         int r;
-        struct davinci_spi_dma *dma = &dspi->dma;
 
-        r = edma_alloc_channel(dma->rx_channel, davinci_spi_dma_callback, dspi,
-                                                                dma->eventq);
-        if (r < 0) {
-                pr_err("Unable to request DMA channel for SPI RX\n");
-                r = -EAGAIN;
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        dspi->dma_rx = dma_request_channel(mask, edma_filter_fn,
+                                           &dspi->dma_rx_chnum);
+        if (!dspi->dma_rx) {
+                dev_err(sdev, "request RX DMA channel failed\n");
+                r = -ENODEV;
                 goto rx_dma_failed;
         }
 
-        r = edma_alloc_channel(dma->tx_channel, davinci_spi_dma_callback, dspi,
-                                                                dma->eventq);
-        if (r < 0) {
-                pr_err("Unable to request DMA channel for SPI TX\n");
-                r = -EAGAIN;
+        dspi->dma_tx = dma_request_channel(mask, edma_filter_fn,
+                                           &dspi->dma_tx_chnum);
+        if (!dspi->dma_tx) {
+                dev_err(sdev, "request TX DMA channel failed\n");
+                r = -ENODEV;
                 goto tx_dma_failed;
         }
 
-        r = edma_alloc_slot(EDMA_CTLR(dma->tx_channel), EDMA_SLOT_ANY);
-        if (r < 0) {
-                pr_err("Unable to request SPI TX DMA param slot\n");
-                r = -EAGAIN;
-                goto param_failed;
-        }
-        dma->dummy_param_slot = r;
-        edma_link(dma->dummy_param_slot, dma->dummy_param_slot);
-
         return 0;
-param_failed:
-        edma_free_channel(dma->tx_channel);
+
 tx_dma_failed:
-        edma_free_channel(dma->rx_channel);
+        dma_release_channel(dspi->dma_rx);
 rx_dma_failed:
         return r;
 }
@@ -898,9 +868,8 @@ static int __devinit davinci_spi_probe(struct platform_device *pdev)
         dspi->bitbang.txrx_bufs = davinci_spi_bufs;
         if (dma_rx_chan != SPI_NO_RESOURCE &&
             dma_tx_chan != SPI_NO_RESOURCE) {
-                dspi->dma.rx_channel = dma_rx_chan;
-                dspi->dma.tx_channel = dma_tx_chan;
-                dspi->dma.eventq = pdata->dma_event_q;
+                dspi->dma_rx_chnum = dma_rx_chan;
+                dspi->dma_tx_chnum = dma_tx_chan;
 
                 ret = davinci_spi_request_dma(dspi);
                 if (ret)
@@ -955,9 +924,8 @@ static int __devinit davinci_spi_probe(struct platform_device *pdev)
         return ret;
 
 free_dma:
-        edma_free_channel(dspi->dma.tx_channel);
-        edma_free_channel(dspi->dma.rx_channel);
-        edma_free_slot(dspi->dma.dummy_param_slot);
+        dma_release_channel(dspi->dma_rx);
+        dma_release_channel(dspi->dma_tx);
 free_clk:
         clk_disable(dspi->clk);
         clk_put(dspi->clk);
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index ff6475f409d6..f3187938e081 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -16,6 +16,7 @@
  * Boston, MA 021110-1307, USA.
  */
 
+#include <linux/vmalloc.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "backref.h"
@@ -231,7 +232,7 @@ static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
                         }
                         if (!ret) {
                                 ret = ulist_add(parents, eb->start,
-                                                (unsigned long)eie, GFP_NOFS);
+                                                (uintptr_t)eie, GFP_NOFS);
                                 if (ret < 0)
                                         break;
                                 if (!extent_item_pos) {
@@ -363,8 +364,8 @@ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
                 ULIST_ITER_INIT(&uiter);
                 node = ulist_next(parents, &uiter);
                 ref->parent = node ? node->val : 0;
-                ref->inode_list =
-                        node ? (struct extent_inode_elem *)node->aux : 0;
+                ref->inode_list = node ?
+                        (struct extent_inode_elem *)(uintptr_t)node->aux : 0;
 
                 /* additional parents require new refs being added here */
                 while ((node = ulist_next(parents, &uiter))) {
@@ -375,8 +376,8 @@ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
                         }
                         memcpy(new_ref, ref, sizeof(*ref));
                         new_ref->parent = node->val;
-                        new_ref->inode_list =
-                                        (struct extent_inode_elem *)node->aux;
+                        new_ref->inode_list = (struct extent_inode_elem *)
+                                                        (uintptr_t)node->aux;
                         list_add(&new_ref->list, &ref->list);
                 }
                 ulist_reinit(parents);
@@ -914,8 +915,8 @@ again:
                                 free_extent_buffer(eb);
                         }
                         ret = ulist_add_merge(refs, ref->parent,
-                                              (unsigned long)ref->inode_list,
-                                              (unsigned long *)&eie, GFP_NOFS);
+                                              (uintptr_t)ref->inode_list,
+                                              (u64 *)&eie, GFP_NOFS);
                         if (!ret && extent_item_pos) {
                                 /*
                                  * we've recorded that parent, so we must extend
@@ -959,7 +960,7 @@ static void free_leaf_list(struct ulist *blocks)
         while ((node = ulist_next(blocks, &uiter))) {
                 if (!node->aux)
                         continue;
-                eie = (struct extent_inode_elem *)node->aux;
+                eie = (struct extent_inode_elem *)(uintptr_t)node->aux;
                 for (; eie; eie = eie_next) {
                         eie_next = eie->next;
                         kfree(eie);
@@ -1108,26 +1109,80 @@ static int inode_ref_info(u64 inum, u64 ioff, struct btrfs_root *fs_root,
                                 found_key);
 }
 
-/*
- * this iterates to turn a btrfs_inode_ref into a full filesystem path. elements
- * of the path are separated by '/' and the path is guaranteed to be
- * 0-terminated. the path is only given within the current file system.
- * Therefore, it never starts with a '/'. the caller is responsible to provide
- * "size" bytes in "dest". the dest buffer will be filled backwards. finally,
- * the start point of the resulting string is returned. this pointer is within
- * dest, normally.
- * in case the path buffer would overflow, the pointer is decremented further
- * as if output was written to the buffer, though no more output is actually
- * generated. that way, the caller can determine how much space would be
- * required for the path to fit into the buffer. in that case, the returned
- * value will be smaller than dest. callers must check this!
- */
-char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
-                         struct btrfs_inode_ref *iref,
+int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid,
+                          u64 start_off, struct btrfs_path *path,
+                          struct btrfs_inode_extref **ret_extref,
+                          u64 *found_off)
+{
+        int ret, slot;
+        struct btrfs_key key;
+        struct btrfs_key found_key;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        unsigned long ptr;
+
+        key.objectid = inode_objectid;
+        btrfs_set_key_type(&key, BTRFS_INODE_EXTREF_KEY);
+        key.offset = start_off;
+
+        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+        if (ret < 0)
+                return ret;
+
+        while (1) {
+                leaf = path->nodes[0];
+                slot = path->slots[0];
+                if (slot >= btrfs_header_nritems(leaf)) {
+                        /*
+                         * If the item at offset is not found,
+                         * btrfs_search_slot will point us to the slot
+                         * where it should be inserted. In our case
+                         * that will be the slot directly before the
+                         * next INODE_REF_KEY_V2 item. In the case
+                         * that we're pointing to the last slot in a
+                         * leaf, we must move one leaf over.
+                         */
+                        ret = btrfs_next_leaf(root, path);
+                        if (ret) {
+                                if (ret >= 1)
+                                        ret = -ENOENT;
+                                break;
+                        }
+                        continue;
+                }
+
+                btrfs_item_key_to_cpu(leaf, &found_key, slot);
+
+                /*
+                 * Check that we're still looking at an extended ref key for
+                 * this particular objectid. If we have different
+                 * objectid or type then there are no more to be found
+                 * in the tree and we can exit.
+                 */
+                ret = -ENOENT;
+                if (found_key.objectid != inode_objectid)
+                        break;
+                if (btrfs_key_type(&found_key) != BTRFS_INODE_EXTREF_KEY)
+                        break;
+
+                ret = 0;
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+                extref = (struct btrfs_inode_extref *)ptr;
+                *ret_extref = extref;
+                if (found_off)
+                        *found_off = found_key.offset;
+                break;
+        }
+
+        return ret;
+}
+
+static char *ref_to_path(struct btrfs_root *fs_root,
+                         struct btrfs_path *path,
+                         u32 name_len, unsigned long name_off,
                          struct extent_buffer *eb_in, u64 parent,
                          char *dest, u32 size)
 {
-        u32 len;
         int slot;
         u64 next_inum;
         int ret;
@@ -1135,17 +1190,17 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
         struct extent_buffer *eb = eb_in;
         struct btrfs_key found_key;
         int leave_spinning = path->leave_spinning;
+        struct btrfs_inode_ref *iref;
 
         if (bytes_left >= 0)
                 dest[bytes_left] = '\0';
 
         path->leave_spinning = 1;
         while (1) {
-                len = btrfs_inode_ref_name_len(eb, iref);
-                bytes_left -= len;
+                bytes_left -= name_len;
                 if (bytes_left >= 0)
                         read_extent_buffer(eb, dest + bytes_left,
-                                                (unsigned long)(iref + 1), len);
+                                           name_off, name_len);
                 if (eb != eb_in) {
                         btrfs_tree_read_unlock_blocking(eb);
                         free_extent_buffer(eb);
@@ -1155,6 +1210,7 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
                         ret = -ENOENT;
                 if (ret)
                         break;
+
                 next_inum = found_key.offset;
 
                 /* regular exit ahead */
@@ -1170,8 +1226,11 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
                         btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
                 }
                 btrfs_release_path(path);
-
                 iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
+
+                name_len = btrfs_inode_ref_name_len(eb, iref);
+                name_off = (unsigned long)(iref + 1);
+
                 parent = next_inum;
                 --bytes_left;
                 if (bytes_left >= 0)
@@ -1188,12 +1247,39 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
 }
 
 /*
+ * this iterates to turn a btrfs_inode_ref into a full filesystem path. elements
+ * of the path are separated by '/' and the path is guaranteed to be
+ * 0-terminated. the path is only given within the current file system.
+ * Therefore, it never starts with a '/'. the caller is responsible to provide
+ * "size" bytes in "dest". the dest buffer will be filled backwards. finally,
+ * the start point of the resulting string is returned. this pointer is within
+ * dest, normally.
+ * in case the path buffer would overflow, the pointer is decremented further
+ * as if output was written to the buffer, though no more output is actually
+ * generated. that way, the caller can determine how much space would be
+ * required for the path to fit into the buffer. in that case, the returned
+ * value will be smaller than dest. callers must check this!
+ */
+char *btrfs_iref_to_path(struct btrfs_root *fs_root,
+                         struct btrfs_path *path,
+                         struct btrfs_inode_ref *iref,
+                         struct extent_buffer *eb_in, u64 parent,
+                         char *dest, u32 size)
+{
+        return ref_to_path(fs_root, path,
+                           btrfs_inode_ref_name_len(eb_in, iref),
+                           (unsigned long)(iref + 1),
+                           eb_in, parent, dest, size);
+}
+
+/*
  * this makes the path point to (logical EXTENT_ITEM *)
  * returns BTRFS_EXTENT_FLAG_DATA for data, BTRFS_EXTENT_FLAG_TREE_BLOCK for
  * tree blocks and <0 on error.
  */
 int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
-                        struct btrfs_path *path, struct btrfs_key *found_key)
+                        struct btrfs_path *path, struct btrfs_key *found_key,
+                        u64 *flags_ret)
 {
         int ret;
         u64 flags;
@@ -1237,10 +1323,17 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
                  (unsigned long long)found_key->objectid,
                  (unsigned long long)found_key->offset,
                  (unsigned long long)flags, item_size);
-        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
-                return BTRFS_EXTENT_FLAG_TREE_BLOCK;
-        if (flags & BTRFS_EXTENT_FLAG_DATA)
-                return BTRFS_EXTENT_FLAG_DATA;
+
+        WARN_ON(!flags_ret);
+        if (flags_ret) {
+                if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+                        *flags_ret = BTRFS_EXTENT_FLAG_TREE_BLOCK;
+                else if (flags & BTRFS_EXTENT_FLAG_DATA)
+                        *flags_ret = BTRFS_EXTENT_FLAG_DATA;
+                else
+                        BUG_ON(1);
+                return 0;
+        }
 
         return -EIO;
 }
@@ -1404,12 +1497,13 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
                 ULIST_ITER_INIT(&root_uiter);
                 while (!ret && (root_node = ulist_next(roots, &root_uiter))) {
                         pr_debug("root %llu references leaf %llu, data list "
-                                 "%#lx\n", root_node->val, ref_node->val,
-                                 ref_node->aux);
-                        ret = iterate_leaf_refs(
-                                (struct extent_inode_elem *)ref_node->aux,
-                                root_node->val, extent_item_objectid,
-                                iterate, ctx);
+                                 "%#llx\n", root_node->val, ref_node->val,
+                                 (long long)ref_node->aux);
+                        ret = iterate_leaf_refs((struct extent_inode_elem *)
+                                                (uintptr_t)ref_node->aux,
+                                                root_node->val,
+                                                extent_item_objectid,
+                                                iterate, ctx);
                 }
                 ulist_free(roots);
                 roots = NULL;
@@ -1432,15 +1526,15 @@ int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
 {
         int ret;
         u64 extent_item_pos;
+        u64 flags = 0;
         struct btrfs_key found_key;
         int search_commit_root = path->search_commit_root;
 
-        ret = extent_from_logical(fs_info, logical, path,
-                                        &found_key);
+        ret = extent_from_logical(fs_info, logical, path, &found_key, &flags);
         btrfs_release_path(path);
         if (ret < 0)
                 return ret;
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
                 return -EINVAL;
 
         extent_item_pos = logical - found_key.objectid;
@@ -1451,9 +1545,12 @@ int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
         return ret;
 }
 
-static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
-                                struct btrfs_path *path,
-                                iterate_irefs_t *iterate, void *ctx)
+typedef int (iterate_irefs_t)(u64 parent, u32 name_len, unsigned long name_off,
+                              struct extent_buffer *eb, void *ctx);
+
+static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
+                              struct btrfs_path *path,
+                              iterate_irefs_t *iterate, void *ctx)
 {
         int ret = 0;
         int slot;
@@ -1470,7 +1567,7 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
         while (!ret) {
                 path->leave_spinning = 1;
                 ret = inode_ref_info(inum, parent ? parent+1 : 0, fs_root, path,
-                                        &found_key);
+                                     &found_key);
                 if (ret < 0)
                         break;
                 if (ret) {
@@ -1498,7 +1595,8 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
                                  "tree %llu\n", cur,
                                  (unsigned long long)found_key.objectid,
                                  (unsigned long long)fs_root->objectid);
-                        ret = iterate(parent, iref, eb, ctx);
+                        ret = iterate(parent, name_len,
+                                      (unsigned long)(iref + 1), eb, ctx);
                         if (ret)
                                 break;
                         len = sizeof(*iref) + name_len;
@@ -1513,12 +1611,98 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
         return ret;
 }
 
+static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root,
+                                 struct btrfs_path *path,
+                                 iterate_irefs_t *iterate, void *ctx)
+{
+        int ret;
+        int slot;
+        u64 offset = 0;
+        u64 parent;
+        int found = 0;
+        struct extent_buffer *eb;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        u32 item_size;
+        u32 cur_offset;
+        unsigned long ptr;
+
+        while (1) {
+                ret = btrfs_find_one_extref(fs_root, inum, offset, path, &extref,
+                                            &offset);
+                if (ret < 0)
+                        break;
+                if (ret) {
+                        ret = found ? 0 : -ENOENT;
+                        break;
+                }
+                ++found;
+
+                slot = path->slots[0];
+                eb = path->nodes[0];
+                /* make sure we can use eb after releasing the path */
+                atomic_inc(&eb->refs);
+
+                btrfs_tree_read_lock(eb);
+                btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
+                btrfs_release_path(path);
+
+                leaf = path->nodes[0];
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+                cur_offset = 0;
+
+                while (cur_offset < item_size) {
+                        u32 name_len;
+
+                        extref = (struct btrfs_inode_extref *)(ptr + cur_offset);
+                        parent = btrfs_inode_extref_parent(eb, extref);
+                        name_len = btrfs_inode_extref_name_len(eb, extref);
+                        ret = iterate(parent, name_len,
+                                      (unsigned long)&extref->name, eb, ctx);
+                        if (ret)
+                                break;
+
+                        cur_offset += btrfs_inode_extref_name_len(leaf, extref);
+                        cur_offset += sizeof(*extref);
+                }
+                btrfs_tree_read_unlock_blocking(eb);
+                free_extent_buffer(eb);
+
+                offset++;
+        }
+
+        btrfs_release_path(path);
+
+        return ret;
+}
+
+static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
+                         struct btrfs_path *path, iterate_irefs_t *iterate,
+                         void *ctx)
+{
+        int ret;
+        int found_refs = 0;
+
+        ret = iterate_inode_refs(inum, fs_root, path, iterate, ctx);
+        if (!ret)
+                ++found_refs;
+        else if (ret != -ENOENT)
+                return ret;
+
+        ret = iterate_inode_extrefs(inum, fs_root, path, iterate, ctx);
+        if (ret == -ENOENT && found_refs)
+                return 0;
+
+        return ret;
+}
+
 /*
  * returns 0 if the path could be dumped (probably truncated)
  * returns <0 in case of an error
  */
-static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
-                                struct extent_buffer *eb, void *ctx)
+static int inode_to_path(u64 inum, u32 name_len, unsigned long name_off,
+                         struct extent_buffer *eb, void *ctx)
 {
         struct inode_fs_paths *ipath = ctx;
         char *fspath;
@@ -1531,20 +1715,17 @@ static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
                                         ipath->fspath->bytes_left - s_ptr : 0;
 
         fspath_min = (char *)ipath->fspath->val + (i + 1) * s_ptr;
-        fspath = btrfs_iref_to_path(ipath->fs_root, ipath->btrfs_path, iref, eb,
-                                inum, fspath_min, bytes_left);
+        fspath = ref_to_path(ipath->fs_root, ipath->btrfs_path, name_len,
+                             name_off, eb, inum, fspath_min,
+                             bytes_left);
         if (IS_ERR(fspath))
                 return PTR_ERR(fspath);
 
         if (fspath > fspath_min) {
-                pr_debug("path resolved: %s\n", fspath);
                 ipath->fspath->val[i] = (u64)(unsigned long)fspath;
                 ++ipath->fspath->elem_cnt;
                 ipath->fspath->bytes_left = fspath - fspath_min;
         } else {
-                pr_debug("missed path, not enough space. missing bytes: %lu, "
-                         "constructed so far: %s\n",
-                         (unsigned long)(fspath_min - fspath), fspath_min);
                 ++ipath->fspath->elem_missed;
                 ipath->fspath->bytes_missing += fspath_min - fspath;
                 ipath->fspath->bytes_left = 0;
@@ -1566,7 +1747,7 @@ static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
 int paths_from_inode(u64 inum, struct inode_fs_paths *ipath)
 {
         return iterate_irefs(inum, ipath->fs_root, ipath->btrfs_path,
-                                inode_to_path, ipath);
+                             inode_to_path, ipath);
 }
 
 struct btrfs_data_container *init_data_container(u32 total_bytes)
@@ -1575,7 +1756,7 @@ struct btrfs_data_container *init_data_container(u32 total_bytes)
         size_t alloc_bytes;
 
         alloc_bytes = max_t(size_t, total_bytes, sizeof(*data));
-        data = kmalloc(alloc_bytes, GFP_NOFS);
+        data = vmalloc(alloc_bytes);
         if (!data)
                 return ERR_PTR(-ENOMEM);
 
@@ -1626,6 +1807,6 @@ void free_ipath(struct inode_fs_paths *ipath)
 {
         if (!ipath)
                 return;
-        kfree(ipath->fspath);
+        vfree(ipath->fspath);
         kfree(ipath);
 }
diff --git a/fs/btrfs/backref.h b/fs/btrfs/backref.h
index 032f4dc7eab8..e75533043a5f 100644
--- a/fs/btrfs/backref.h
+++ b/fs/btrfs/backref.h
@@ -33,14 +33,13 @@ struct inode_fs_paths {
 
 typedef int (iterate_extent_inodes_t)(u64 inum, u64 offset, u64 root,
                 void *ctx);
-typedef int (iterate_irefs_t)(u64 parent, struct btrfs_inode_ref *iref,
-                                struct extent_buffer *eb, void *ctx);
 
 int inode_item_info(u64 inum, u64 ioff, struct btrfs_root *fs_root,
                         struct btrfs_path *path);
 
 int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
-                        struct btrfs_path *path, struct btrfs_key *found_key);
+                        struct btrfs_path *path, struct btrfs_key *found_key,
+                        u64 *flags);
 
 int tree_backref_for_extent(unsigned long *ptr, struct extent_buffer *eb,
                                 struct btrfs_extent_item *ei, u32 item_size,
@@ -69,4 +68,9 @@ struct inode_fs_paths *init_ipath(s32 total_bytes, struct btrfs_root *fs_root,
                                         struct btrfs_path *path);
 void free_ipath(struct inode_fs_paths *ipath);
 
+int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid,
+                          u64 start_off, struct btrfs_path *path,
+                          struct btrfs_inode_extref **ret_extref,
+                          u64 *found_off);
+
 #endif
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 5b2ad6bc4fe7..ed8ca7ca5eff 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -38,6 +38,7 @@
 #define BTRFS_INODE_DELALLOC_META_RESERVED      4
 #define BTRFS_INODE_HAS_ORPHAN_ITEM             5
 #define BTRFS_INODE_HAS_ASYNC_EXTENT            6
+#define BTRFS_INODE_NEEDS_FULL_SYNC             7
 
 /* in memory btrfs inode */
 struct btrfs_inode {
@@ -143,6 +144,9 @@ struct btrfs_inode {
         /* flags field from the on disk inode */
         u32 flags;
 
+        /* a local copy of root's last_log_commit */
+        unsigned long last_log_commit;
+
         /*
          * Counters to keep track of the number of extent item's we may use due
          * to delalloc and such.  outstanding_extents is the number of extent
@@ -202,15 +206,10 @@ static inline bool btrfs_is_free_space_inode(struct inode *inode)
 
 static inline int btrfs_inode_in_log(struct inode *inode, u64 generation)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        int ret = 0;
-
-        mutex_lock(&root->log_mutex);
         if (BTRFS_I(inode)->logged_trans == generation &&
-            BTRFS_I(inode)->last_sub_trans <= root->last_log_commit)
-                ret = 1;
-        mutex_unlock(&root->log_mutex);
-        return ret;
+            BTRFS_I(inode)->last_sub_trans <= BTRFS_I(inode)->last_log_commit)
+                return 1;
+        return 0;
 }
 
 #endif
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 9197e2e33407..5a3e45db642a 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -37,8 +37,9 @@
  *        the file system was mounted, (i.e., they have been
  *        referenced by the super block) or they have been
  *        written since then and the write completion callback
- *        was called and a FLUSH request to the device where
- *        these blocks are located was received and completed.
+ *        was called and no write error was indicated and a
+ *        FLUSH request to the device where these blocks are
+ *        located was received and completed.
  *    2b. All referenced blocks need to have a generation
  *        number which is equal to the parent's number.
  *
@@ -2601,6 +2602,17 @@ static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state,
                                (unsigned long long)l->block_ref_to->dev_bytenr,
                                l->block_ref_to->mirror_num);
                         ret = -1;
+                } else if (l->block_ref_to->iodone_w_error) {
+                        printk(KERN_INFO "btrfs: attempt to write superblock"
+                               " which references block %c @%llu (%s/%llu/%d)"
+                               " which has write error!\n",
+                               btrfsic_get_block_type(state, l->block_ref_to),
+                               (unsigned long long)
+                               l->block_ref_to->logical_bytenr,
+                               l->block_ref_to->dev_state->name,
+                               (unsigned long long)l->block_ref_to->dev_bytenr,
+                               l->block_ref_to->mirror_num);
+                        ret = -1;
                 } else if (l->parent_generation !=
                            l->block_ref_to->generation &&
                            BTRFSIC_GENERATION_UNKNOWN !=
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 43d1c5a3a030..c6467aa88bee 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -577,6 +577,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         u64 em_start;
         struct extent_map *em;
         int ret = -ENOMEM;
+        int faili = 0;
         u32 *sums;
 
         tree = &BTRFS_I(inode)->io_tree;
@@ -626,9 +627,13 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         for (pg_index = 0; pg_index < nr_pages; pg_index++) {
                 cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS |
                                                               __GFP_HIGHMEM);
-                if (!cb->compressed_pages[pg_index])
+                if (!cb->compressed_pages[pg_index]) {
+                        faili = pg_index - 1;
+                        ret = -ENOMEM;
                         goto fail2;
+                }
         }
+        faili = nr_pages - 1;
         cb->nr_pages = nr_pages;
 
         add_ra_bio_pages(inode, em_start + em_len, cb);
@@ -713,8 +718,10 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         return 0;
 
 fail2:
-        for (pg_index = 0; pg_index < nr_pages; pg_index++)
-                free_page((unsigned long)cb->compressed_pages[pg_index]);
+        while (faili >= 0) {
+                __free_page(cb->compressed_pages[faili]);
+                faili--;
+        }
 
         kfree(cb->compressed_pages);
 fail1:
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 6d183f60d63a..b33436211000 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -4402,149 +4402,6 @@ void btrfs_extend_item(struct btrfs_trans_handle *trans,
 }
 
 /*
- * Given a key and some data, insert items into the tree.
- * This does all the path init required, making room in the tree if needed.
- * Returns the number of keys that were inserted.
- */
-int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
-                            struct btrfs_root *root,
-                            struct btrfs_path *path,
-                            struct btrfs_key *cpu_key, u32 *data_size,
-                            int nr)
-{
-        struct extent_buffer *leaf;
-        struct btrfs_item *item;
-        int ret = 0;
-        int slot;
-        int i;
-        u32 nritems;
-        u32 total_data = 0;
-        u32 total_size = 0;
-        unsigned int data_end;
-        struct btrfs_disk_key disk_key;
-        struct btrfs_key found_key;
-        struct btrfs_map_token token;
-
-        btrfs_init_map_token(&token);
-
-        for (i = 0; i < nr; i++) {
-                if (total_size + data_size[i] + sizeof(struct btrfs_item) >
-                    BTRFS_LEAF_DATA_SIZE(root)) {
-                        break;
-                        nr = i;
-                }
-                total_data += data_size[i];
-                total_size += data_size[i] + sizeof(struct btrfs_item);
-        }
-        BUG_ON(nr == 0);
-
-        ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
-        if (ret == 0)
-                return -EEXIST;
-        if (ret < 0)
-                goto out;
-
-        leaf = path->nodes[0];
-
-        nritems = btrfs_header_nritems(leaf);
-        data_end = leaf_data_end(root, leaf);
-
-        if (btrfs_leaf_free_space(root, leaf) < total_size) {
-                for (i = nr; i >= 0; i--) {
-                        total_data -= data_size[i];
-                        total_size -= data_size[i] + sizeof(struct btrfs_item);
-                        if (total_size < btrfs_leaf_free_space(root, leaf))
-                                break;
-                }
-                nr = i;
-        }
-
-        slot = path->slots[0];
-        BUG_ON(slot < 0);
-
-        if (slot != nritems) {
-                unsigned int old_data = btrfs_item_end_nr(leaf, slot);
-
-                item = btrfs_item_nr(leaf, slot);
-                btrfs_item_key_to_cpu(leaf, &found_key, slot);
-
-                /* figure out how many keys we can insert in here */
-                total_data = data_size[0];
-                for (i = 1; i < nr; i++) {
-                        if (btrfs_comp_cpu_keys(&found_key, cpu_key + i) <= 0)
-                                break;
-                        total_data += data_size[i];
-                }
-                nr = i;
-
-                if (old_data < data_end) {
-                        btrfs_print_leaf(root, leaf);
-                        printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
-                               slot, old_data, data_end);
-                        BUG_ON(1);
-                }
-                /*
-                 * item0..itemN ... dataN.offset..dataN.size .. data0.size
-                 */
-                /* first correct the data pointers */
-                for (i = slot; i < nritems; i++) {
-                        u32 ioff;
-
-                        item = btrfs_item_nr(leaf, i);
-                        ioff = btrfs_token_item_offset(leaf, item, &token);
-                        btrfs_set_token_item_offset(leaf, item,
-                                                    ioff - total_data, &token);
-                }
-                /* shift the items */
-                memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
-                              btrfs_item_nr_offset(slot),
-                              (nritems - slot) * sizeof(struct btrfs_item));
-
-                /* shift the data */
-                memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
-                              data_end - total_data, btrfs_leaf_data(leaf) +
-                              data_end, old_data - data_end);
-                data_end = old_data;
-        } else {
-                /*
-                 * this sucks but it has to be done, if we are inserting at
-                 * the end of the leaf only insert 1 of the items, since we
-                 * have no way of knowing whats on the next leaf and we'd have
-                 * to drop our current locks to figure it out
-                 */
-                nr = 1;
-        }
-
-        /* setup the item for the new data */
-        for (i = 0; i < nr; i++) {
-                btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
-                btrfs_set_item_key(leaf, &disk_key, slot + i);
-                item = btrfs_item_nr(leaf, slot + i);
-                btrfs_set_token_item_offset(leaf, item,
-                                            data_end - data_size[i], &token);
-                data_end -= data_size[i];
-                btrfs_set_token_item_size(leaf, item, data_size[i], &token);
-        }
-        btrfs_set_header_nritems(leaf, nritems + nr);
-        btrfs_mark_buffer_dirty(leaf);
-
-        ret = 0;
-        if (slot == 0) {
-                btrfs_cpu_key_to_disk(&disk_key, cpu_key);
-                fixup_low_keys(trans, root, path, &disk_key, 1);
-        }
-
-        if (btrfs_leaf_free_space(root, leaf) < 0) {
-                btrfs_print_leaf(root, leaf);
-                BUG();
-        }
-out:
-        if (!ret)
-                ret = nr;
-        return ret;
-}
-
-/*
  * this is a helper for btrfs_insert_empty_items, the main goal here is
  * to save stack depth by doing the bulk of the work in a function
  * that doesn't call btrfs_search_slot
@@ -5073,6 +4930,7 @@ static void tree_move_down(struct btrfs_root *root,
                            struct btrfs_path *path,
                            int *level, int root_level)
 {
+        BUG_ON(*level == 0);
         path->nodes[*level - 1] = read_node_slot(root, path->nodes[*level],
                                         path->slots[*level]);
         path->slots[*level - 1] = 0;
@@ -5089,7 +4947,7 @@ static int tree_move_next_or_upnext(struct btrfs_root *root,
 
         path->slots[*level]++;
 
-        while (path->slots[*level] == nritems) {
+        while (path->slots[*level] >= nritems) {
                 if (*level == root_level)
                         return -1;
 
@@ -5433,9 +5291,11 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
                                         goto out;
                                 advance_right = ADVANCE;
                         } else {
+                                WARN_ON(!extent_buffer_uptodate(left_path->nodes[0]));
                                 ret = tree_compare_item(left_root, left_path,
                                                 right_path, tmp_buf);
                                 if (ret) {
+                                        WARN_ON(!extent_buffer_uptodate(left_path->nodes[0]));
                                         ret = changed_cb(left_root, right_root,
                                                 left_path, right_path,
                                                 &left_key,
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 9821b672f5a2..926c9ffc66d9 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -154,6 +154,13 @@ struct btrfs_ordered_sum;
  */
 #define BTRFS_NAME_LEN 255
 
+/*
+ * Theoretical limit is larger, but we keep this down to a sane
+ * value. That should limit greatly the possibility of collisions on
+ * inode ref items.
+ */
+#define BTRFS_LINK_MAX 65535U
+
 /* 32 bytes in various csum fields */
 #define BTRFS_CSUM_SIZE 32
 
@@ -489,6 +496,8 @@ struct btrfs_super_block {
  */
 #define BTRFS_FEATURE_INCOMPAT_BIG_METADATA     (1ULL << 5)
 
+#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF    (1ULL << 6)
+
 #define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 #define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
 #define BTRFS_FEATURE_INCOMPAT_SUPP                     \
@@ -496,7 +505,8 @@ struct btrfs_super_block {
          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
          BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
          BTRFS_FEATURE_INCOMPAT_BIG_METADATA |          \
-         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO)
+         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |          \
+         BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
 
 /*
  * A leaf is full of items. offset and size tell us where to find
@@ -643,6 +653,14 @@ struct btrfs_inode_ref {
         /* name goes here */
 } __attribute__ ((__packed__));
 
+struct btrfs_inode_extref {
+        __le64 parent_objectid;
+        __le64 index;
+        __le16 name_len;
+        __u8   name[0];
+        /* name goes here */
+} __attribute__ ((__packed__));
+
 struct btrfs_timespec {
         __le64 sec;
         __le32 nsec;
@@ -1028,12 +1046,22 @@ struct btrfs_space_info {
         wait_queue_head_t wait;
 };
 
+#define BTRFS_BLOCK_RSV_GLOBAL          1
+#define BTRFS_BLOCK_RSV_DELALLOC        2
+#define BTRFS_BLOCK_RSV_TRANS           3
+#define BTRFS_BLOCK_RSV_CHUNK           4
+#define BTRFS_BLOCK_RSV_DELOPS          5
+#define BTRFS_BLOCK_RSV_EMPTY           6
+#define BTRFS_BLOCK_RSV_TEMP            7
+
 struct btrfs_block_rsv {
         u64 size;
         u64 reserved;
         struct btrfs_space_info *space_info;
         spinlock_t lock;
-        unsigned int full;
+        unsigned short full;
+        unsigned short type;
+        unsigned short failfast;
 };
 
 /*
@@ -1127,6 +1155,9 @@ struct btrfs_block_group_cache {
          * Today it will only have one thing on it, but that may change
          */
         struct list_head cluster_list;
+
+        /* For delayed block group creation */
+        struct list_head new_bg_list;
 };
 
 /* delayed seq elem */
@@ -1240,7 +1271,6 @@ struct btrfs_fs_info {
         struct mutex reloc_mutex;
 
         struct list_head trans_list;
-        struct list_head hashers;
         struct list_head dead_roots;
         struct list_head caching_block_groups;
 
@@ -1366,9 +1396,6 @@ struct btrfs_fs_info {
         struct rb_root defrag_inodes;
         atomic_t defrag_running;
 
-        spinlock_t ref_cache_lock;
-        u64 total_ref_cache_size;
-
         /*
          * these three are in extended format (availability of single
          * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
@@ -1441,6 +1468,8 @@ struct btrfs_fs_info {
 
         /* next backup root to be overwritten */
         int backup_root_index;
+
+        int num_tolerated_disk_barrier_failures;
 };
 
 /*
@@ -1481,9 +1510,9 @@ struct btrfs_root {
         wait_queue_head_t log_commit_wait[2];
         atomic_t log_writers;
         atomic_t log_commit[2];
+        atomic_t log_batch;
         unsigned long log_transid;
         unsigned long last_log_commit;
-        unsigned long log_batch;
         pid_t log_start_pid;
         bool log_multiple_pids;
 
@@ -1592,6 +1621,7 @@ struct btrfs_ioctl_defrag_range_args {
  */
 #define BTRFS_INODE_ITEM_KEY            1
 #define BTRFS_INODE_REF_KEY             12
+#define BTRFS_INODE_EXTREF_KEY          13
 #define BTRFS_XATTR_ITEM_KEY            24
 #define BTRFS_ORPHAN_ITEM_KEY           48
 /* reserve 2-15 close to the inode for later flexibility */
@@ -1978,6 +2008,13 @@ BTRFS_SETGET_STACK_FUNCS(block_group_flags,
 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
 
+/* struct btrfs_inode_extref */
+BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
+                   parent_objectid, 64);
+BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
+                   name_len, 16);
+BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
+
 /* struct btrfs_inode_item */
 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
@@ -2858,6 +2895,8 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
                            u64 size);
 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root, u64 group_start);
+void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
+                                       struct btrfs_root *root);
 u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
 u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
 void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
@@ -2874,8 +2913,9 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
 void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
 int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
 void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
-void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv);
-struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root);
+void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
+struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
+                                              unsigned short type);
 void btrfs_free_block_rsv(struct btrfs_root *root,
                           struct btrfs_block_rsv *rsv);
 int btrfs_block_rsv_add(struct btrfs_root *root,
@@ -3172,12 +3212,12 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            const char *name, int name_len,
                            u64 inode_objectid, u64 ref_objectid, u64 *index);
-struct btrfs_inode_ref *
-btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root,
-                        struct btrfs_path *path,
-                        const char *name, int name_len,
-                        u64 inode_objectid, u64 ref_objectid, int mod);
+int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
+                              struct btrfs_root *root,
+                              struct btrfs_path *path,
+                              const char *name, int name_len,
+                              u64 inode_objectid, u64 ref_objectid, int mod,
+                              u64 *ret_index);
 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
                              struct btrfs_path *path, u64 objectid);
@@ -3185,6 +3225,19 @@ int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
                        *root, struct btrfs_path *path,
                        struct btrfs_key *location, int mod);
 
+struct btrfs_inode_extref *
+btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root,
+                          struct btrfs_path *path,
+                          const char *name, int name_len,
+                          u64 inode_objectid, u64 ref_objectid, int ins_len,
+                          int cow);
+
+int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
+                                   u64 ref_objectid, const char *name,
+                                   int name_len,
+                                   struct btrfs_inode_extref **extref_ret);
+
 /* file-item.c */
 int btrfs_del_csums(struct btrfs_trans_handle *trans,
                     struct btrfs_root *root, u64 bytenr, u64 len);
@@ -3249,6 +3302,8 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root,
                         struct inode *dir, u64 objectid,
                         const char *name, int name_len);
+int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
+                        int front);
 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root,
                                struct inode *inode, u64 new_size,
@@ -3308,16 +3363,27 @@ void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
 int btrfs_defrag_file(struct inode *inode, struct file *file,
                       struct btrfs_ioctl_defrag_range_args *range,
                       u64 newer_than, unsigned long max_pages);
+void btrfs_get_block_group_info(struct list_head *groups_list,
+                                struct btrfs_ioctl_space_info *space);
+
 /* file.c */
 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
                            struct inode *inode);
 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
-int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
-                            int skip_pinned);
+void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
+                             int skip_pinned);
+int btrfs_replace_extent_cache(struct inode *inode, struct extent_map *replace,
+                               u64 start, u64 end, int skip_pinned,
+                               int modified);
 extern const struct file_operations btrfs_file_operations;
-int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
-                       u64 start, u64 end, u64 *hint_byte, int drop_cache);
+int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                         struct btrfs_root *root, struct inode *inode,
+                         struct btrfs_path *path, u64 start, u64 end,
+                         u64 *drop_end, int drop_cache);
+int btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root, struct inode *inode, u64 start,
+                       u64 end, int drop_cache);
 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
                               struct inode *inode, u64 start, u64 end);
 int btrfs_release_file(struct inode *inode, struct file *file);
@@ -3378,6 +3444,11 @@ static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
         }
 }
 
+/*
+ * Call btrfs_abort_transaction as early as possible when an error condition is
+ * detected, that way the exact line number is reported.
+ */
+
 #define btrfs_abort_transaction(trans, root, errno)             \
 do {                                                            \
         __btrfs_abort_transaction(trans, root, __func__,        \
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 52c85e2b95d0..478f66bdc57b 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -29,7 +29,7 @@ static struct kmem_cache *delayed_node_cache;
 
 int __init btrfs_delayed_inode_init(void)
 {
-        delayed_node_cache = kmem_cache_create("delayed_node",
+        delayed_node_cache = kmem_cache_create("btrfs_delayed_node",
                                         sizeof(struct btrfs_delayed_node),
                                         0,
                                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
@@ -650,7 +650,7 @@ static int btrfs_delayed_inode_reserve_metadata(
          * we're accounted for.
          */
         if (!src_rsv || (!trans->bytes_reserved &&
-            src_rsv != &root->fs_info->delalloc_block_rsv)) {
+                         src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) {
                 ret = btrfs_block_rsv_add_noflush(root, dst_rsv, num_bytes);
                 /*
                  * Since we're under a transaction reserve_metadata_bytes could
@@ -668,7 +668,7 @@ static int btrfs_delayed_inode_reserve_metadata(
                                                       num_bytes, 1);
                 }
                 return ret;
-        } else if (src_rsv == &root->fs_info->delalloc_block_rsv) {
+        } else if (src_rsv->type == BTRFS_BLOCK_RSV_DELALLOC) {
                 spin_lock(&BTRFS_I(inode)->lock);
                 if (test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
                                        &BTRFS_I(inode)->runtime_flags)) {
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 22e98e04c2ea..7cda51995c1e 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -46,6 +46,10 @@
 #include "check-integrity.h"
 #include "rcu-string.h"
 
+#ifdef CONFIG_X86
+#include <asm/cpufeature.h>
+#endif
+
 static struct extent_io_ops btree_extent_io_ops;
 static void end_workqueue_fn(struct btrfs_work *work);
 static void free_fs_root(struct btrfs_root *root);
@@ -217,26 +221,16 @@ static struct extent_map *btree_get_extent(struct inode *inode,
         write_lock(&em_tree->lock);
         ret = add_extent_mapping(em_tree, em);
         if (ret == -EEXIST) {
-                u64 failed_start = em->start;
-                u64 failed_len = em->len;
-
                 free_extent_map(em);
                 em = lookup_extent_mapping(em_tree, start, len);
-                if (em) {
-                        ret = 0;
-                } else {
-                        em = lookup_extent_mapping(em_tree, failed_start,
-                                                   failed_len);
-                        ret = -EIO;
-                }
+                if (!em)
+                        em = ERR_PTR(-EIO);
         } else if (ret) {
                 free_extent_map(em);
-                em = NULL;
+                em = ERR_PTR(ret);
         }
         write_unlock(&em_tree->lock);
 
-        if (ret)
-                em = ERR_PTR(ret);
 out:
         return em;
 }
@@ -439,10 +433,6 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
                 WARN_ON(1);
                 return 0;
         }
-        if (eb->pages[0] != page) {
-                WARN_ON(1);
-                return 0;
-        }
         if (!PageUptodate(page)) {
                 WARN_ON(1);
                 return 0;
@@ -869,10 +859,22 @@ static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
         return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
 }
 
+static int check_async_write(struct inode *inode, unsigned long bio_flags)
+{
+        if (bio_flags & EXTENT_BIO_TREE_LOG)
+                return 0;
+#ifdef CONFIG_X86
+        if (cpu_has_xmm4_2)
+                return 0;
+#endif
+        return 1;
+}
+
 static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags,
                                  u64 bio_offset)
 {
+        int async = check_async_write(inode, bio_flags);
         int ret;
 
         if (!(rw & REQ_WRITE)) {
@@ -887,6 +889,12 @@ static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                         return ret;
                 return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
                                      mirror_num, 0);
+        } else if (!async) {
+                ret = btree_csum_one_bio(bio);
+                if (ret)
+                        return ret;
+                return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
+                                     mirror_num, 0);
         }
 
         /*
@@ -1168,8 +1176,8 @@ static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
         atomic_set(&root->log_commit[0], 0);
         atomic_set(&root->log_commit[1], 0);
         atomic_set(&root->log_writers, 0);
+        atomic_set(&root->log_batch, 0);
         atomic_set(&root->orphan_inodes, 0);
-        root->log_batch = 0;
         root->log_transid = 0;
         root->last_log_commit = 0;
         extent_io_tree_init(&root->dirty_log_pages,
@@ -1667,9 +1675,10 @@ static int transaction_kthread(void *arg)
                 spin_unlock(&root->fs_info->trans_lock);
 
                 /* If the file system is aborted, this will always fail. */
-                trans = btrfs_join_transaction(root);
+                trans = btrfs_attach_transaction(root);
                 if (IS_ERR(trans)) {
-                        cannot_commit = true;
+                        if (PTR_ERR(trans) != -ENOENT)
+                                cannot_commit = true;
                         goto sleep;
                 }
                 if (transid == trans->transid) {
@@ -1994,13 +2003,11 @@ int open_ctree(struct super_block *sb,
         INIT_LIST_HEAD(&fs_info->trans_list);
         INIT_LIST_HEAD(&fs_info->dead_roots);
         INIT_LIST_HEAD(&fs_info->delayed_iputs);
-        INIT_LIST_HEAD(&fs_info->hashers);
         INIT_LIST_HEAD(&fs_info->delalloc_inodes);
         INIT_LIST_HEAD(&fs_info->ordered_operations);
         INIT_LIST_HEAD(&fs_info->caching_block_groups);
         spin_lock_init(&fs_info->delalloc_lock);
         spin_lock_init(&fs_info->trans_lock);
-        spin_lock_init(&fs_info->ref_cache_lock);
         spin_lock_init(&fs_info->fs_roots_radix_lock);
         spin_lock_init(&fs_info->delayed_iput_lock);
         spin_lock_init(&fs_info->defrag_inodes_lock);
@@ -2014,12 +2021,15 @@ int open_ctree(struct super_block *sb,
         INIT_LIST_HEAD(&fs_info->space_info);
         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
         btrfs_mapping_init(&fs_info->mapping_tree);
-        btrfs_init_block_rsv(&fs_info->global_block_rsv);
-        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
-        btrfs_init_block_rsv(&fs_info->trans_block_rsv);
-        btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
-        btrfs_init_block_rsv(&fs_info->empty_block_rsv);
-        btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
+        btrfs_init_block_rsv(&fs_info->global_block_rsv,
+                             BTRFS_BLOCK_RSV_GLOBAL);
+        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
+                             BTRFS_BLOCK_RSV_DELALLOC);
+        btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
+        btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
+        btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
+        btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
+                             BTRFS_BLOCK_RSV_DELOPS);
         atomic_set(&fs_info->nr_async_submits, 0);
         atomic_set(&fs_info->async_delalloc_pages, 0);
         atomic_set(&fs_info->async_submit_draining, 0);
@@ -2491,6 +2501,8 @@ retry_root_backup:
                 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
                 goto fail_block_groups;
         }
+        fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
 
         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
                                                "btrfs-cleaner");
@@ -2874,12 +2886,10 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
                         printk_in_rcu("btrfs: disabling barriers on dev %s\n",
                                       rcu_str_deref(device->name));
                         device->nobarriers = 1;
-                }
-                if (!bio_flagged(bio, BIO_UPTODATE)) {
+                } else if (!bio_flagged(bio, BIO_UPTODATE)) {
                         ret = -EIO;
-                        if (!bio_flagged(bio, BIO_EOPNOTSUPP))
-                                btrfs_dev_stat_inc_and_print(device,
-                                        BTRFS_DEV_STAT_FLUSH_ERRS);
+                        btrfs_dev_stat_inc_and_print(device,
+                                BTRFS_DEV_STAT_FLUSH_ERRS);
                 }
 
                 /* drop the reference from the wait == 0 run */
@@ -2918,14 +2928,15 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 {
         struct list_head *head;
         struct btrfs_device *dev;
-        int errors = 0;
+        int errors_send = 0;
+        int errors_wait = 0;
         int ret;
 
         /* send down all the barriers */
         head = &info->fs_devices->devices;
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
-                        errors++;
+                        errors_send++;
                         continue;
                 }
                 if (!dev->in_fs_metadata || !dev->writeable)
@@ -2933,13 +2944,13 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 
                 ret = write_dev_flush(dev, 0);
                 if (ret)
-                        errors++;
+                        errors_send++;
         }
 
         /* wait for all the barriers */
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
-                        errors++;
+                        errors_wait++;
                         continue;
                 }
                 if (!dev->in_fs_metadata || !dev->writeable)
@@ -2947,13 +2958,87 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 
                 ret = write_dev_flush(dev, 1);
                 if (ret)
-                        errors++;
+                        errors_wait++;
         }
-        if (errors)
+        if (errors_send > info->num_tolerated_disk_barrier_failures ||
+            errors_wait > info->num_tolerated_disk_barrier_failures)
                 return -EIO;
         return 0;
 }
 
+int btrfs_calc_num_tolerated_disk_barrier_failures(
+        struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_ioctl_space_info space;
+        struct btrfs_space_info *sinfo;
+        u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
+                       BTRFS_BLOCK_GROUP_SYSTEM,
+                       BTRFS_BLOCK_GROUP_METADATA,
+                       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
+        int num_types = 4;
+        int i;
+        int c;
+        int num_tolerated_disk_barrier_failures =
+                (int)fs_info->fs_devices->num_devices;
+
+        for (i = 0; i < num_types; i++) {
+                struct btrfs_space_info *tmp;
+
+                sinfo = NULL;
+                rcu_read_lock();
+                list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
+                        if (tmp->flags == types[i]) {
+                                sinfo = tmp;
+                                break;
+                        }
+                }
+                rcu_read_unlock();
+
+                if (!sinfo)
+                        continue;
+
+                down_read(&sinfo->groups_sem);
+                for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
+                        if (!list_empty(&sinfo->block_groups[c])) {
+                                u64 flags;
+
+                                btrfs_get_block_group_info(
+                                        &sinfo->block_groups[c], &space);
+                                if (space.total_bytes == 0 ||
+                                    space.used_bytes == 0)
+                                        continue;
+                                flags = space.flags;
+                                /*
+                                 * return
+                                 * 0: if dup, single or RAID0 is configured for
+                                 *    any of metadata, system or data, else
+                                 * 1: if RAID5 is configured, or if RAID1 or
+                                 *    RAID10 is configured and only two mirrors
+                                 *    are used, else
+                                 * 2: if RAID6 is configured, else
+                                 * num_mirrors - 1: if RAID1 or RAID10 is
+                                 *                  configured and more than
+                                 *                  2 mirrors are used.
+                                 */
+                                if (num_tolerated_disk_barrier_failures > 0 &&
+                                    ((flags & (BTRFS_BLOCK_GROUP_DUP |
+                                               BTRFS_BLOCK_GROUP_RAID0)) ||
+                                     ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
+                                      == 0)))
+                                        num_tolerated_disk_barrier_failures = 0;
+                                else if (num_tolerated_disk_barrier_failures > 1
+                                         &&
+                                         (flags & (BTRFS_BLOCK_GROUP_RAID1 |
+                                                   BTRFS_BLOCK_GROUP_RAID10)))
+                                        num_tolerated_disk_barrier_failures = 1;
+                        }
+                }
+                up_read(&sinfo->groups_sem);
+        }
+
+        return num_tolerated_disk_barrier_failures;
+}
+
 int write_all_supers(struct btrfs_root *root, int max_mirrors)
 {
         struct list_head *head;
@@ -2976,8 +3061,16 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors)
         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
         head = &root->fs_info->fs_devices->devices;
 
-        if (do_barriers)
-                barrier_all_devices(root->fs_info);
+        if (do_barriers) {
+                ret = barrier_all_devices(root->fs_info);
+                if (ret) {
+                        mutex_unlock(
+                                &root->fs_info->fs_devices->device_list_mutex);
+                        btrfs_error(root->fs_info, ret,
+                                    "errors while submitting device barriers.");
+                        return ret;
+                }
+        }
 
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
@@ -3211,10 +3304,6 @@ int close_ctree(struct btrfs_root *root)
                 printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
                        (unsigned long long)fs_info->delalloc_bytes);
         }
-        if (fs_info->total_ref_cache_size) {
-                printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
-                       (unsigned long long)fs_info->total_ref_cache_size);
-        }
 
         free_extent_buffer(fs_info->extent_root->node);
         free_extent_buffer(fs_info->extent_root->commit_root);
@@ -3360,52 +3449,6 @@ int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
         return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
 }
 
-int btree_lock_page_hook(struct page *page, void *data,
-                                void (*flush_fn)(void *))
-{
-        struct inode *inode = page->mapping->host;
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct extent_buffer *eb;
-
-        /*
-         * We culled this eb but the page is still hanging out on the mapping,
-         * carry on.
-         */
-        if (!PagePrivate(page))
-                goto out;
-
-        eb = (struct extent_buffer *)page->private;
-        if (!eb) {
-                WARN_ON(1);
-                goto out;
-        }
-        if (page != eb->pages[0])
-                goto out;
-
-        if (!btrfs_try_tree_write_lock(eb)) {
-                flush_fn(data);
-                btrfs_tree_lock(eb);
-        }
-        btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
-
-        if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
-                spin_lock(&root->fs_info->delalloc_lock);
-                if (root->fs_info->dirty_metadata_bytes >= eb->len)
-                        root->fs_info->dirty_metadata_bytes -= eb->len;
-                else
-                        WARN_ON(1);
-                spin_unlock(&root->fs_info->delalloc_lock);
-        }
-
-        btrfs_tree_unlock(eb);
-out:
-        if (!trylock_page(page)) {
-                flush_fn(data);
-                lock_page(page);
-        }
-        return 0;
-}
-
 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
                               int read_only)
 {
@@ -3608,7 +3651,7 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
 
         while (1) {
                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
-                                            mark);
+                                            mark, NULL);
                 if (ret)
                         break;
 
@@ -3663,7 +3706,7 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
 again:
         while (1) {
                 ret = find_first_extent_bit(unpin, 0, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret)
                         break;
 
@@ -3800,7 +3843,6 @@ int btrfs_cleanup_transaction(struct btrfs_root *root)
 }
 
 static struct extent_io_ops btree_extent_io_ops = {
-        .write_cache_pages_lock_hook = btree_lock_page_hook,
         .readpage_end_io_hook = btree_readpage_end_io_hook,
         .readpage_io_failed_hook = btree_io_failed_hook,
         .submit_bio_hook = btree_submit_bio_hook,
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index c5b00a735fef..2025a9132c16 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -95,6 +95,8 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
                                      u64 objectid);
 int btree_lock_page_hook(struct page *page, void *data,
                                 void (*flush_fn)(void *));
+int btrfs_calc_num_tolerated_disk_barrier_failures(
+        struct btrfs_fs_info *fs_info);
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 void btrfs_init_lockdep(void);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index ba58024d40d3..3d3e2c17d8d1 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -94,8 +94,8 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
                                      u64 flags, struct btrfs_disk_key *key,
                                      int level, struct btrfs_key *ins);
 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *extent_root, u64 alloc_bytes,
-                          u64 flags, int force);
+                          struct btrfs_root *extent_root, u64 flags,
+                          int force);
 static int find_next_key(struct btrfs_path *path, int level,
                          struct btrfs_key *key);
 static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
@@ -312,7 +312,8 @@ static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
         while (start < end) {
                 ret = find_first_extent_bit(info->pinned_extents, start,
                                             &extent_start, &extent_end,
-                                            EXTENT_DIRTY | EXTENT_UPTODATE);
+                                            EXTENT_DIRTY | EXTENT_UPTODATE,
+                                            NULL);
                 if (ret)
                         break;
 
@@ -2361,10 +2362,6 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                 }
 
 next:
-                do_chunk_alloc(trans, fs_info->extent_root,
-                               2 * 1024 * 1024,
-                               btrfs_get_alloc_profile(root, 0),
-                               CHUNK_ALLOC_NO_FORCE);
                 cond_resched();
                 spin_lock(&delayed_refs->lock);
         }
@@ -2478,10 +2475,6 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
         if (root == root->fs_info->extent_root)
                 root = root->fs_info->tree_root;
 
-        do_chunk_alloc(trans, root->fs_info->extent_root,
-                       2 * 1024 * 1024, btrfs_get_alloc_profile(root, 0),
-                       CHUNK_ALLOC_NO_FORCE);
-
         btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
 
         delayed_refs = &trans->transaction->delayed_refs;
@@ -2551,6 +2544,12 @@ again:
         }
 
         if (run_all) {
+                if (!list_empty(&trans->new_bgs)) {
+                        spin_unlock(&delayed_refs->lock);
+                        btrfs_create_pending_block_groups(trans, root);
+                        spin_lock(&delayed_refs->lock);
+                }
+
                 node = rb_first(&delayed_refs->root);
                 if (!node)
                         goto out;
@@ -3406,7 +3405,6 @@ alloc:
                                 return PTR_ERR(trans);
 
                         ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                             bytes + 2 * 1024 * 1024,
                                              alloc_target,
                                              CHUNK_ALLOC_NO_FORCE);
                         btrfs_end_transaction(trans, root);
@@ -3488,8 +3486,7 @@ static void force_metadata_allocation(struct btrfs_fs_info *info)
 }
 
 static int should_alloc_chunk(struct btrfs_root *root,
-                              struct btrfs_space_info *sinfo, u64 alloc_bytes,
-                              int force)
+                              struct btrfs_space_info *sinfo, int force)
 {
         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
         u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
@@ -3504,7 +3501,8 @@ static int should_alloc_chunk(struct btrfs_root *root,
          * and purposes it's used space.  Don't worry about locking the
          * global_rsv, it doesn't change except when the transaction commits.
          */
-        num_allocated += global_rsv->size;
+        if (sinfo->flags & BTRFS_BLOCK_GROUP_METADATA)
+                num_allocated += global_rsv->size;
 
         /*
          * in limited mode, we want to have some free space up to
@@ -3518,15 +3516,8 @@ static int should_alloc_chunk(struct btrfs_root *root,
                 if (num_bytes - num_allocated < thresh)
                         return 1;
         }
-        thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
 
-        /* 256MB or 2% of the FS */
-        thresh = max_t(u64, 256 * 1024 * 1024, div_factor_fine(thresh, 2));
-        /* system chunks need a much small threshold */
-        if (sinfo->flags & BTRFS_BLOCK_GROUP_SYSTEM)
-                thresh = 32 * 1024 * 1024;
-
-        if (num_bytes > thresh && sinfo->bytes_used < div_factor(num_bytes, 8))
+        if (num_allocated + 2 * 1024 * 1024 < div_factor(num_bytes, 8))
                 return 0;
         return 1;
 }
@@ -3576,8 +3567,7 @@ static void check_system_chunk(struct btrfs_trans_handle *trans,
 }
 
 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *extent_root, u64 alloc_bytes,
-                          u64 flags, int force)
+                          struct btrfs_root *extent_root, u64 flags, int force)
 {
         struct btrfs_space_info *space_info;
         struct btrfs_fs_info *fs_info = extent_root->fs_info;
@@ -3601,7 +3591,7 @@ again:
                 return 0;
         }
 
-        if (!should_alloc_chunk(extent_root, space_info, alloc_bytes, force)) {
+        if (!should_alloc_chunk(extent_root, space_info, force)) {
                 spin_unlock(&space_info->lock);
                 return 0;
         } else if (space_info->chunk_alloc) {
@@ -3669,6 +3659,46 @@ out:
         return ret;
 }
 
+static int can_overcommit(struct btrfs_root *root,
+                          struct btrfs_space_info *space_info, u64 bytes,
+                          int flush)
+{
+        u64 profile = btrfs_get_alloc_profile(root, 0);
+        u64 avail;
+        u64 used;
+
+        used = space_info->bytes_used + space_info->bytes_reserved +
+                space_info->bytes_pinned + space_info->bytes_readonly +
+                space_info->bytes_may_use;
+
+        spin_lock(&root->fs_info->free_chunk_lock);
+        avail = root->fs_info->free_chunk_space;
+        spin_unlock(&root->fs_info->free_chunk_lock);
+
+        /*
+         * If we have dup, raid1 or raid10 then only half of the free
+         * space is actually useable.
+         */
+        if (profile & (BTRFS_BLOCK_GROUP_DUP |
+                       BTRFS_BLOCK_GROUP_RAID1 |
+                       BTRFS_BLOCK_GROUP_RAID10))
+                avail >>= 1;
+
+        /*
+         * If we aren't flushing don't let us overcommit too much, say
+         * 1/8th of the space.  If we can flush, let it overcommit up to
+         * 1/2 of the space.
+         */
+        if (flush)
+                avail >>= 3;
+        else
+                avail >>= 1;
+
+        if (used + bytes < space_info->total_bytes + avail)
+                return 1;
+        return 0;
+}
+
 /*
  * shrink metadata reservation for delalloc
  */
@@ -3693,7 +3723,7 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
         if (delalloc_bytes == 0) {
                 if (trans)
                         return;
-                btrfs_wait_ordered_extents(root, 0, 0);
+                btrfs_wait_ordered_extents(root, 0);
                 return;
         }
 
@@ -3703,11 +3733,15 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
                 writeback_inodes_sb_nr_if_idle(root->fs_info->sb, nr_pages,
                                                WB_REASON_FS_FREE_SPACE);
 
+                /*
+                 * We need to wait for the async pages to actually start before
+                 * we do anything.
+                 */
+                wait_event(root->fs_info->async_submit_wait,
+                           !atomic_read(&root->fs_info->async_delalloc_pages));
+
                 spin_lock(&space_info->lock);
-                if (space_info->bytes_used + space_info->bytes_reserved +
-                    space_info->bytes_pinned + space_info->bytes_readonly +
-                    space_info->bytes_may_use + orig <=
-                    space_info->total_bytes) {
+                if (can_overcommit(root, space_info, orig, !trans)) {
                         spin_unlock(&space_info->lock);
                         break;
                 }
@@ -3715,7 +3749,7 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
 
                 loops++;
                 if (wait_ordered && !trans) {
-                        btrfs_wait_ordered_extents(root, 0, 0);
+                        btrfs_wait_ordered_extents(root, 0);
                 } else {
                         time_left = schedule_timeout_killable(1);
                         if (time_left)
@@ -3784,11 +3818,12 @@ commit:
 }
 
 enum flush_state {
-        FLUSH_DELALLOC          =       1,
-        FLUSH_DELALLOC_WAIT     =       2,
-        FLUSH_DELAYED_ITEMS_NR  =       3,
-        FLUSH_DELAYED_ITEMS     =       4,
-        COMMIT_TRANS            =       5,
+        FLUSH_DELAYED_ITEMS_NR  =       1,
+        FLUSH_DELAYED_ITEMS     =       2,
+        FLUSH_DELALLOC          =       3,
+        FLUSH_DELALLOC_WAIT     =       4,
+        ALLOC_CHUNK             =       5,
+        COMMIT_TRANS            =       6,
 };
 
 static int flush_space(struct btrfs_root *root,
@@ -3800,11 +3835,6 @@ static int flush_space(struct btrfs_root *root,
         int ret = 0;
 
         switch (state) {
-        case FLUSH_DELALLOC:
-        case FLUSH_DELALLOC_WAIT:
-                shrink_delalloc(root, num_bytes, orig_bytes,
-                                state == FLUSH_DELALLOC_WAIT);
-                break;
         case FLUSH_DELAYED_ITEMS_NR:
         case FLUSH_DELAYED_ITEMS:
                 if (state == FLUSH_DELAYED_ITEMS_NR) {
@@ -3825,6 +3855,24 @@ static int flush_space(struct btrfs_root *root,
                 ret = btrfs_run_delayed_items_nr(trans, root, nr);
                 btrfs_end_transaction(trans, root);
                 break;
+        case FLUSH_DELALLOC:
+        case FLUSH_DELALLOC_WAIT:
+                shrink_delalloc(root, num_bytes, orig_bytes,
+                                state == FLUSH_DELALLOC_WAIT);
+                break;
+        case ALLOC_CHUNK:
+                trans = btrfs_join_transaction(root);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        break;
+                }
+                ret = do_chunk_alloc(trans, root->fs_info->extent_root,
+                                     btrfs_get_alloc_profile(root, 0),
+                                     CHUNK_ALLOC_NO_FORCE);
+                btrfs_end_transaction(trans, root);
+                if (ret == -ENOSPC)
+                        ret = 0;
+                break;
         case COMMIT_TRANS:
                 ret = may_commit_transaction(root, space_info, orig_bytes, 0);
                 break;
@@ -3856,10 +3904,9 @@ static int reserve_metadata_bytes(struct btrfs_root *root,
         struct btrfs_space_info *space_info = block_rsv->space_info;
         u64 used;
         u64 num_bytes = orig_bytes;
-        int flush_state = FLUSH_DELALLOC;
+        int flush_state = FLUSH_DELAYED_ITEMS_NR;
         int ret = 0;
         bool flushing = false;
-        bool committed = false;
 
 again:
         ret = 0;
@@ -3922,57 +3969,12 @@ again:
                         (orig_bytes * 2);
         }
 
-        if (ret) {
-                u64 profile = btrfs_get_alloc_profile(root, 0);
-                u64 avail;
-
-                /*
-                 * If we have a lot of space that's pinned, don't bother doing
-                 * the overcommit dance yet and just commit the transaction.
-                 */
-                avail = (space_info->total_bytes - space_info->bytes_used) * 8;
-                do_div(avail, 10);
-                if (space_info->bytes_pinned >= avail && flush && !committed) {
-                        space_info->flush = 1;
-                        flushing = true;
-                        spin_unlock(&space_info->lock);
-                        ret = may_commit_transaction(root, space_info,
-                                                     orig_bytes, 1);
-                        if (ret)
-                                goto out;
-                        committed = true;
-                        goto again;
-                }
-
-                spin_lock(&root->fs_info->free_chunk_lock);
-                avail = root->fs_info->free_chunk_space;
-
-                /*
-                 * If we have dup, raid1 or raid10 then only half of the free
-                 * space is actually useable.
-                 */
-                if (profile & (BTRFS_BLOCK_GROUP_DUP |
-                               BTRFS_BLOCK_GROUP_RAID1 |
-                               BTRFS_BLOCK_GROUP_RAID10))
-                        avail >>= 1;
-
-                /*
-                 * If we aren't flushing don't let us overcommit too much, say
-                 * 1/8th of the space.  If we can flush, let it overcommit up to
-                 * 1/2 of the space.
-                 */
-                if (flush)
-                        avail >>= 3;
-                else
-                        avail >>= 1;
-                 spin_unlock(&root->fs_info->free_chunk_lock);
-
-                if (used + num_bytes < space_info->total_bytes + avail) {
-                        space_info->bytes_may_use += orig_bytes;
-                        trace_btrfs_space_reservation(root->fs_info,
-                                "space_info", space_info->flags, orig_bytes, 1);
-                        ret = 0;
-                }
+        if (ret && can_overcommit(root, space_info, orig_bytes, flush)) {
+                space_info->bytes_may_use += orig_bytes;
+                trace_btrfs_space_reservation(root->fs_info, "space_info",
+                                              space_info->flags, orig_bytes,
+                                              1);
+                ret = 0;
         }
 
         /*
@@ -4114,13 +4116,15 @@ static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
         return 0;
 }
 
-void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
+void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
 {
         memset(rsv, 0, sizeof(*rsv));
         spin_lock_init(&rsv->lock);
+        rsv->type = type;
 }
 
-struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
+struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
+                                              unsigned short type)
 {
         struct btrfs_block_rsv *block_rsv;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -4129,7 +4133,7 @@ struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
         if (!block_rsv)
                 return NULL;
 
-        btrfs_init_block_rsv(block_rsv);
+        btrfs_init_block_rsv(block_rsv, type);
         block_rsv->space_info = __find_space_info(fs_info,
                                                   BTRFS_BLOCK_GROUP_METADATA);
         return block_rsv;
@@ -4138,6 +4142,8 @@ struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
 void btrfs_free_block_rsv(struct btrfs_root *root,
                           struct btrfs_block_rsv *rsv)
 {
+        if (!rsv)
+                return;
         btrfs_block_rsv_release(root, rsv, (u64)-1);
         kfree(rsv);
 }
@@ -4416,10 +4422,10 @@ int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
         struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
         struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
         /*
-         * two for root back/forward refs, two for directory entries
-         * and one for root of the snapshot.
+         * two for root back/forward refs, two for directory entries,
+         * one for root of the snapshot and one for parent inode.
          */
-        u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
+        u64 num_bytes = btrfs_calc_trans_metadata_size(root, 6);
         dst_rsv->space_info = src_rsv->space_info;
         return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
 }
@@ -5018,7 +5024,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
 
         while (1) {
                 ret = find_first_extent_bit(unpin, 0, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret)
                         break;
 
@@ -5096,8 +5102,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                         ret = remove_extent_backref(trans, extent_root, path,
                                                     NULL, refs_to_drop,
                                                     is_data);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                         btrfs_release_path(path);
                         path->leave_spinning = 1;
 
@@ -5115,8 +5123,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                         btrfs_print_leaf(extent_root,
                                                          path->nodes[0]);
                         }
-                        if (ret < 0)
-                                goto abort;
+                        if (ret < 0) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                         extent_slot = path->slots[0];
                 }
         } else if (ret == -ENOENT) {
@@ -5130,7 +5140,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                        (unsigned long long)owner_objectid,
                        (unsigned long long)owner_offset);
         } else {
-                goto abort;
+                btrfs_abort_transaction(trans, extent_root, ret);
+                goto out;
         }
 
         leaf = path->nodes[0];
@@ -5140,8 +5151,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                 BUG_ON(found_extent || extent_slot != path->slots[0]);
                 ret = convert_extent_item_v0(trans, extent_root, path,
                                              owner_objectid, 0);
-                if (ret < 0)
-                        goto abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
 
                 btrfs_release_path(path);
                 path->leave_spinning = 1;
@@ -5158,8 +5171,11 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                (unsigned long long)bytenr);
                         btrfs_print_leaf(extent_root, path->nodes[0]);
                 }
-                if (ret < 0)
-                        goto abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
+
                 extent_slot = path->slots[0];
                 leaf = path->nodes[0];
                 item_size = btrfs_item_size_nr(leaf, extent_slot);
@@ -5196,8 +5212,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                         ret = remove_extent_backref(trans, extent_root, path,
                                                     iref, refs_to_drop,
                                                     is_data);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                 }
         } else {
                 if (found_extent) {
@@ -5214,27 +5232,29 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
 
                 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
                                       num_to_del);
-                if (ret)
-                        goto abort;
+                if (ret) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
                 btrfs_release_path(path);
 
                 if (is_data) {
                         ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                 }
 
                 ret = update_block_group(trans, root, bytenr, num_bytes, 0);
-                if (ret)
-                        goto abort;
+                if (ret) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
         }
 out:
         btrfs_free_path(path);
         return ret;
-
-abort:
-        btrfs_abort_transaction(trans, extent_root, ret);
-        goto out;
 }
 
 /*
@@ -5497,8 +5517,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
         struct btrfs_block_group_cache *used_block_group;
         u64 search_start = 0;
         int empty_cluster = 2 * 1024 * 1024;
-        int allowed_chunk_alloc = 0;
-        int done_chunk_alloc = 0;
         struct btrfs_space_info *space_info;
         int loop = 0;
         int index = 0;
@@ -5530,9 +5548,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
         if (btrfs_mixed_space_info(space_info))
                 use_cluster = false;
 
-        if (orig_root->ref_cows || empty_size)
-                allowed_chunk_alloc = 1;
-
         if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
                 last_ptr = &root->fs_info->meta_alloc_cluster;
                 if (!btrfs_test_opt(root, SSD))
@@ -5806,10 +5821,6 @@ checks:
 
                 trace_btrfs_reserve_extent(orig_root, block_group,
                                            search_start, num_bytes);
-                if (offset < search_start)
-                        btrfs_add_free_space(used_block_group, offset,
-                                             search_start - offset);
-                BUG_ON(offset > search_start);
                 if (used_block_group != block_group)
                         btrfs_put_block_group(used_block_group);
                 btrfs_put_block_group(block_group);
@@ -5842,34 +5853,17 @@ loop:
                 index = 0;
                 loop++;
                 if (loop == LOOP_ALLOC_CHUNK) {
-                       if (allowed_chunk_alloc) {
-                                ret = do_chunk_alloc(trans, root, num_bytes +
-                                                     2 * 1024 * 1024, data,
-                                                     CHUNK_ALLOC_LIMITED);
-                                /*
-                                 * Do not bail out on ENOSPC since we
-                                 * can do more things.
-                                 */
-                                if (ret < 0 && ret != -ENOSPC) {
-                                        btrfs_abort_transaction(trans,
-                                                                root, ret);
-                                        goto out;
-                                }
-                                allowed_chunk_alloc = 0;
-                                if (ret == 1)
-                                        done_chunk_alloc = 1;
-                        } else if (!done_chunk_alloc &&
-                                   space_info->force_alloc ==
-                                   CHUNK_ALLOC_NO_FORCE) {
-                                space_info->force_alloc = CHUNK_ALLOC_LIMITED;
+                        ret = do_chunk_alloc(trans, root, data,
+                                             CHUNK_ALLOC_FORCE);
+                        /*
+                         * Do not bail out on ENOSPC since we
+                         * can do more things.
+                         */
+                        if (ret < 0 && ret != -ENOSPC) {
+                                btrfs_abort_transaction(trans,
+                                                        root, ret);
+                                goto out;
                         }
-
-                       /*
-                        * We didn't allocate a chunk, go ahead and drop the
-                        * empty size and loop again.
-                        */
-                       if (!done_chunk_alloc)
-                               loop = LOOP_NO_EMPTY_SIZE;
                 }
 
                 if (loop == LOOP_NO_EMPTY_SIZE) {
@@ -5944,20 +5938,6 @@ int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
 
         data = btrfs_get_alloc_profile(root, data);
 again:
-        /*
-         * the only place that sets empty_size is btrfs_realloc_node, which
-         * is not called recursively on allocations
-         */
-        if (empty_size || root->ref_cows) {
-                ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                     num_bytes + 2 * 1024 * 1024, data,
-                                     CHUNK_ALLOC_NO_FORCE);
-                if (ret < 0 && ret != -ENOSPC) {
-                        btrfs_abort_transaction(trans, root, ret);
-                        return ret;
-                }
-        }
-
         WARN_ON(num_bytes < root->sectorsize);
         ret = find_free_extent(trans, root, num_bytes, empty_size,
                                hint_byte, ins, data);
@@ -5967,12 +5947,6 @@ again:
                         num_bytes = num_bytes >> 1;
                         num_bytes = num_bytes & ~(root->sectorsize - 1);
                         num_bytes = max(num_bytes, min_alloc_size);
-                        ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                       num_bytes, data, CHUNK_ALLOC_FORCE);
-                        if (ret < 0 && ret != -ENOSPC) {
-                                btrfs_abort_transaction(trans, root, ret);
-                                return ret;
-                        }
                         if (num_bytes == min_alloc_size)
                                 final_tried = true;
                         goto again;
@@ -6314,7 +6288,7 @@ use_block_rsv(struct btrfs_trans_handle *trans,
         ret = block_rsv_use_bytes(block_rsv, blocksize);
         if (!ret)
                 return block_rsv;
-        if (ret) {
+        if (ret && !block_rsv->failfast) {
                 static DEFINE_RATELIMIT_STATE(_rs,
                                 DEFAULT_RATELIMIT_INTERVAL,
                                 /*DEFAULT_RATELIMIT_BURST*/ 2);
@@ -7279,7 +7253,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root,
 
         alloc_flags = update_block_group_flags(root, cache->flags);
         if (alloc_flags != cache->flags) {
-                ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+                ret = do_chunk_alloc(trans, root, alloc_flags,
                                      CHUNK_ALLOC_FORCE);
                 if (ret < 0)
                         goto out;
@@ -7289,7 +7263,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root,
         if (!ret)
                 goto out;
         alloc_flags = get_alloc_profile(root, cache->space_info->flags);
-        ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+        ret = do_chunk_alloc(trans, root, alloc_flags,
                              CHUNK_ALLOC_FORCE);
         if (ret < 0)
                 goto out;
@@ -7303,7 +7277,7 @@ int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root, u64 type)
 {
         u64 alloc_flags = get_alloc_profile(root, type);
-        return do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+        return do_chunk_alloc(trans, root, alloc_flags,
                               CHUNK_ALLOC_FORCE);
 }
 
@@ -7810,6 +7784,34 @@ error:
         return ret;
 }
 
+void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
+                                       struct btrfs_root *root)
+{
+        struct btrfs_block_group_cache *block_group, *tmp;
+        struct btrfs_root *extent_root = root->fs_info->extent_root;
+        struct btrfs_block_group_item item;
+        struct btrfs_key key;
+        int ret = 0;
+
+        list_for_each_entry_safe(block_group, tmp, &trans->new_bgs,
+                                 new_bg_list) {
+                list_del_init(&block_group->new_bg_list);
+
+                if (ret)
+                        continue;
+
+                spin_lock(&block_group->lock);
+                memcpy(&item, &block_group->item, sizeof(item));
+                memcpy(&key, &block_group->key, sizeof(key));
+                spin_unlock(&block_group->lock);
+
+                ret = btrfs_insert_item(trans, extent_root, &key, &item,
+                                        sizeof(item));
+                if (ret)
+                        btrfs_abort_transaction(trans, extent_root, ret);
+        }
+}
+
 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root, u64 bytes_used,
                            u64 type, u64 chunk_objectid, u64 chunk_offset,
@@ -7843,6 +7845,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
         spin_lock_init(&cache->lock);
         INIT_LIST_HEAD(&cache->list);
         INIT_LIST_HEAD(&cache->cluster_list);
+        INIT_LIST_HEAD(&cache->new_bg_list);
 
         btrfs_init_free_space_ctl(cache);
 
@@ -7874,12 +7877,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
         ret = btrfs_add_block_group_cache(root->fs_info, cache);
         BUG_ON(ret); /* Logic error */
 
-        ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
-                                sizeof(cache->item));
-        if (ret) {
-                btrfs_abort_transaction(trans, extent_root, ret);
-                return ret;
-        }
+        list_add_tail(&cache->new_bg_list, &trans->new_bgs);
 
         set_avail_alloc_bits(extent_root->fs_info, type);
 
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index b08ea4717e9d..8036d3a84853 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -45,6 +45,7 @@ struct extent_page_data {
         struct bio *bio;
         struct extent_io_tree *tree;
         get_extent_t *get_extent;
+        unsigned long bio_flags;
 
         /* tells writepage not to lock the state bits for this range
          * it still does the unlocking
@@ -64,13 +65,13 @@ tree_fs_info(struct extent_io_tree *tree)
 
 int __init extent_io_init(void)
 {
-        extent_state_cache = kmem_cache_create("extent_state",
+        extent_state_cache = kmem_cache_create("btrfs_extent_state",
                         sizeof(struct extent_state), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_state_cache)
                 return -ENOMEM;
 
-        extent_buffer_cache = kmem_cache_create("extent_buffers",
+        extent_buffer_cache = kmem_cache_create("btrfs_extent_buffer",
                         sizeof(struct extent_buffer), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_buffer_cache)
@@ -942,6 +943,7 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
  * @end:        the end offset in bytes (inclusive)
  * @bits:       the bits to set in this range
  * @clear_bits: the bits to clear in this range
+ * @cached_state:       state that we're going to cache
  * @mask:       the allocation mask
  *
  * This will go through and set bits for the given range.  If any states exist
@@ -951,7 +953,8 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
  * boundary bits like LOCK.
  */
 int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
-                       int bits, int clear_bits, gfp_t mask)
+                       int bits, int clear_bits,
+                       struct extent_state **cached_state, gfp_t mask)
 {
         struct extent_state *state;
         struct extent_state *prealloc = NULL;
@@ -968,6 +971,15 @@ again:
         }
 
         spin_lock(&tree->lock);
+        if (cached_state && *cached_state) {
+                state = *cached_state;
+                if (state->start <= start && state->end > start &&
+                    state->tree) {
+                        node = &state->rb_node;
+                        goto hit_next;
+                }
+        }
+
         /*
          * this search will find all the extents that end after
          * our range starts.
@@ -998,6 +1010,7 @@ hit_next:
          */
         if (state->start == start && state->end <= end) {
                 set_state_bits(tree, state, &bits);
+                cache_state(state, cached_state);
                 state = clear_state_bit(tree, state, &clear_bits, 0);
                 if (last_end == (u64)-1)
                         goto out;
@@ -1038,6 +1051,7 @@ hit_next:
                         goto out;
                 if (state->end <= end) {
                         set_state_bits(tree, state, &bits);
+                        cache_state(state, cached_state);
                         state = clear_state_bit(tree, state, &clear_bits, 0);
                         if (last_end == (u64)-1)
                                 goto out;
@@ -1076,6 +1090,7 @@ hit_next:
                                    &bits);
                 if (err)
                         extent_io_tree_panic(tree, err);
+                cache_state(prealloc, cached_state);
                 prealloc = NULL;
                 start = this_end + 1;
                 goto search_again;
@@ -1098,6 +1113,7 @@ hit_next:
                         extent_io_tree_panic(tree, err);
 
                 set_state_bits(tree, prealloc, &bits);
+                cache_state(prealloc, cached_state);
                 clear_state_bit(tree, prealloc, &clear_bits, 0);
                 prealloc = NULL;
                 goto out;
@@ -1150,6 +1166,14 @@ int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
                               NULL, cached_state, mask);
 }
 
+int set_extent_defrag(struct extent_io_tree *tree, u64 start, u64 end,
+                      struct extent_state **cached_state, gfp_t mask)
+{
+        return set_extent_bit(tree, start, end,
+                              EXTENT_DELALLOC | EXTENT_UPTODATE | EXTENT_DEFRAG,
+                              NULL, cached_state, mask);
+}
+
 int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
                        gfp_t mask)
 {
@@ -1294,18 +1318,42 @@ out:
  * If nothing was found, 1 is returned. If found something, return 0.
  */
 int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
-                          u64 *start_ret, u64 *end_ret, int bits)
+                          u64 *start_ret, u64 *end_ret, int bits,
+                          struct extent_state **cached_state)
 {
         struct extent_state *state;
+        struct rb_node *n;
         int ret = 1;
 
         spin_lock(&tree->lock);
+        if (cached_state && *cached_state) {
+                state = *cached_state;
+                if (state->end == start - 1 && state->tree) {
+                        n = rb_next(&state->rb_node);
+                        while (n) {
+                                state = rb_entry(n, struct extent_state,
+                                                 rb_node);
+                                if (state->state & bits)
+                                        goto got_it;
+                                n = rb_next(n);
+                        }
+                        free_extent_state(*cached_state);
+                        *cached_state = NULL;
+                        goto out;
+                }
+                free_extent_state(*cached_state);
+                *cached_state = NULL;
+        }
+
         state = find_first_extent_bit_state(tree, start, bits);
+got_it:
         if (state) {
+                cache_state(state, cached_state);
                 *start_ret = state->start;
                 *end_ret = state->end;
                 ret = 0;
         }
+out:
         spin_unlock(&tree->lock);
         return ret;
 }
@@ -2068,7 +2116,7 @@ static int bio_readpage_error(struct bio *failed_bio, struct page *page,
                 }
                 read_unlock(&em_tree->lock);
 
-                if (!em || IS_ERR(em)) {
+                if (!em) {
                         kfree(failrec);
                         return -EIO;
                 }
@@ -2304,8 +2352,8 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
                 struct extent_state *cached = NULL;
                 struct extent_state *state;
 
-                pr_debug("end_bio_extent_readpage: bi_vcnt=%d, idx=%d, err=%d, "
-                         "mirror=%ld\n", bio->bi_vcnt, bio->bi_idx, err,
+                pr_debug("end_bio_extent_readpage: bi_sector=%llu, err=%d, "
+                         "mirror=%ld\n", (u64)bio->bi_sector, err,
                          (long int)bio->bi_bdev);
                 tree = &BTRFS_I(page->mapping->host)->io_tree;
 
@@ -2709,12 +2757,15 @@ static int __extent_read_full_page(struct extent_io_tree *tree,
                                          end_bio_extent_readpage, mirror_num,
                                          *bio_flags,
                                          this_bio_flag);
-                        BUG_ON(ret == -ENOMEM);
-                        nr++;
-                        *bio_flags = this_bio_flag;
+                        if (!ret) {
+                                nr++;
+                                *bio_flags = this_bio_flag;
+                        }
                 }
-                if (ret)
+                if (ret) {
                         SetPageError(page);
+                        unlock_extent(tree, cur, cur + iosize - 1);
+                }
                 cur = cur + iosize;
                 pg_offset += iosize;
         }
@@ -3161,12 +3212,16 @@ static int write_one_eb(struct extent_buffer *eb,
         struct block_device *bdev = fs_info->fs_devices->latest_bdev;
         u64 offset = eb->start;
         unsigned long i, num_pages;
+        unsigned long bio_flags = 0;
         int rw = (epd->sync_io ? WRITE_SYNC : WRITE);
         int ret = 0;
 
         clear_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
         num_pages = num_extent_pages(eb->start, eb->len);
         atomic_set(&eb->io_pages, num_pages);
+        if (btrfs_header_owner(eb) == BTRFS_TREE_LOG_OBJECTID)
+                bio_flags = EXTENT_BIO_TREE_LOG;
+
         for (i = 0; i < num_pages; i++) {
                 struct page *p = extent_buffer_page(eb, i);
 
@@ -3175,7 +3230,8 @@ static int write_one_eb(struct extent_buffer *eb,
                 ret = submit_extent_page(rw, eb->tree, p, offset >> 9,
                                          PAGE_CACHE_SIZE, 0, bdev, &epd->bio,
                                          -1, end_bio_extent_buffer_writepage,
-                                         0, 0, 0);
+                                         0, epd->bio_flags, bio_flags);
+                epd->bio_flags = bio_flags;
                 if (ret) {
                         set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
                         SetPageError(p);
@@ -3210,6 +3266,7 @@ int btree_write_cache_pages(struct address_space *mapping,
                 .tree = tree,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
         int ret = 0;
         int done = 0;
@@ -3254,19 +3311,34 @@ retry:
                                 break;
                         }
 
+                        spin_lock(&mapping->private_lock);
+                        if (!PagePrivate(page)) {
+                                spin_unlock(&mapping->private_lock);
+                                continue;
+                        }
+
                         eb = (struct extent_buffer *)page->private;
+
+                        /*
+                         * Shouldn't happen and normally this would be a BUG_ON
+                         * but no sense in crashing the users box for something
+                         * we can survive anyway.
+                         */
                         if (!eb) {
+                                spin_unlock(&mapping->private_lock);
                                 WARN_ON(1);
                                 continue;
                         }
 
-                        if (eb == prev_eb)
+                        if (eb == prev_eb) {
+                                spin_unlock(&mapping->private_lock);
                                 continue;
+                        }
 
-                        if (!atomic_inc_not_zero(&eb->refs)) {
-                                WARN_ON(1);
+                        ret = atomic_inc_not_zero(&eb->refs);
+                        spin_unlock(&mapping->private_lock);
+                        if (!ret)
                                 continue;
-                        }
 
                         prev_eb = eb;
                         ret = lock_extent_buffer_for_io(eb, fs_info, &epd);
@@ -3457,7 +3529,7 @@ static void flush_epd_write_bio(struct extent_page_data *epd)
                 if (epd->sync_io)
                         rw = WRITE_SYNC;
 
-                ret = submit_one_bio(rw, epd->bio, 0, 0);
+                ret = submit_one_bio(rw, epd->bio, 0, epd->bio_flags);
                 BUG_ON(ret < 0); /* -ENOMEM */
                 epd->bio = NULL;
         }
@@ -3480,6 +3552,7 @@ int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
                 .get_extent = get_extent,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
 
         ret = __extent_writepage(page, wbc, &epd);
@@ -3504,6 +3577,7 @@ int extent_write_locked_range(struct extent_io_tree *tree, struct inode *inode,
                 .get_extent = get_extent,
                 .extent_locked = 1,
                 .sync_io = mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
         struct writeback_control wbc_writepages = {
                 .sync_mode      = mode,
@@ -3543,6 +3617,7 @@ int extent_writepages(struct extent_io_tree *tree,
                 .get_extent = get_extent,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
 
         ret = extent_write_cache_pages(tree, mapping, wbc,
@@ -3920,18 +3995,6 @@ out:
         return ret;
 }
 
-inline struct page *extent_buffer_page(struct extent_buffer *eb,
-                                              unsigned long i)
-{
-        return eb->pages[i];
-}
-
-inline unsigned long num_extent_pages(u64 start, u64 len)
-{
-        return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
-                (start >> PAGE_CACHE_SHIFT);
-}
-
 static void __free_extent_buffer(struct extent_buffer *eb)
 {
 #if LEAK_DEBUG
@@ -4047,7 +4110,7 @@ struct extent_buffer *alloc_dummy_extent_buffer(u64 start, unsigned long len)
 
         return eb;
 err:
-        for (i--; i > 0; i--)
+        for (i--; i >= 0; i--)
                 __free_page(eb->pages[i]);
         __free_extent_buffer(eb);
         return NULL;
@@ -4192,10 +4255,8 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
 
         for (i = 0; i < num_pages; i++, index++) {
                 p = find_or_create_page(mapping, index, GFP_NOFS);
-                if (!p) {
-                        WARN_ON(1);
+                if (!p)
                         goto free_eb;
-                }
 
                 spin_lock(&mapping->private_lock);
                 if (PagePrivate(p)) {
@@ -4338,7 +4399,6 @@ static int release_extent_buffer(struct extent_buffer *eb, gfp_t mask)
 
                 /* Should be safe to release our pages at this point */
                 btrfs_release_extent_buffer_page(eb, 0);
-
                 call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);
                 return 1;
         }
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 25900af5b15d..711d12b80028 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -27,6 +27,7 @@
  * type for this bio
  */
 #define EXTENT_BIO_COMPRESSED 1
+#define EXTENT_BIO_TREE_LOG 2
 #define EXTENT_BIO_FLAG_SHIFT 16
 
 /* these are bit numbers for test/set bit */
@@ -232,11 +233,15 @@ int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
 int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
                        gfp_t mask);
 int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
-                       int bits, int clear_bits, gfp_t mask);
+                       int bits, int clear_bits,
+                       struct extent_state **cached_state, gfp_t mask);
 int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
                         struct extent_state **cached_state, gfp_t mask);
+int set_extent_defrag(struct extent_io_tree *tree, u64 start, u64 end,
+                      struct extent_state **cached_state, gfp_t mask);
 int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
-                          u64 *start_ret, u64 *end_ret, int bits);
+                          u64 *start_ret, u64 *end_ret, int bits,
+                          struct extent_state **cached_state);
 struct extent_state *find_first_extent_bit_state(struct extent_io_tree *tree,
                                                  u64 start, int bits);
 int extent_invalidatepage(struct extent_io_tree *tree,
@@ -277,8 +282,18 @@ void free_extent_buffer_stale(struct extent_buffer *eb);
 int read_extent_buffer_pages(struct extent_io_tree *tree,
                              struct extent_buffer *eb, u64 start, int wait,
                              get_extent_t *get_extent, int mirror_num);
-unsigned long num_extent_pages(u64 start, u64 len);
-struct page *extent_buffer_page(struct extent_buffer *eb, unsigned long i);
+
+static inline unsigned long num_extent_pages(u64 start, u64 len)
+{
+        return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
+                (start >> PAGE_CACHE_SHIFT);
+}
+
+static inline struct page *extent_buffer_page(struct extent_buffer *eb,
+                                              unsigned long i)
+{
+        return eb->pages[i];
+}
 
 static inline void extent_buffer_get(struct extent_buffer *eb)
 {
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 7c97b3301459..b8cbc8d5c7f7 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -11,7 +11,7 @@ static struct kmem_cache *extent_map_cache;
 
 int __init extent_map_init(void)
 {
-        extent_map_cache = kmem_cache_create("extent_map",
+        extent_map_cache = kmem_cache_create("btrfs_extent_map",
                         sizeof(struct extent_map), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_map_cache)
@@ -35,6 +35,7 @@ void extent_map_exit(void)
 void extent_map_tree_init(struct extent_map_tree *tree)
 {
         tree->map = RB_ROOT;
+        INIT_LIST_HEAD(&tree->modified_extents);
         rwlock_init(&tree->lock);
 }
 
@@ -54,7 +55,9 @@ struct extent_map *alloc_extent_map(void)
         em->in_tree = 0;
         em->flags = 0;
         em->compress_type = BTRFS_COMPRESS_NONE;
+        em->generation = 0;
         atomic_set(&em->refs, 1);
+        INIT_LIST_HEAD(&em->list);
         return em;
 }
 
@@ -72,6 +75,7 @@ void free_extent_map(struct extent_map *em)
         WARN_ON(atomic_read(&em->refs) == 0);
         if (atomic_dec_and_test(&em->refs)) {
                 WARN_ON(em->in_tree);
+                WARN_ON(!list_empty(&em->list));
                 kmem_cache_free(extent_map_cache, em);
         }
 }
@@ -198,6 +202,14 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                         em->block_len += merge->block_len;
                         em->block_start = merge->block_start;
                         merge->in_tree = 0;
+                        if (merge->generation > em->generation) {
+                                em->mod_start = em->start;
+                                em->mod_len = em->len;
+                                em->generation = merge->generation;
+                                list_move(&em->list, &tree->modified_extents);
+                        }
+
+                        list_del_init(&merge->list);
                         rb_erase(&merge->rb_node, &tree->map);
                         free_extent_map(merge);
                 }
@@ -211,14 +223,34 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                 em->block_len += merge->len;
                 rb_erase(&merge->rb_node, &tree->map);
                 merge->in_tree = 0;
+                if (merge->generation > em->generation) {
+                        em->mod_len = em->len;
+                        em->generation = merge->generation;
+                        list_move(&em->list, &tree->modified_extents);
+                }
+                list_del_init(&merge->list);
                 free_extent_map(merge);
         }
 }
 
-int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
+/**
+ * unpint_extent_cache - unpin an extent from the cache
+ * @tree:       tree to unpin the extent in
+ * @start:      logical offset in the file
+ * @len:        length of the extent
+ * @gen:        generation that this extent has been modified in
+ * @prealloc:   if this is set we need to clear the prealloc flag
+ *
+ * Called after an extent has been written to disk properly.  Set the generation
+ * to the generation that actually added the file item to the inode so we know
+ * we need to sync this extent when we call fsync().
+ */
+int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len,
+                       u64 gen)
 {
         int ret = 0;
         struct extent_map *em;
+        bool prealloc = false;
 
         write_lock(&tree->lock);
         em = lookup_extent_mapping(tree, start, len);
@@ -228,10 +260,24 @@ int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
         if (!em)
                 goto out;
 
+        list_move(&em->list, &tree->modified_extents);
+        em->generation = gen;
         clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+        em->mod_start = em->start;
+        em->mod_len = em->len;
+
+        if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
+                prealloc = true;
+                clear_bit(EXTENT_FLAG_PREALLOC, &em->flags);
+        }
 
         try_merge_map(tree, em);
 
+        if (prealloc) {
+                em->mod_start = em->start;
+                em->mod_len = em->len;
+        }
+
         free_extent_map(em);
 out:
         write_unlock(&tree->lock);
@@ -269,6 +315,9 @@ int add_extent_mapping(struct extent_map_tree *tree,
         }
         atomic_inc(&em->refs);
 
+        em->mod_start = em->start;
+        em->mod_len = em->len;
+
         try_merge_map(tree, em);
 out:
         return ret;
@@ -358,6 +407,8 @@ int remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em)
 
         WARN_ON(test_bit(EXTENT_FLAG_PINNED, &em->flags));
         rb_erase(&em->rb_node, &tree->map);
+        if (!test_bit(EXTENT_FLAG_LOGGING, &em->flags))
+                list_del_init(&em->list);
         em->in_tree = 0;
         return ret;
 }
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index 1195f09761fe..679225555f7b 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -13,6 +13,7 @@
 #define EXTENT_FLAG_COMPRESSED 1
 #define EXTENT_FLAG_VACANCY 2 /* no file extent item found */
 #define EXTENT_FLAG_PREALLOC 3 /* pre-allocated extent */
+#define EXTENT_FLAG_LOGGING 4 /* Logging this extent */
 
 struct extent_map {
         struct rb_node rb_node;
@@ -20,18 +21,23 @@ struct extent_map {
         /* all of these are in bytes */
         u64 start;
         u64 len;
+        u64 mod_start;
+        u64 mod_len;
         u64 orig_start;
         u64 block_start;
         u64 block_len;
+        u64 generation;
         unsigned long flags;
         struct block_device *bdev;
         atomic_t refs;
         unsigned int in_tree;
         unsigned int compress_type;
+        struct list_head list;
 };
 
 struct extent_map_tree {
         struct rb_root map;
+        struct list_head modified_extents;
         rwlock_t lock;
 };
 
@@ -60,7 +66,7 @@ struct extent_map *alloc_extent_map(void);
 void free_extent_map(struct extent_map *em);
 int __init extent_map_init(void);
 void extent_map_exit(void);
-int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len);
+int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len, u64 gen);
 struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
                                          u64 start, u64 len);
 #endif
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 857d93cd01dc..1ad08e4e4a15 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -25,11 +25,12 @@
 #include "transaction.h"
 #include "print-tree.h"
 
-#define __MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
+#define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
                                    sizeof(struct btrfs_item) * 2) / \
                                   size) - 1))
 
-#define MAX_CSUM_ITEMS(r, size) (min(__MAX_CSUM_ITEMS(r, size), PAGE_CACHE_SIZE))
+#define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
+                                       PAGE_CACHE_SIZE))
 
 #define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \
                                    sizeof(struct btrfs_ordered_sum)) / \
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index f6b40e86121b..9ab1bed88116 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -39,6 +39,7 @@
 #include "tree-log.h"
 #include "locking.h"
 #include "compat.h"
+#include "volumes.h"
 
 /*
  * when auto defrag is enabled we
@@ -458,14 +459,15 @@ int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
  * this drops all the extents in the cache that intersect the range
  * [start, end].  Existing extents are split as required.
  */
-int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
-                            int skip_pinned)
+void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
+                             int skip_pinned)
 {
         struct extent_map *em;
         struct extent_map *split = NULL;
         struct extent_map *split2 = NULL;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         u64 len = end - start + 1;
+        u64 gen;
         int ret;
         int testend = 1;
         unsigned long flags;
@@ -477,11 +479,14 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 testend = 0;
         }
         while (1) {
+                int no_splits = 0;
+
                 if (!split)
                         split = alloc_extent_map();
                 if (!split2)
                         split2 = alloc_extent_map();
-                BUG_ON(!split || !split2); /* -ENOMEM */
+                if (!split || !split2)
+                        no_splits = 1;
 
                 write_lock(&em_tree->lock);
                 em = lookup_extent_mapping(em_tree, start, len);
@@ -490,6 +495,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         break;
                 }
                 flags = em->flags;
+                gen = em->generation;
                 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
                         if (testend && em->start + em->len >= start + len) {
                                 free_extent_map(em);
@@ -506,6 +512,8 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
                 remove_extent_mapping(em_tree, em);
+                if (no_splits)
+                        goto next;
 
                 if (em->block_start < EXTENT_MAP_LAST_BYTE &&
                     em->start < start) {
@@ -518,12 +526,13 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                                 split->block_len = em->block_len;
                         else
                                 split->block_len = split->len;
-
+                        split->generation = gen;
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
                         ret = add_extent_mapping(em_tree, split);
                         BUG_ON(ret); /* Logic error */
+                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = split2;
                         split2 = NULL;
@@ -537,6 +546,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
+                        split->generation = gen;
 
                         if (compressed) {
                                 split->block_len = em->block_len;
@@ -550,9 +560,11 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
 
                         ret = add_extent_mapping(em_tree, split);
                         BUG_ON(ret); /* Logic error */
+                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = NULL;
                 }
+next:
                 write_unlock(&em_tree->lock);
 
                 /* once for us */
@@ -564,7 +576,6 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 free_extent_map(split);
         if (split2)
                 free_extent_map(split2);
-        return 0;
 }
 
 /*
@@ -576,13 +587,13 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
  * it is either truncated or split.  Anything entirely inside the range
  * is deleted from the tree.
  */
-int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
-                       u64 start, u64 end, u64 *hint_byte, int drop_cache)
+int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                         struct btrfs_root *root, struct inode *inode,
+                         struct btrfs_path *path, u64 start, u64 end,
+                         u64 *drop_end, int drop_cache)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_buffer *leaf;
         struct btrfs_file_extent_item *fi;
-        struct btrfs_path *path;
         struct btrfs_key key;
         struct btrfs_key new_key;
         u64 ino = btrfs_ino(inode);
@@ -597,14 +608,12 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
         int recow;
         int ret;
         int modify_tree = -1;
+        int update_refs = (root->ref_cows || root == root->fs_info->tree_root);
+        int found = 0;
 
         if (drop_cache)
                 btrfs_drop_extent_cache(inode, start, end - 1, 0);
 
-        path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
-
         if (start >= BTRFS_I(inode)->disk_i_size)
                 modify_tree = 0;
 
@@ -666,6 +675,7 @@ next_slot:
                         goto next_slot;
                 }
 
+                found = 1;
                 search_start = max(key.offset, start);
                 if (recow || !modify_tree) {
                         modify_tree = -1;
@@ -707,14 +717,13 @@ next_slot:
                                                         extent_end - start);
                         btrfs_mark_buffer_dirty(leaf);
 
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0) {
                                 ret = btrfs_inc_extent_ref(trans, root,
                                                 disk_bytenr, num_bytes, 0,
                                                 root->root_key.objectid,
                                                 new_key.objectid,
                                                 start - extent_offset, 0);
                                 BUG_ON(ret); /* -ENOMEM */
-                                *hint_byte = disk_bytenr;
                         }
                         key.offset = start;
                 }
@@ -734,10 +743,8 @@ next_slot:
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         extent_end - end);
                         btrfs_mark_buffer_dirty(leaf);
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0)
                                 inode_sub_bytes(inode, end - key.offset);
-                                *hint_byte = disk_bytenr;
-                        }
                         break;
                 }
 
@@ -753,10 +760,8 @@ next_slot:
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         start - key.offset);
                         btrfs_mark_buffer_dirty(leaf);
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0)
                                 inode_sub_bytes(inode, extent_end - start);
-                                *hint_byte = disk_bytenr;
-                        }
                         if (end == extent_end)
                                 break;
 
@@ -777,12 +782,13 @@ next_slot:
                                 del_nr++;
                         }
 
-                        if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                        if (update_refs &&
+                            extent_type == BTRFS_FILE_EXTENT_INLINE) {
                                 inode_sub_bytes(inode,
                                                 extent_end - key.offset);
                                 extent_end = ALIGN(extent_end,
                                                    root->sectorsize);
-                        } else if (disk_bytenr > 0) {
+                        } else if (update_refs && disk_bytenr > 0) {
                                 ret = btrfs_free_extent(trans, root,
                                                 disk_bytenr, num_bytes, 0,
                                                 root->root_key.objectid,
@@ -791,7 +797,6 @@ next_slot:
                                 BUG_ON(ret); /* -ENOMEM */
                                 inode_sub_bytes(inode,
                                                 extent_end - key.offset);
-                                *hint_byte = disk_bytenr;
                         }
 
                         if (end == extent_end)
@@ -806,7 +811,7 @@ next_slot:
                                               del_nr);
                         if (ret) {
                                 btrfs_abort_transaction(trans, root, ret);
-                                goto out;
+                                break;
                         }
 
                         del_nr = 0;
@@ -825,7 +830,24 @@ next_slot:
                         btrfs_abort_transaction(trans, root, ret);
         }
 
-out:
+        if (drop_end)
+                *drop_end = found ? min(end, extent_end) : end;
+        btrfs_release_path(path);
+        return ret;
+}
+
+int btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root, struct inode *inode, u64 start,
+                       u64 end, int drop_cache)
+{
+        struct btrfs_path *path;
+        int ret;
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+        ret = __btrfs_drop_extents(trans, root, inode, path, start, end, NULL,
+                                   drop_cache);
         btrfs_free_path(path);
         return ret;
 }
@@ -892,8 +914,6 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
         int ret;
         u64 ino = btrfs_ino(inode);
 
-        btrfs_drop_extent_cache(inode, start, end - 1, 0);
-
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
@@ -935,12 +955,16 @@ again:
                         btrfs_set_item_key_safe(trans, root, path, &new_key);
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         extent_end - end);
                         btrfs_set_file_extent_offset(leaf, fi,
                                                      end - orig_offset);
                         fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         end - other_start);
                         btrfs_mark_buffer_dirty(leaf);
@@ -958,12 +982,16 @@ again:
                                             struct btrfs_file_extent_item);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         start - key.offset);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         path->slots[0]++;
                         new_key.offset = start;
                         btrfs_set_item_key_safe(trans, root, path, &new_key);
 
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         other_end - start);
                         btrfs_set_file_extent_offset(leaf, fi,
@@ -991,12 +1019,14 @@ again:
                 leaf = path->nodes[0];
                 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
                                     struct btrfs_file_extent_item);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 split - key.offset);
 
                 fi = btrfs_item_ptr(leaf, path->slots[0],
                                     struct btrfs_file_extent_item);
 
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 extent_end - split);
@@ -1056,12 +1086,14 @@ again:
                            struct btrfs_file_extent_item);
                 btrfs_set_file_extent_type(leaf, fi,
                                            BTRFS_FILE_EXTENT_REG);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_mark_buffer_dirty(leaf);
         } else {
                 fi = btrfs_item_ptr(leaf, del_slot - 1,
                            struct btrfs_file_extent_item);
                 btrfs_set_file_extent_type(leaf, fi,
                                            BTRFS_FILE_EXTENT_REG);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 extent_end - key.offset);
                 btrfs_mark_buffer_dirty(leaf);
@@ -1173,8 +1205,8 @@ again:
 
                 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos,
                                   last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
-                                  EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
-                                  GFP_NOFS);
+                                  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
+                                  0, 0, &cached_state, GFP_NOFS);
                 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
                                      start_pos, last_pos - 1, &cached_state,
                                      GFP_NOFS);
@@ -1514,16 +1546,24 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         trace_btrfs_sync_file(file, datasync);
 
+        /*
+         * We write the dirty pages in the range and wait until they complete
+         * out of the ->i_mutex. If so, we can flush the dirty pages by
+         * multi-task, and make the performance up.
+         */
+        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (ret)
+                return ret;
+
         mutex_lock(&inode->i_mutex);
 
         /*
-         * we wait first, since the writeback may change the inode, also wait
-         * ordered range does a filemape_write_and_wait_range which is why we
-         * don't do it above like other file systems.
+         * We flush the dirty pages again to avoid some dirty pages in the
+         * range being left.
          */
-        root->log_batch++;
+        atomic_inc(&root->log_batch);
         btrfs_wait_ordered_range(inode, start, end);
-        root->log_batch++;
+        atomic_inc(&root->log_batch);
 
         /*
          * check the transaction that last modified this inode
@@ -1544,6 +1584,14 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
             BTRFS_I(inode)->last_trans <=
             root->fs_info->last_trans_committed) {
                 BTRFS_I(inode)->last_trans = 0;
+
+                /*
+                 * We'v had everything committed since the last time we were
+                 * modified so clear this flag in case it was set for whatever
+                 * reason, it's no longer relevant.
+                 */
+                clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                          &BTRFS_I(inode)->runtime_flags);
                 mutex_unlock(&inode->i_mutex);
                 goto out;
         }
@@ -1615,6 +1663,324 @@ static int btrfs_file_mmap(struct file	*filp, struct vm_area_struct *vma)
         return 0;
 }
 
+static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
+                          int slot, u64 start, u64 end)
+{
+        struct btrfs_file_extent_item *fi;
+        struct btrfs_key key;
+
+        if (slot < 0 || slot >= btrfs_header_nritems(leaf))
+                return 0;
+
+        btrfs_item_key_to_cpu(leaf, &key, slot);
+        if (key.objectid != btrfs_ino(inode) ||
+            key.type != BTRFS_EXTENT_DATA_KEY)
+                return 0;
+
+        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+
+        if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
+                return 0;
+
+        if (btrfs_file_extent_disk_bytenr(leaf, fi))
+                return 0;
+
+        if (key.offset == end)
+                return 1;
+        if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
+                return 1;
+        return 0;
+}
+
+static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
+                      struct btrfs_path *path, u64 offset, u64 end)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct extent_buffer *leaf;
+        struct btrfs_file_extent_item *fi;
+        struct extent_map *hole_em;
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct btrfs_key key;
+        int ret;
+
+        key.objectid = btrfs_ino(inode);
+        key.type = BTRFS_EXTENT_DATA_KEY;
+        key.offset = offset;
+
+
+        ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
+        if (ret < 0)
+                return ret;
+        BUG_ON(!ret);
+
+        leaf = path->nodes[0];
+        if (hole_mergeable(inode, leaf, path->slots[0]-1, offset, end)) {
+                u64 num_bytes;
+
+                path->slots[0]--;
+                fi = btrfs_item_ptr(leaf, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
+                        end - offset;
+                btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_offset(leaf, fi, 0);
+                btrfs_mark_buffer_dirty(leaf);
+                goto out;
+        }
+
+        if (hole_mergeable(inode, leaf, path->slots[0]+1, offset, end)) {
+                u64 num_bytes;
+
+                path->slots[0]++;
+                key.offset = offset;
+                btrfs_set_item_key_safe(trans, root, path, &key);
+                fi = btrfs_item_ptr(leaf, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
+                        offset;
+                btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_offset(leaf, fi, 0);
+                btrfs_mark_buffer_dirty(leaf);
+                goto out;
+        }
+        btrfs_release_path(path);
+
+        ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset,
+                                       0, 0, end - offset, 0, end - offset,
+                                       0, 0, 0);
+        if (ret)
+                return ret;
+
+out:
+        btrfs_release_path(path);
+
+        hole_em = alloc_extent_map();
+        if (!hole_em) {
+                btrfs_drop_extent_cache(inode, offset, end - 1, 0);
+                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                        &BTRFS_I(inode)->runtime_flags);
+        } else {
+                hole_em->start = offset;
+                hole_em->len = end - offset;
+                hole_em->orig_start = offset;
+
+                hole_em->block_start = EXTENT_MAP_HOLE;
+                hole_em->block_len = 0;
+                hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
+                hole_em->compress_type = BTRFS_COMPRESS_NONE;
+                hole_em->generation = trans->transid;
+
+                do {
+                        btrfs_drop_extent_cache(inode, offset, end - 1, 0);
+                        write_lock(&em_tree->lock);
+                        ret = add_extent_mapping(em_tree, hole_em);
+                        if (!ret)
+                                list_move(&hole_em->list,
+                                          &em_tree->modified_extents);
+                        write_unlock(&em_tree->lock);
+                } while (ret == -EEXIST);
+                free_extent_map(hole_em);
+                if (ret)
+                        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                &BTRFS_I(inode)->runtime_flags);
+        }
+
+        return 0;
+}
+
+static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct extent_state *cached_state = NULL;
+        struct btrfs_path *path;
+        struct btrfs_block_rsv *rsv;
+        struct btrfs_trans_handle *trans;
+        u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
+        u64 lockstart = (offset + mask) & ~mask;
+        u64 lockend = ((offset + len) & ~mask) - 1;
+        u64 cur_offset = lockstart;
+        u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
+        u64 drop_end;
+        unsigned long nr;
+        int ret = 0;
+        int err = 0;
+        bool same_page = (offset >> PAGE_CACHE_SHIFT) ==
+                ((offset + len) >> PAGE_CACHE_SHIFT);
+
+        btrfs_wait_ordered_range(inode, offset, len);
+
+        mutex_lock(&inode->i_mutex);
+        if (offset >= inode->i_size) {
+                mutex_unlock(&inode->i_mutex);
+                return 0;
+        }
+
+        /*
+         * Only do this if we are in the same page and we aren't doing the
+         * entire page.
+         */
+        if (same_page && len < PAGE_CACHE_SIZE) {
+                ret = btrfs_truncate_page(inode, offset, len, 0);
+                mutex_unlock(&inode->i_mutex);
+                return ret;
+        }
+
+        /* zero back part of the first page */
+        ret = btrfs_truncate_page(inode, offset, 0, 0);
+        if (ret) {
+                mutex_unlock(&inode->i_mutex);
+                return ret;
+        }
+
+        /* zero the front end of the last page */
+        ret = btrfs_truncate_page(inode, offset + len, 0, 1);
+        if (ret) {
+                mutex_unlock(&inode->i_mutex);
+                return ret;
+        }
+
+        if (lockend < lockstart) {
+                mutex_unlock(&inode->i_mutex);
+                return 0;
+        }
+
+        while (1) {
+                struct btrfs_ordered_extent *ordered;
+
+                truncate_pagecache_range(inode, lockstart, lockend);
+
+                lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
+                                 0, &cached_state);
+                ordered = btrfs_lookup_first_ordered_extent(inode, lockend);
+
+                /*
+                 * We need to make sure we have no ordered extents in this range
+                 * and nobody raced in and read a page in this range, if we did
+                 * we need to try again.
+                 */
+                if ((!ordered ||
+                    (ordered->file_offset + ordered->len < lockstart ||
+                     ordered->file_offset > lockend)) &&
+                     !test_range_bit(&BTRFS_I(inode)->io_tree, lockstart,
+                                     lockend, EXTENT_UPTODATE, 0,
+                                     cached_state)) {
+                        if (ordered)
+                                btrfs_put_ordered_extent(ordered);
+                        break;
+                }
+                if (ordered)
+                        btrfs_put_ordered_extent(ordered);
+                unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
+                                     lockend, &cached_state, GFP_NOFS);
+                btrfs_wait_ordered_range(inode, lockstart,
+                                         lockend - lockstart + 1);
+        }
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
+        if (!rsv) {
+                ret = -ENOMEM;
+                goto out_free;
+        }
+        rsv->size = btrfs_calc_trunc_metadata_size(root, 1);
+        rsv->failfast = 1;
+
+        /*
+         * 1 - update the inode
+         * 1 - removing the extents in the range
+         * 1 - adding the hole extent
+         */
+        trans = btrfs_start_transaction(root, 3);
+        if (IS_ERR(trans)) {
+                err = PTR_ERR(trans);
+                goto out_free;
+        }
+
+        ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
+                                      min_size);
+        BUG_ON(ret);
+        trans->block_rsv = rsv;
+
+        while (cur_offset < lockend) {
+                ret = __btrfs_drop_extents(trans, root, inode, path,
+                                           cur_offset, lockend + 1,
+                                           &drop_end, 1);
+                if (ret != -ENOSPC)
+                        break;
+
+                trans->block_rsv = &root->fs_info->trans_block_rsv;
+
+                ret = fill_holes(trans, inode, path, cur_offset, drop_end);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
+
+                cur_offset = drop_end;
+
+                ret = btrfs_update_inode(trans, root, inode);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
+
+                nr = trans->blocks_used;
+                btrfs_end_transaction(trans, root);
+                btrfs_btree_balance_dirty(root, nr);
+
+                trans = btrfs_start_transaction(root, 3);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        trans = NULL;
+                        break;
+                }
+
+                ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
+                                              rsv, min_size);
+                BUG_ON(ret);    /* shouldn't happen */
+                trans->block_rsv = rsv;
+        }
+
+        if (ret) {
+                err = ret;
+                goto out_trans;
+        }
+
+        trans->block_rsv = &root->fs_info->trans_block_rsv;
+        ret = fill_holes(trans, inode, path, cur_offset, drop_end);
+        if (ret) {
+                err = ret;
+                goto out_trans;
+        }
+
+out_trans:
+        if (!trans)
+                goto out_free;
+
+        trans->block_rsv = &root->fs_info->trans_block_rsv;
+        ret = btrfs_update_inode(trans, root, inode);
+        nr = trans->blocks_used;
+        btrfs_end_transaction(trans, root);
+        btrfs_btree_balance_dirty(root, nr);
+out_free:
+        btrfs_free_path(path);
+        btrfs_free_block_rsv(root, rsv);
+out:
+        unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
+                             &cached_state, GFP_NOFS);
+        mutex_unlock(&inode->i_mutex);
+        if (ret && !err)
+                err = ret;
+        return err;
+}
+
 static long btrfs_fallocate(struct file *file, int mode,
                             loff_t offset, loff_t len)
 {
@@ -1633,15 +1999,18 @@ static long btrfs_fallocate(struct file *file, int mode,
         alloc_start = offset & ~mask;
         alloc_end =  (offset + len + mask) & ~mask;
 
-        /* We only support the FALLOC_FL_KEEP_SIZE mode */
-        if (mode & ~FALLOC_FL_KEEP_SIZE)
+        /* Make sure we aren't being give some crap mode */
+        if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
 
+        if (mode & FALLOC_FL_PUNCH_HOLE)
+                return btrfs_punch_hole(inode, offset, len);
+
         /*
          * Make sure we have enough space before we do the
          * allocation.
          */
-        ret = btrfs_check_data_free_space(inode, len);
+        ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start + 1);
         if (ret)
                 return ret;
 
@@ -1748,7 +2117,7 @@ static long btrfs_fallocate(struct file *file, int mode,
 out:
         mutex_unlock(&inode->i_mutex);
         /* Let go of our reservation. */
-        btrfs_free_reserved_data_space(inode, len);
+        btrfs_free_reserved_data_space(inode, alloc_end - alloc_start + 1);
         return ret;
 }
 
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 6b10acfc2f5c..1027b854b90c 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -966,7 +966,7 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
                                block_group->key.offset)) {
                 ret = find_first_extent_bit(unpin, start,
                                             &extent_start, &extent_end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret) {
                         ret = 0;
                         break;
@@ -1454,9 +1454,7 @@ static int search_bitmap(struct btrfs_free_space_ctl *ctl,
                           max_t(u64, *offset, bitmap_info->offset));
         bits = bytes_to_bits(*bytes, ctl->unit);
 
-        for (i = find_next_bit(bitmap_info->bitmap, BITS_PER_BITMAP, i);
-             i < BITS_PER_BITMAP;
-             i = find_next_bit(bitmap_info->bitmap, BITS_PER_BITMAP, i + 1)) {
+        for_each_set_bit_from(i, bitmap_info->bitmap, BITS_PER_BITMAP) {
                 next_zero = find_next_zero_bit(bitmap_info->bitmap,
                                                BITS_PER_BITMAP, i);
                 if ((next_zero - i) >= bits) {
@@ -2307,9 +2305,7 @@ static int btrfs_bitmap_cluster(struct btrfs_block_group_cache *block_group,
 
 again:
         found_bits = 0;
-        for (i = find_next_bit(entry->bitmap, BITS_PER_BITMAP, i);
-             i < BITS_PER_BITMAP;
-             i = find_next_bit(entry->bitmap, BITS_PER_BITMAP, i + 1)) {
+        for_each_set_bit_from(i, entry->bitmap, BITS_PER_BITMAP) {
                 next_zero = find_next_zero_bit(entry->bitmap,
                                                BITS_PER_BITMAP, i);
                 if (next_zero - i >= min_bits) {
diff --git a/fs/btrfs/hash.h b/fs/btrfs/hash.h
index db2ff9773b99..1d982812ab67 100644
--- a/fs/btrfs/hash.h
+++ b/fs/btrfs/hash.h
@@ -24,4 +24,14 @@ static inline u64 btrfs_name_hash(const char *name, int len)
 {
         return crc32c((u32)~1, name, len);
 }
+
+/*
+ * Figure the key offset of an extended inode ref
+ */
+static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,
+                                    int len)
+{
+        return (u64) crc32c(parent_objectid, name, len);
+}
+
 #endif
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index a13cf1a96c73..48b8fda93132 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -18,6 +18,7 @@
 
 #include "ctree.h"
 #include "disk-io.h"
+#include "hash.h"
 #include "transaction.h"
 #include "print-tree.h"
 
@@ -50,18 +51,57 @@ static int find_name_in_backref(struct btrfs_path *path, const char *name,
         return 0;
 }
 
-struct btrfs_inode_ref *
+int btrfs_find_name_in_ext_backref(struct btrfs_path *path, u64 ref_objectid,
+                                   const char *name, int name_len,
+                                   struct btrfs_inode_extref **extref_ret)
+{
+        struct extent_buffer *leaf;
+        struct btrfs_inode_extref *extref;
+        unsigned long ptr;
+        unsigned long name_ptr;
+        u32 item_size;
+        u32 cur_offset = 0;
+        int ref_name_len;
+
+        leaf = path->nodes[0];
+        item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+        ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+        /*
+         * Search all extended backrefs in this item. We're only
+         * looking through any collisions so most of the time this is
+         * just going to compare against one buffer. If all is well,
+         * we'll return success and the inode ref object.
+         */
+        while (cur_offset < item_size) {
+                extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
+                name_ptr = (unsigned long)(&extref->name);
+                ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                if (ref_name_len == name_len &&
+                    btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&
+                    (memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)) {
+                        if (extref_ret)
+                                *extref_ret = extref;
+                        return 1;
+                }
+
+                cur_offset += ref_name_len + sizeof(*extref);
+        }
+        return 0;
+}
+
+static struct btrfs_inode_ref *
 btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root,
-                        struct btrfs_path *path,
-                        const char *name, int name_len,
-                        u64 inode_objectid, u64 ref_objectid, int mod)
+                       struct btrfs_root *root,
+                       struct btrfs_path *path,
+                       const char *name, int name_len,
+                       u64 inode_objectid, u64 ref_objectid, int ins_len,
+                       int cow)
 {
+        int ret;
         struct btrfs_key key;
         struct btrfs_inode_ref *ref;
-        int ins_len = mod < 0 ? -1 : 0;
-        int cow = mod != 0;
-        int ret;
 
         key.objectid = inode_objectid;
         key.type = BTRFS_INODE_REF_KEY;
@@ -77,13 +117,150 @@ btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
         return ref;
 }
 
-int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
+/* Returns NULL if no extref found */
+struct btrfs_inode_extref *
+btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root,
+                          struct btrfs_path *path,
+                          const char *name, int name_len,
+                          u64 inode_objectid, u64 ref_objectid, int ins_len,
+                          int cow)
+{
+        int ret;
+        struct btrfs_key key;
+        struct btrfs_inode_extref *extref;
+
+        key.objectid = inode_objectid;
+        key.type = BTRFS_INODE_EXTREF_KEY;
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
+        if (ret < 0)
+                return ERR_PTR(ret);
+        if (ret > 0)
+                return NULL;
+        if (!btrfs_find_name_in_ext_backref(path, ref_objectid, name, name_len, &extref))
+                return NULL;
+        return extref;
+}
+
+int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
+                              struct btrfs_root *root,
+                              struct btrfs_path *path,
+                              const char *name, int name_len,
+                              u64 inode_objectid, u64 ref_objectid, int mod,
+                              u64 *ret_index)
+{
+        struct btrfs_inode_ref *ref;
+        struct btrfs_inode_extref *extref;
+        int ins_len = mod < 0 ? -1 : 0;
+        int cow = mod != 0;
+
+        ref = btrfs_lookup_inode_ref(trans, root, path, name, name_len,
+                                     inode_objectid, ref_objectid, ins_len,
+                                     cow);
+        if (IS_ERR(ref))
+                return PTR_ERR(ref);
+
+        if (ref != NULL) {
+                *ret_index = btrfs_inode_ref_index(path->nodes[0], ref);
+                return 0;
+        }
+
+        btrfs_release_path(path);
+
+        extref = btrfs_lookup_inode_extref(trans, root, path, name,
+                                           name_len, inode_objectid,
+                                           ref_objectid, ins_len, cow);
+        if (IS_ERR(extref))
+                return PTR_ERR(extref);
+
+        if (extref) {
+                *ret_index = btrfs_inode_extref_index(path->nodes[0], extref);
+                return 0;
+        }
+
+        return -ENOENT;
+}
+
+int btrfs_del_inode_extref(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            const char *name, int name_len,
                            u64 inode_objectid, u64 ref_objectid, u64 *index)
 {
         struct btrfs_path *path;
         struct btrfs_key key;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        int ret;
+        int del_len = name_len + sizeof(*extref);
+        unsigned long ptr;
+        unsigned long item_start;
+        u32 item_size;
+
+        key.objectid = inode_objectid;
+        btrfs_set_key_type(&key, BTRFS_INODE_EXTREF_KEY);
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        path->leave_spinning = 1;
+
+        ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+        if (ret > 0)
+                ret = -ENOENT;
+        if (ret < 0)
+                goto out;
+
+        /*
+         * Sanity check - did we find the right item for this name?
+         * This should always succeed so error here will make the FS
+         * readonly.
+         */
+        if (!btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                            name, name_len, &extref)) {
+                btrfs_std_error(root->fs_info, -ENOENT);
+                ret = -EROFS;
+                goto out;
+        }
+
+        leaf = path->nodes[0];
+        item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+        if (index)
+                *index = btrfs_inode_extref_index(leaf, extref);
+
+        if (del_len == item_size) {
+                /*
+                 * Common case only one ref in the item, remove the
+                 * whole item.
+                 */
+                ret = btrfs_del_item(trans, root, path);
+                goto out;
+        }
+
+        ptr = (unsigned long)extref;
+        item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+        memmove_extent_buffer(leaf, ptr, ptr + del_len,
+                              item_size - (ptr + del_len - item_start));
+
+        btrfs_truncate_item(trans, root, path, item_size - del_len, 1);
+
+out:
+        btrfs_free_path(path);
+
+        return ret;
+}
+
+int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
+                        struct btrfs_root *root,
+                        const char *name, int name_len,
+                        u64 inode_objectid, u64 ref_objectid, u64 *index)
+{
+        struct btrfs_path *path;
+        struct btrfs_key key;
         struct btrfs_inode_ref *ref;
         struct extent_buffer *leaf;
         unsigned long ptr;
@@ -91,6 +268,7 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         u32 item_size;
         u32 sub_item_len;
         int ret;
+        int search_ext_refs = 0;
         int del_len = name_len + sizeof(*ref);
 
         key.objectid = inode_objectid;
@@ -106,12 +284,14 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
         if (ret > 0) {
                 ret = -ENOENT;
+                search_ext_refs = 1;
                 goto out;
         } else if (ret < 0) {
                 goto out;
         }
         if (!find_name_in_backref(path, name, name_len, &ref)) {
                 ret = -ENOENT;
+                search_ext_refs = 1;
                 goto out;
         }
         leaf = path->nodes[0];
@@ -129,8 +309,78 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
         memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
                               item_size - (ptr + sub_item_len - item_start));
-        btrfs_truncate_item(trans, root, path,
-                                  item_size - sub_item_len, 1);
+        btrfs_truncate_item(trans, root, path, item_size - sub_item_len, 1);
+out:
+        btrfs_free_path(path);
+
+        if (search_ext_refs) {
+                /*
+                 * No refs were found, or we could not find the
+                 * name in our ref array. Find and remove the extended
+                 * inode ref then.
+                 */
+                return btrfs_del_inode_extref(trans, root, name, name_len,
+                                              inode_objectid, ref_objectid, index);
+        }
+
+        return ret;
+}
+
+/*
+ * btrfs_insert_inode_extref() - Inserts an extended inode ref into a tree.
+ *
+ * The caller must have checked against BTRFS_LINK_MAX already.
+ */
+static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
+                                     struct btrfs_root *root,
+                                     const char *name, int name_len,
+                                     u64 inode_objectid, u64 ref_objectid, u64 index)
+{
+        struct btrfs_inode_extref *extref;
+        int ret;
+        int ins_len = name_len + sizeof(*extref);
+        unsigned long ptr;
+        struct btrfs_path *path;
+        struct btrfs_key key;
+        struct extent_buffer *leaf;
+        struct btrfs_item *item;
+
+        key.objectid = inode_objectid;
+        key.type = BTRFS_INODE_EXTREF_KEY;
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        path->leave_spinning = 1;
+        ret = btrfs_insert_empty_item(trans, root, path, &key,
+                                      ins_len);
+        if (ret == -EEXIST) {
+                if (btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                                   name, name_len, NULL))
+                        goto out;
+
+                btrfs_extend_item(trans, root, path, ins_len);
+                ret = 0;
+        }
+        if (ret < 0)
+                goto out;
+
+        leaf = path->nodes[0];
+        item = btrfs_item_nr(leaf, path->slots[0]);
+        ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
+        ptr += btrfs_item_size(leaf, item) - ins_len;
+        extref = (struct btrfs_inode_extref *)ptr;
+
+        btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len);
+        btrfs_set_inode_extref_index(path->nodes[0], extref, index);
+        btrfs_set_inode_extref_parent(path->nodes[0], extref, ref_objectid);
+
+        ptr = (unsigned long)&extref->name;
+        write_extent_buffer(path->nodes[0], name, ptr, name_len);
+        btrfs_mark_buffer_dirty(path->nodes[0]);
+
 out:
         btrfs_free_path(path);
         return ret;
@@ -191,6 +441,19 @@ int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
 
 out:
         btrfs_free_path(path);
+
+        if (ret == -EMLINK) {
+                struct btrfs_super_block *disk_super = root->fs_info->super_copy;
+                /* We ran out of space in the ref array. Need to
+                 * add an extended ref. */
+                if (btrfs_super_incompat_flags(disk_super)
+                    & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
+                        ret = btrfs_insert_inode_extref(trans, root, name,
+                                                        name_len,
+                                                        inode_objectid,
+                                                        ref_objectid, index);
+        }
+
         return ret;
 }
 
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a6ed6944e50c..85a1e5053fe6 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -230,7 +230,6 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
         u64 inline_len = actual_end - start;
         u64 aligned_end = (end + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
-        u64 hint_byte;
         u64 data_len = inline_len;
         int ret;
 
@@ -247,8 +246,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                 return 1;
         }
 
-        ret = btrfs_drop_extents(trans, inode, start, aligned_end,
-                                 &hint_byte, 1);
+        ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
         if (ret)
                 return ret;
 
@@ -664,7 +662,7 @@ retry:
                                            async_extent->compressed_size,
                                            async_extent->compressed_size,
                                            0, alloc_hint, &ins, 1);
-                        if (ret)
+                        if (ret && ret != -ENOSPC)
                                 btrfs_abort_transaction(trans, root, ret);
                         btrfs_end_transaction(trans, root);
                 }
@@ -1308,6 +1306,7 @@ out_check:
                         em->block_start = disk_bytenr;
                         em->bdev = root->fs_info->fs_devices->latest_bdev;
                         set_bit(EXTENT_FLAG_PINNED, &em->flags);
+                        set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
                         while (1) {
                                 write_lock(&em_tree->lock);
                                 ret = add_extent_mapping(em_tree, em);
@@ -1364,11 +1363,7 @@ out_check:
         }
 
 error:
-        if (nolock) {
-                err = btrfs_end_transaction_nolock(trans, root);
-        } else {
-                err = btrfs_end_transaction(trans, root);
-        }
+        err = btrfs_end_transaction(trans, root);
         if (!ret)
                 ret = err;
 
@@ -1785,7 +1780,6 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         struct btrfs_path *path;
         struct extent_buffer *leaf;
         struct btrfs_key ins;
-        u64 hint;
         int ret;
 
         path = btrfs_alloc_path();
@@ -1803,8 +1797,8 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
          * the caller is expected to unpin it and allow it to be merged
          * with the others.
          */
-        ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
-                                 &hint, 0);
+        ret = btrfs_drop_extents(trans, root, inode, file_pos,
+                                 file_pos + num_bytes, 0);
         if (ret)
                 goto out;
 
@@ -1828,10 +1822,8 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         btrfs_set_file_extent_encryption(leaf, fi, encryption);
         btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
 
-        btrfs_unlock_up_safe(path, 1);
-        btrfs_set_lock_blocking(leaf);
-
         btrfs_mark_buffer_dirty(leaf);
+        btrfs_release_path(path);
 
         inode_add_bytes(inode, num_bytes);
 
@@ -1929,11 +1921,10 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
                                                 ordered_extent->len,
                                                 compress_type, 0, 0,
                                                 BTRFS_FILE_EXTENT_REG);
-                unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
-                                   ordered_extent->file_offset,
-                                   ordered_extent->len);
         }
-
+        unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
+                           ordered_extent->file_offset, ordered_extent->len,
+                           trans->transid);
         if (ret < 0) {
                 btrfs_abort_transaction(trans, root, ret);
                 goto out_unlock;
@@ -1949,6 +1940,8 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
                         btrfs_abort_transaction(trans, root, ret);
                         goto out_unlock;
                 }
+        } else {
+                btrfs_set_inode_last_trans(trans, inode);
         }
         ret = 0;
 out_unlock:
@@ -1958,12 +1951,8 @@ out_unlock:
 out:
         if (root != root->fs_info->tree_root)
                 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
-        if (trans) {
-                if (nolock)
-                        btrfs_end_transaction_nolock(trans, root);
-                else
-                        btrfs_end_transaction(trans, root);
-        }
+        if (trans)
+                btrfs_end_transaction(trans, root);
 
         if (ret)
                 clear_extent_uptodate(io_tree, ordered_extent->file_offset,
@@ -2119,7 +2108,6 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
         if (empty)
                 return;
 
-        down_read(&root->fs_info->cleanup_work_sem);
         spin_lock(&fs_info->delayed_iput_lock);
         list_splice_init(&fs_info->delayed_iputs, &list);
         spin_unlock(&fs_info->delayed_iput_lock);
@@ -2130,7 +2118,6 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
                 iput(delayed->inode);
                 kfree(delayed);
         }
-        up_read(&root->fs_info->cleanup_work_sem);
 }
 
 enum btrfs_orphan_cleanup_state {
@@ -2198,7 +2185,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
         int ret;
 
         if (!root->orphan_block_rsv) {
-                block_rsv = btrfs_alloc_block_rsv(root);
+                block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
                 if (!block_rsv)
                         return -ENOMEM;
         }
@@ -2225,7 +2212,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
                         insert = 1;
 #endif
                 insert = 1;
-                atomic_dec(&root->orphan_inodes);
+                atomic_inc(&root->orphan_inodes);
         }
 
         if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
@@ -2590,6 +2577,18 @@ static void btrfs_read_locked_inode(struct inode *inode)
 
         inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
         BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
+        BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);
+
+        /*
+         * If we were modified in the current generation and evicted from memory
+         * and then re-read we need to do a full sync since we don't have any
+         * idea about which extents were modified before we were evicted from
+         * cache.
+         */
+        if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
+                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                        &BTRFS_I(inode)->runtime_flags);
+
         inode->i_version = btrfs_inode_sequence(leaf, inode_item);
         inode->i_generation = BTRFS_I(inode)->generation;
         inode->i_rdev = 0;
@@ -2894,7 +2893,6 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_path *path;
-        struct btrfs_inode_ref *ref;
         struct btrfs_dir_item *di;
         struct inode *inode = dentry->d_inode;
         u64 index;
@@ -3008,17 +3006,17 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         }
         btrfs_release_path(path);
 
-        ref = btrfs_lookup_inode_ref(trans, root, path,
-                                dentry->d_name.name, dentry->d_name.len,
-                                ino, dir_ino, 0);
-        if (IS_ERR(ref)) {
-                err = PTR_ERR(ref);
+        ret = btrfs_get_inode_ref_index(trans, root, path, dentry->d_name.name,
+                                        dentry->d_name.len, ino, dir_ino, 0,
+                                        &index);
+        if (ret) {
+                err = ret;
                 goto out;
         }
-        BUG_ON(!ref); /* Logic error */
+
         if (check_path_shared(root, path))
                 goto out;
-        index = btrfs_inode_ref_index(path->nodes[0], ref);
+
         btrfs_release_path(path);
 
         /*
@@ -3061,7 +3059,7 @@ out:
 static void __unlink_end_trans(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root)
 {
-        if (trans->block_rsv == &root->fs_info->global_block_rsv) {
+        if (trans->block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL) {
                 btrfs_block_rsv_release(root, trans->block_rsv,
                                         trans->bytes_reserved);
                 trans->block_rsv = &root->fs_info->trans_block_rsv;
@@ -3191,9 +3189,10 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         struct btrfs_trans_handle *trans;
         unsigned long nr = 0;
 
-        if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
-            btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
+        if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
                 return -ENOTEMPTY;
+        if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
+                return -EPERM;
 
         trans = __unlink_start_trans(dir, dentry);
         if (IS_ERR(trans))
@@ -3267,8 +3266,13 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                 return -ENOMEM;
         path->reada = -1;
 
+        /*
+         * We want to drop from the next block forward in case this new size is
+         * not block aligned since we will be keeping the last block of the
+         * extent just the way it is.
+         */
         if (root->ref_cows || root == root->fs_info->tree_root)
-                btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
+                btrfs_drop_extent_cache(inode, (new_size + mask) & (~mask), (u64)-1, 0);
 
         /*
          * This function is also used to drop the items in the log tree before
@@ -3429,12 +3433,6 @@ delete:
 
                 if (path->slots[0] == 0 ||
                     path->slots[0] != pending_del_slot) {
-                        if (root->ref_cows &&
-                            BTRFS_I(inode)->location.objectid !=
-                                                BTRFS_FREE_INO_OBJECTID) {
-                                err = -EAGAIN;
-                                goto out;
-                        }
                         if (pending_del_nr) {
                                 ret = btrfs_del_items(trans, root, path,
                                                 pending_del_slot,
@@ -3465,12 +3463,20 @@ error:
 }
 
 /*
- * taken from block_truncate_page, but does cow as it zeros out
- * any bytes left in the last page in the file.
+ * btrfs_truncate_page - read, zero a chunk and write a page
+ * @inode - inode that we're zeroing
+ * @from - the offset to start zeroing
+ * @len - the length to zero, 0 to zero the entire range respective to the
+ *      offset
+ * @front - zero up to the offset instead of from the offset on
+ *
+ * This will find the page for the "from" offset and cow the page and zero the
+ * part we want to zero.  This is used with truncate and hole punching.
  */
-static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
+int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
+                        int front)
 {
-        struct inode *inode = mapping->host;
+        struct address_space *mapping = inode->i_mapping;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_ordered_extent *ordered;
@@ -3485,7 +3491,8 @@ static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
         u64 page_start;
         u64 page_end;
 
-        if ((offset & (blocksize - 1)) == 0)
+        if ((offset & (blocksize - 1)) == 0 &&
+            (!len || ((len & (blocksize - 1)) == 0)))
                 goto out;
         ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
         if (ret)
@@ -3532,7 +3539,8 @@ again:
         }
 
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
-                          EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
+                          EXTENT_DIRTY | EXTENT_DELALLOC |
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
                           0, 0, &cached_state, GFP_NOFS);
 
         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
@@ -3545,8 +3553,13 @@ again:
 
         ret = 0;
         if (offset != PAGE_CACHE_SIZE) {
+                if (!len)
+                        len = PAGE_CACHE_SIZE - offset;
                 kaddr = kmap(page);
-                memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
+                if (front)
+                        memset(kaddr, 0, offset);
+                else
+                        memset(kaddr + offset, 0, len);
                 flush_dcache_page(page);
                 kunmap(page);
         }
@@ -3577,6 +3590,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct extent_map *em = NULL;
         struct extent_state *cached_state = NULL;
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         u64 mask = root->sectorsize - 1;
         u64 hole_start = (oldsize + mask) & ~mask;
         u64 block_end = (size + mask) & ~mask;
@@ -3613,7 +3627,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                 last_byte = min(extent_map_end(em), block_end);
                 last_byte = (last_byte + mask) & ~mask;
                 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
-                        u64 hint_byte = 0;
+                        struct extent_map *hole_em;
                         hole_size = last_byte - cur_offset;
 
                         trans = btrfs_start_transaction(root, 3);
@@ -3622,9 +3636,9 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                                 break;
                         }
 
-                        err = btrfs_drop_extents(trans, inode, cur_offset,
-                                                 cur_offset + hole_size,
-                                                 &hint_byte, 1);
+                        err = btrfs_drop_extents(trans, root, inode,
+                                                 cur_offset,
+                                                 cur_offset + hole_size, 1);
                         if (err) {
                                 btrfs_abort_transaction(trans, root, err);
                                 btrfs_end_transaction(trans, root);
@@ -3641,9 +3655,39 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                                 break;
                         }
 
-                        btrfs_drop_extent_cache(inode, hole_start,
-                                        last_byte - 1, 0);
+                        btrfs_drop_extent_cache(inode, cur_offset,
+                                                cur_offset + hole_size - 1, 0);
+                        hole_em = alloc_extent_map();
+                        if (!hole_em) {
+                                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                        &BTRFS_I(inode)->runtime_flags);
+                                goto next;
+                        }
+                        hole_em->start = cur_offset;
+                        hole_em->len = hole_size;
+                        hole_em->orig_start = cur_offset;
 
+                        hole_em->block_start = EXTENT_MAP_HOLE;
+                        hole_em->block_len = 0;
+                        hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
+                        hole_em->compress_type = BTRFS_COMPRESS_NONE;
+                        hole_em->generation = trans->transid;
+
+                        while (1) {
+                                write_lock(&em_tree->lock);
+                                err = add_extent_mapping(em_tree, hole_em);
+                                if (!err)
+                                        list_move(&hole_em->list,
+                                                  &em_tree->modified_extents);
+                                write_unlock(&em_tree->lock);
+                                if (err != -EEXIST)
+                                        break;
+                                btrfs_drop_extent_cache(inode, cur_offset,
+                                                        cur_offset +
+                                                        hole_size - 1, 0);
+                        }
+                        free_extent_map(hole_em);
+next:
                         btrfs_update_inode(trans, root, inode);
                         btrfs_end_transaction(trans, root);
                 }
@@ -3768,26 +3812,22 @@ void btrfs_evict_inode(struct inode *inode)
                 goto no_delete;
         }
 
-        rsv = btrfs_alloc_block_rsv(root);
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
         if (!rsv) {
                 btrfs_orphan_del(NULL, inode);
                 goto no_delete;
         }
         rsv->size = min_size;
+        rsv->failfast = 1;
         global_rsv = &root->fs_info->global_block_rsv;
 
         btrfs_i_size_write(inode, 0);
 
         /*
-         * This is a bit simpler than btrfs_truncate since
-         *
-         * 1) We've already reserved our space for our orphan item in the
-         *    unlink.
-         * 2) We're going to delete the inode item, so we don't need to update
-         *    it at all.
-         *
-         * So we just need to reserve some slack space in case we add bytes when
-         * doing the truncate.
+         * This is a bit simpler than btrfs_truncate since we've already
+         * reserved our space for our orphan item in the unlink, so we just
+         * need to reserve some slack space in case we add bytes and update
+         * inode item when doing the truncate.
          */
         while (1) {
                 ret = btrfs_block_rsv_refill_noflush(root, rsv, min_size);
@@ -3808,7 +3848,7 @@ void btrfs_evict_inode(struct inode *inode)
                         goto no_delete;
                 }
 
-                trans = btrfs_start_transaction(root, 0);
+                trans = btrfs_start_transaction_noflush(root, 1);
                 if (IS_ERR(trans)) {
                         btrfs_orphan_del(NULL, inode);
                         btrfs_free_block_rsv(root, rsv);
@@ -3818,9 +3858,13 @@ void btrfs_evict_inode(struct inode *inode)
                 trans->block_rsv = rsv;
 
                 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
-                if (ret != -EAGAIN)
+                if (ret != -ENOSPC)
                         break;
 
+                trans->block_rsv = &root->fs_info->trans_block_rsv;
+                ret = btrfs_update_inode(trans, root, inode);
+                BUG_ON(ret);
+
                 nr = trans->blocks_used;
                 btrfs_end_transaction(trans, root);
                 trans = NULL;
@@ -4470,10 +4514,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
                         trans = btrfs_join_transaction(root);
                 if (IS_ERR(trans))
                         return PTR_ERR(trans);
-                if (nolock)
-                        ret = btrfs_end_transaction_nolock(trans, root);
-                else
-                        ret = btrfs_commit_transaction(trans, root);
+                ret = btrfs_commit_transaction(trans, root);
         }
         return ret;
 }
@@ -4671,6 +4712,14 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         BTRFS_I(inode)->generation = trans->transid;
         inode->i_generation = BTRFS_I(inode)->generation;
 
+        /*
+         * We could have gotten an inode number from somebody who was fsynced
+         * and then removed in this same transaction, so let's just set full
+         * sync since it will be a full sync anyway and this will blow away the
+         * old info in the log.
+         */
+        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
+
         if (S_ISDIR(mode))
                 owner = 0;
         else
@@ -4680,6 +4729,12 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
         key[0].offset = 0;
 
+        /*
+         * Start new inodes with an inode_ref. This is slightly more
+         * efficient for small numbers of hard links since they will
+         * be packed into one item. Extended refs will kick in if we
+         * add more hard links than can fit in the ref item.
+         */
         key[1].objectid = objectid;
         btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
         key[1].offset = ref_objectid;
@@ -4986,7 +5041,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         if (root->objectid != BTRFS_I(inode)->root->objectid)
                 return -EXDEV;
 
-        if (inode->i_nlink == ~0U)
+        if (inode->i_nlink >= BTRFS_LINK_MAX)
                 return -EMLINK;
 
         err = btrfs_set_inode_index(dir, &index);
@@ -5450,7 +5505,8 @@ insert:
         write_unlock(&em_tree->lock);
 out:
 
-        trace_btrfs_get_extent(root, em);
+        if (em)
+                trace_btrfs_get_extent(root, em);
 
         if (path)
                 btrfs_free_path(path);
@@ -5836,6 +5892,48 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
         return ret;
 }
 
+static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
+                                           u64 len, u64 orig_start,
+                                           u64 block_start, u64 block_len,
+                                           int type)
+{
+        struct extent_map_tree *em_tree;
+        struct extent_map *em;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        em_tree = &BTRFS_I(inode)->extent_tree;
+        em = alloc_extent_map();
+        if (!em)
+                return ERR_PTR(-ENOMEM);
+
+        em->start = start;
+        em->orig_start = orig_start;
+        em->len = len;
+        em->block_len = block_len;
+        em->block_start = block_start;
+        em->bdev = root->fs_info->fs_devices->latest_bdev;
+        set_bit(EXTENT_FLAG_PINNED, &em->flags);
+        if (type == BTRFS_ORDERED_PREALLOC)
+                set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
+
+        do {
+                btrfs_drop_extent_cache(inode, em->start,
+                                em->start + em->len - 1, 0);
+                write_lock(&em_tree->lock);
+                ret = add_extent_mapping(em_tree, em);
+                write_unlock(&em_tree->lock);
+        } while (ret == -EEXIST);
+
+        if (ret) {
+                free_extent_map(em);
+                return ERR_PTR(ret);
+        }
+
+        return em;
+}
+
+
 static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                                    struct buffer_head *bh_result, int create)
 {
@@ -5950,6 +6048,19 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                         goto must_cow;
 
                 if (can_nocow_odirect(trans, inode, start, len) == 1) {
+                        u64 orig_start = em->start;
+
+                        if (type == BTRFS_ORDERED_PREALLOC) {
+                                free_extent_map(em);
+                                em = create_pinned_em(inode, start, len,
+                                                       orig_start,
+                                                       block_start, len, type);
+                                if (IS_ERR(em)) {
+                                        btrfs_end_transaction(trans, root);
+                                        goto unlock_err;
+                                }
+                        }
+
                         ret = btrfs_add_ordered_extent_dio(inode, start,
                                            block_start, len, len, type);
                         btrfs_end_transaction(trans, root);
@@ -5999,7 +6110,8 @@ unlock:
         if (lockstart < lockend) {
                 if (create && len < lockend - lockstart) {
                         clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
-                                         lockstart + len - 1, unlock_bits, 1, 0,
+                                         lockstart + len - 1,
+                                         unlock_bits | EXTENT_DEFRAG, 1, 0,
                                          &cached_state, GFP_NOFS);
                         /*
                          * Beside unlock, we also need to cleanup reserved space
@@ -6007,8 +6119,8 @@ unlock:
                          */
                         clear_extent_bit(&BTRFS_I(inode)->io_tree,
                                          lockstart + len, lockend,
-                                         unlock_bits | EXTENT_DO_ACCOUNTING,
-                                         1, 0, NULL, GFP_NOFS);
+                                         unlock_bits | EXTENT_DO_ACCOUNTING |
+                                         EXTENT_DEFRAG, 1, 0, NULL, GFP_NOFS);
                 } else {
                         clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
                                          lockend, unlock_bits, 1, 0,
@@ -6573,8 +6685,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
                  */
                 clear_extent_bit(tree, page_start, page_end,
                                  EXTENT_DIRTY | EXTENT_DELALLOC |
-                                 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING, 1, 0,
-                                 &cached_state, GFP_NOFS);
+                                 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
+                                 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
                 /*
                  * whoever cleared the private bit is responsible
                  * for the finish_ordered_io
@@ -6590,7 +6702,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
         }
         clear_extent_bit(tree, page_start, page_end,
                  EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
-                 EXTENT_DO_ACCOUNTING, 1, 1, &cached_state, GFP_NOFS);
+                 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
+                 &cached_state, GFP_NOFS);
         __btrfs_releasepage(page, GFP_NOFS);
 
         ClearPageChecked(page);
@@ -6687,7 +6800,8 @@ again:
          * prepare_pages in the normal write path.
          */
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
-                          EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
+                          EXTENT_DIRTY | EXTENT_DELALLOC |
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
                           0, 0, &cached_state, GFP_NOFS);
 
         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
@@ -6718,6 +6832,7 @@ again:
 
         BTRFS_I(inode)->last_trans = root->fs_info->generation;
         BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
 
         unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
 
@@ -6745,7 +6860,7 @@ static int btrfs_truncate(struct inode *inode)
         u64 mask = root->sectorsize - 1;
         u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
 
-        ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
+        ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
         if (ret)
                 return ret;
 
@@ -6788,10 +6903,11 @@ static int btrfs_truncate(struct inode *inode)
          * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
          * updating the inode.
          */
-        rsv = btrfs_alloc_block_rsv(root);
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
         if (!rsv)
                 return -ENOMEM;
         rsv->size = min_size;
+        rsv->failfast = 1;
 
         /*
          * 1 for the truncate slack space
@@ -6837,36 +6953,21 @@ static int btrfs_truncate(struct inode *inode)
                                            &BTRFS_I(inode)->runtime_flags))
                 btrfs_add_ordered_operation(trans, root, inode);
 
-        while (1) {
-                ret = btrfs_block_rsv_refill(root, rsv, min_size);
-                if (ret) {
-                        /*
-                         * This can only happen with the original transaction we
-                         * started above, every other time we shouldn't have a
-                         * transaction started yet.
-                         */
-                        if (ret == -EAGAIN)
-                                goto end_trans;
-                        err = ret;
-                        break;
-                }
-
-                if (!trans) {
-                        /* Just need the 1 for updating the inode */
-                        trans = btrfs_start_transaction(root, 1);
-                        if (IS_ERR(trans)) {
-                                ret = err = PTR_ERR(trans);
-                                trans = NULL;
-                                break;
-                        }
-                }
-
-                trans->block_rsv = rsv;
+        /*
+         * So if we truncate and then write and fsync we normally would just
+         * write the extents that changed, which is a problem if we need to
+         * first truncate that entire inode.  So set this flag so we write out
+         * all of the extents in the inode to the sync log so we're completely
+         * safe.
+         */
+        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
+        trans->block_rsv = rsv;
 
+        while (1) {
                 ret = btrfs_truncate_inode_items(trans, root, inode,
                                                  inode->i_size,
                                                  BTRFS_EXTENT_DATA_KEY);
-                if (ret != -EAGAIN) {
+                if (ret != -ENOSPC) {
                         err = ret;
                         break;
                 }
@@ -6877,11 +6978,22 @@ static int btrfs_truncate(struct inode *inode)
                         err = ret;
                         break;
                 }
-end_trans:
+
                 nr = trans->blocks_used;
                 btrfs_end_transaction(trans, root);
-                trans = NULL;
                 btrfs_btree_balance_dirty(root, nr);
+
+                trans = btrfs_start_transaction(root, 2);
+                if (IS_ERR(trans)) {
+                        ret = err = PTR_ERR(trans);
+                        trans = NULL;
+                        break;
+                }
+
+                ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
+                                              rsv, min_size);
+                BUG_ON(ret);    /* shouldn't happen */
+                trans->block_rsv = rsv;
         }
 
         if (ret == 0 && inode->i_nlink > 0) {
@@ -6965,6 +7077,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->csum_bytes = 0;
         ei->index_cnt = (u64)-1;
         ei->last_unlink_trans = 0;
+        ei->last_log_commit = 0;
 
         spin_lock_init(&ei->lock);
         ei->outstanding_extents = 0;
@@ -7095,31 +7208,31 @@ void btrfs_destroy_cachep(void)
 
 int btrfs_init_cachep(void)
 {
-        btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
+        btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
                         sizeof(struct btrfs_inode), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
         if (!btrfs_inode_cachep)
                 goto fail;
 
-        btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
+        btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
                         sizeof(struct btrfs_trans_handle), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_trans_handle_cachep)
                 goto fail;
 
-        btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
+        btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
                         sizeof(struct btrfs_transaction), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_transaction_cachep)
                 goto fail;
 
-        btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
+        btrfs_path_cachep = kmem_cache_create("btrfs_path",
                         sizeof(struct btrfs_path), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_path_cachep)
                 goto fail;
 
-        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
+        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
                         sizeof(struct btrfs_free_space), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_free_space_cachep)
@@ -7513,6 +7626,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                        loff_t actual_len, u64 *alloc_hint,
                                        struct btrfs_trans_handle *trans)
 {
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct extent_map *em;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_key ins;
         u64 cur_offset = start;
@@ -7553,6 +7668,37 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                 btrfs_drop_extent_cache(inode, cur_offset,
                                         cur_offset + ins.offset -1, 0);
 
+                em = alloc_extent_map();
+                if (!em) {
+                        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                &BTRFS_I(inode)->runtime_flags);
+                        goto next;
+                }
+
+                em->start = cur_offset;
+                em->orig_start = cur_offset;
+                em->len = ins.offset;
+                em->block_start = ins.objectid;
+                em->block_len = ins.offset;
+                em->bdev = root->fs_info->fs_devices->latest_bdev;
+                set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
+                em->generation = trans->transid;
+
+                while (1) {
+                        write_lock(&em_tree->lock);
+                        ret = add_extent_mapping(em_tree, em);
+                        if (!ret)
+                                list_move(&em->list,
+                                          &em_tree->modified_extents);
+                        write_unlock(&em_tree->lock);
+                        if (ret != -EEXIST)
+                                break;
+                        btrfs_drop_extent_cache(inode, cur_offset,
+                                                cur_offset + ins.offset - 1,
+                                                0);
+                }
+                free_extent_map(em);
+next:
                 num_bytes -= ins.offset;
                 cur_offset += ins.offset;
                 *alloc_hint = ins.objectid + ins.offset;
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 47127c1bd290..e568c472f807 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -181,6 +181,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         int ret;
         u64 ip_oldflags;
         unsigned int i_oldflags;
+        umode_t mode;
 
         if (btrfs_root_readonly(root))
                 return -EROFS;
@@ -203,6 +204,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 
         ip_oldflags = ip->flags;
         i_oldflags = inode->i_flags;
+        mode = inode->i_mode;
 
         flags = btrfs_mask_flags(inode->i_mode, flags);
         oldflags = btrfs_flags_to_ioctl(ip->flags);
@@ -237,10 +239,31 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
                 ip->flags |= BTRFS_INODE_DIRSYNC;
         else
                 ip->flags &= ~BTRFS_INODE_DIRSYNC;
-        if (flags & FS_NOCOW_FL)
-                ip->flags |= BTRFS_INODE_NODATACOW;
-        else
-                ip->flags &= ~BTRFS_INODE_NODATACOW;
+        if (flags & FS_NOCOW_FL) {
+                if (S_ISREG(mode)) {
+                        /*
+                         * It's safe to turn csums off here, no extents exist.
+                         * Otherwise we want the flag to reflect the real COW
+                         * status of the file and will not set it.
+                         */
+                        if (inode->i_size == 0)
+                                ip->flags |= BTRFS_INODE_NODATACOW
+                                           | BTRFS_INODE_NODATASUM;
+                } else {
+                        ip->flags |= BTRFS_INODE_NODATACOW;
+                }
+        } else {
+                /*
+                 * Revert back under same assuptions as above
+                 */
+                if (S_ISREG(mode)) {
+                        if (inode->i_size == 0)
+                                ip->flags &= ~(BTRFS_INODE_NODATACOW
+                                             | BTRFS_INODE_NODATASUM);
+                } else {
+                        ip->flags &= ~BTRFS_INODE_NODATACOW;
+                }
+        }
 
         /*
          * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
@@ -516,7 +539,8 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
         if (!pending_snapshot)
                 return -ENOMEM;
 
-        btrfs_init_block_rsv(&pending_snapshot->block_rsv);
+        btrfs_init_block_rsv(&pending_snapshot->block_rsv,
+                             BTRFS_BLOCK_RSV_TEMP);
         pending_snapshot->dentry = dentry;
         pending_snapshot->root = root;
         pending_snapshot->readonly = readonly;
@@ -525,7 +549,7 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
                 *inherit = NULL;        /* take responsibility to free it */
         }
 
-        trans = btrfs_start_transaction(root->fs_info->extent_root, 5);
+        trans = btrfs_start_transaction(root->fs_info->extent_root, 6);
         if (IS_ERR(trans)) {
                 ret = PTR_ERR(trans);
                 goto fail;
@@ -1022,8 +1046,8 @@ again:
                          page_start, page_end - 1, 0, &cached_state);
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
                           page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
-                          EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
-                          GFP_NOFS);
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
+                          &cached_state, GFP_NOFS);
 
         if (i_done != page_cnt) {
                 spin_lock(&BTRFS_I(inode)->lock);
@@ -1034,8 +1058,8 @@ again:
         }
 
 
-        btrfs_set_extent_delalloc(inode, page_start, page_end - 1,
-                                  &cached_state);
+        set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
+                          &cached_state, GFP_NOFS);
 
         unlock_extent_cached(&BTRFS_I(inode)->io_tree,
                              page_start, page_end - 1, &cached_state,
@@ -2351,7 +2375,6 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         int ret;
         u64 len = olen;
         u64 bs = root->fs_info->sb->s_blocksize;
-        u64 hint_byte;
 
         /*
          * TODO:
@@ -2456,13 +2479,13 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
            another, and lock file content */
         while (1) {
                 struct btrfs_ordered_extent *ordered;
-                lock_extent(&BTRFS_I(src)->io_tree, off, off+len);
-                ordered = btrfs_lookup_first_ordered_extent(src, off+len);
+                lock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
+                ordered = btrfs_lookup_first_ordered_extent(src, off + len - 1);
                 if (!ordered &&
-                    !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len,
-                                   EXTENT_DELALLOC, 0, NULL))
+                    !test_range_bit(&BTRFS_I(src)->io_tree, off, off + len - 1,
+                                    EXTENT_DELALLOC, 0, NULL))
                         break;
-                unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
+                unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
                 if (ordered)
                         btrfs_put_ordered_extent(ordered);
                 btrfs_wait_ordered_range(src, off, len);
@@ -2536,7 +2559,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         btrfs_release_path(path);
 
                         if (key.offset + datal <= off ||
-                            key.offset >= off+len)
+                            key.offset >= off + len - 1)
                                 goto next;
 
                         memcpy(&new_key, &key, sizeof(new_key));
@@ -2574,10 +2597,10 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                         datal -= off - key.offset;
                                 }
 
-                                ret = btrfs_drop_extents(trans, inode,
+                                ret = btrfs_drop_extents(trans, root, inode,
                                                          new_key.offset,
                                                          new_key.offset + datal,
-                                                         &hint_byte, 1);
+                                                         1);
                                 if (ret) {
                                         btrfs_abort_transaction(trans, root,
                                                                 ret);
@@ -2637,8 +2660,8 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                         new_key.offset += skip;
                                 }
 
-                                if (key.offset + datal > off+len)
-                                        trim = key.offset + datal - (off+len);
+                                if (key.offset + datal > off + len)
+                                        trim = key.offset + datal - (off + len);
 
                                 if (comp && (skip || trim)) {
                                         ret = -EINVAL;
@@ -2648,10 +2671,10 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                 size -= skip + trim;
                                 datal -= skip + trim;
 
-                                ret = btrfs_drop_extents(trans, inode,
+                                ret = btrfs_drop_extents(trans, root, inode,
                                                          new_key.offset,
                                                          new_key.offset + datal,
-                                                         &hint_byte, 1);
+                                                         1);
                                 if (ret) {
                                         btrfs_abort_transaction(trans, root,
                                                                 ret);
@@ -2715,7 +2738,7 @@ next:
         ret = 0;
 out:
         btrfs_release_path(path);
-        unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
+        unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
 out_unlock:
         mutex_unlock(&src->i_mutex);
         mutex_unlock(&inode->i_mutex);
@@ -2850,8 +2873,8 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
         return 0;
 }
 
-static void get_block_group_info(struct list_head *groups_list,
-                                 struct btrfs_ioctl_space_info *space)
+void btrfs_get_block_group_info(struct list_head *groups_list,
+                                struct btrfs_ioctl_space_info *space)
 {
         struct btrfs_block_group_cache *block_group;
 
@@ -2959,8 +2982,8 @@ long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
                 down_read(&info->groups_sem);
                 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
                         if (!list_empty(&info->block_groups[c])) {
-                                get_block_group_info(&info->block_groups[c],
-                                                     &space);
+                                btrfs_get_block_group_info(
+                                        &info->block_groups[c], &space);
                                 memcpy(dest, &space, sizeof(space));
                                 dest++;
                                 space_args.total_spaces++;
@@ -3208,11 +3231,9 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
 {
         int ret = 0;
         int size;
-        u64 extent_item_pos;
         struct btrfs_ioctl_logical_ino_args *loi;
         struct btrfs_data_container *inodes = NULL;
         struct btrfs_path *path = NULL;
-        struct btrfs_key key;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -3230,7 +3251,7 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
                 goto out;
         }
 
-        size = min_t(u32, loi->size, 4096);
+        size = min_t(u32, loi->size, 64 * 1024);
         inodes = init_data_container(size);
         if (IS_ERR(inodes)) {
                 ret = PTR_ERR(inodes);
@@ -3238,22 +3259,13 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
                 goto out;
         }
 
-        ret = extent_from_logical(root->fs_info, loi->logical, path, &key);
-        btrfs_release_path(path);
-
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+        ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path,
+                                          build_ino_list, inodes);
+        if (ret == -EINVAL)
                 ret = -ENOENT;
         if (ret < 0)
                 goto out;
 
-        extent_item_pos = loi->logical - key.objectid;
-        ret = iterate_extent_inodes(root->fs_info, key.objectid,
-                                        extent_item_pos, 0, build_ino_list,
-                                        inodes);
-
-        if (ret < 0)
-                goto out;
-
         ret = copy_to_user((void *)(unsigned long)loi->inodes,
                            (void *)(unsigned long)inodes, size);
         if (ret)
@@ -3261,7 +3273,7 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
 
 out:
         btrfs_free_path(path);
-        kfree(inodes);
+        vfree(inodes);
         kfree(loi);
 
         return ret;
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 051c7fe551dd..7772f02ba28e 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -25,6 +25,8 @@
 #include "btrfs_inode.h"
 #include "extent_io.h"
 
+static struct kmem_cache *btrfs_ordered_extent_cache;
+
 static u64 entry_end(struct btrfs_ordered_extent *entry)
 {
         if (entry->file_offset + entry->len < entry->file_offset)
@@ -187,7 +189,7 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
         struct btrfs_ordered_extent *entry;
 
         tree = &BTRFS_I(inode)->ordered_tree;
-        entry = kzalloc(sizeof(*entry), GFP_NOFS);
+        entry = kmem_cache_zalloc(btrfs_ordered_extent_cache, GFP_NOFS);
         if (!entry)
                 return -ENOMEM;
 
@@ -421,7 +423,7 @@ void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
                         list_del(&sum->list);
                         kfree(sum);
                 }
-                kfree(entry);
+                kmem_cache_free(btrfs_ordered_extent_cache, entry);
         }
 }
 
@@ -466,8 +468,7 @@ void btrfs_remove_ordered_extent(struct inode *inode,
  * wait for all the ordered extents in a root.  This is done when balancing
  * space between drives.
  */
-void btrfs_wait_ordered_extents(struct btrfs_root *root,
-                                int nocow_only, int delay_iput)
+void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput)
 {
         struct list_head splice;
         struct list_head *cur;
@@ -482,15 +483,6 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root,
                 cur = splice.next;
                 ordered = list_entry(cur, struct btrfs_ordered_extent,
                                      root_extent_list);
-                if (nocow_only &&
-                    !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) &&
-                    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
-                        list_move(&ordered->root_extent_list,
-                                  &root->fs_info->ordered_extents);
-                        cond_resched_lock(&root->fs_info->ordered_extent_lock);
-                        continue;
-                }
-
                 list_del_init(&ordered->root_extent_list);
                 atomic_inc(&ordered->refs);
 
@@ -775,7 +767,6 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
         struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
         u64 disk_i_size;
         u64 new_i_size;
-        u64 i_size_test;
         u64 i_size = i_size_read(inode);
         struct rb_node *node;
         struct rb_node *prev = NULL;
@@ -835,55 +826,30 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
                         break;
                 if (test->file_offset >= i_size)
                         break;
-                if (test->file_offset >= disk_i_size)
+                if (test->file_offset >= disk_i_size) {
+                        /*
+                         * we don't update disk_i_size now, so record this
+                         * undealt i_size. Or we will not know the real
+                         * i_size.
+                         */
+                        if (test->outstanding_isize < offset)
+                                test->outstanding_isize = offset;
+                        if (ordered &&
+                            ordered->outstanding_isize >
+                            test->outstanding_isize)
+                                test->outstanding_isize =
+                                                ordered->outstanding_isize;
                         goto out;
-        }
-        new_i_size = min_t(u64, offset, i_size);
-
-        /*
-         * at this point, we know we can safely update i_size to at least
-         * the offset from this ordered extent.  But, we need to
-         * walk forward and see if ios from higher up in the file have
-         * finished.
-         */
-        if (ordered) {
-                node = rb_next(&ordered->rb_node);
-        } else {
-                if (prev)
-                        node = rb_next(prev);
-                else
-                        node = rb_first(&tree->tree);
-        }
-
-        /*
-         * We are looking for an area between our current extent and the next
-         * ordered extent to update the i_size to.  There are 3 cases here
-         *
-         * 1) We don't actually have anything and we can update to i_size.
-         * 2) We have stuff but they already did their i_size update so again we
-         * can just update to i_size.
-         * 3) We have an outstanding ordered extent so the most we can update
-         * our disk_i_size to is the start of the next offset.
-         */
-        i_size_test = i_size;
-        for (; node; node = rb_next(node)) {
-                test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
-
-                if (test_bit(BTRFS_ORDERED_UPDATED_ISIZE, &test->flags))
-                        continue;
-                if (test->file_offset > offset) {
-                        i_size_test = test->file_offset;
-                        break;
                 }
         }
+        new_i_size = min_t(u64, offset, i_size);
 
         /*
-         * i_size_test is the end of a region after this ordered
-         * extent where there are no ordered extents, we can safely set
-         * disk_i_size to this.
+         * Some ordered extents may completed before the current one, and
+         * we hold the real i_size in ->outstanding_isize.
          */
-        if (i_size_test > offset)
-                new_i_size = min_t(u64, i_size_test, i_size);
+        if (ordered && ordered->outstanding_isize > new_i_size)
+                new_i_size = min_t(u64, ordered->outstanding_isize, i_size);
         BTRFS_I(inode)->disk_i_size = new_i_size;
         ret = 0;
 out:
@@ -984,3 +950,20 @@ void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
         }
         spin_unlock(&root->fs_info->ordered_extent_lock);
 }
+
+int __init ordered_data_init(void)
+{
+        btrfs_ordered_extent_cache = kmem_cache_create("btrfs_ordered_extent",
+                                     sizeof(struct btrfs_ordered_extent), 0,
+                                     SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                                     NULL);
+        if (!btrfs_ordered_extent_cache)
+                return -ENOMEM;
+        return 0;
+}
+
+void ordered_data_exit(void)
+{
+        if (btrfs_ordered_extent_cache)
+                kmem_cache_destroy(btrfs_ordered_extent_cache);
+}
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index e03c560d2997..dd27a0b46a37 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -96,6 +96,13 @@ struct btrfs_ordered_extent {
         /* number of bytes that still need writing */
         u64 bytes_left;
 
+        /*
+         * the end of the ordered extent which is behind it but
+         * didn't update disk_i_size. Please see the comment of
+         * btrfs_ordered_update_i_size();
+         */
+        u64 outstanding_isize;
+
         /* flags (described above) */
         unsigned long flags;
 
@@ -183,6 +190,7 @@ void btrfs_run_ordered_operations(struct btrfs_root *root, int wait);
 void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
                                  struct btrfs_root *root,
                                  struct inode *inode);
-void btrfs_wait_ordered_extents(struct btrfs_root *root,
-                                int nocow_only, int delay_iput);
+void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput);
+int __init ordered_data_init(void);
+void ordered_data_exit(void);
 #endif
diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index b65015581744..5039686df6ae 100644
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -1145,12 +1145,12 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                 ulist_reinit(tmp);
                                                 /* XXX id not needed */
-                ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+                ulist_add(tmp, qg->qgroupid, (u64)(uintptr_t)qg, GFP_ATOMIC);
                 ULIST_ITER_INIT(&tmp_uiter);
                 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                         struct btrfs_qgroup_list *glist;
 
-                        qg = (struct btrfs_qgroup *)tmp_unode->aux;
+                        qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
                         if (qg->refcnt < seq)
                                 qg->refcnt = seq + 1;
                         else
@@ -1158,7 +1158,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                         list_for_each_entry(glist, &qg->groups, next_group) {
                                 ulist_add(tmp, glist->group->qgroupid,
-                                          (unsigned long)glist->group,
+                                          (u64)(uintptr_t)glist->group,
                                           GFP_ATOMIC);
                         }
                 }
@@ -1168,13 +1168,13 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
          * step 2: walk from the new root
          */
         ulist_reinit(tmp);
-        ulist_add(tmp, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        ulist_add(tmp, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(tmp, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
                 if (qg->refcnt < seq) {
                         /* not visited by step 1 */
                         qg->rfer += sgn * node->num_bytes;
@@ -1190,7 +1190,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(tmp, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
 
@@ -1208,12 +1208,12 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
                         continue;
 
                 ulist_reinit(tmp);
-                ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+                ulist_add(tmp, qg->qgroupid, (uintptr_t)qg, GFP_ATOMIC);
                 ULIST_ITER_INIT(&tmp_uiter);
                 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                         struct btrfs_qgroup_list *glist;
 
-                        qg = (struct btrfs_qgroup *)tmp_unode->aux;
+                        qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
                         if (qg->tag == seq)
                                 continue;
 
@@ -1225,7 +1225,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                         list_for_each_entry(glist, &qg->groups, next_group) {
                                 ulist_add(tmp, glist->group->qgroupid,
-                                          (unsigned long)glist->group,
+                                          (uintptr_t)glist->group,
                                           GFP_ATOMIC);
                         }
                 }
@@ -1469,13 +1469,17 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
          * be exceeded
          */
         ulist = ulist_alloc(GFP_ATOMIC);
-        ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        if (!ulist) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ulist_add(ulist, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) &&
                     qg->reserved + qg->rfer + num_bytes >
@@ -1489,7 +1493,7 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(ulist, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
         if (ret)
@@ -1502,7 +1506,7 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 qg->reserved += num_bytes;
         }
@@ -1541,19 +1545,23 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
                 goto out;
 
         ulist = ulist_alloc(GFP_ATOMIC);
-        ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        if (!ulist) {
+                btrfs_std_error(fs_info, -ENOMEM);
+                goto out;
+        }
+        ulist_add(ulist, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 qg->reserved -= num_bytes;
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(ulist, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
 
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 4da08652004d..776f0aa128fc 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3270,8 +3270,8 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info,
         key.offset = 0;
 
         inode = btrfs_iget(fs_info->sb, &key, root, NULL);
-        if (IS_ERR_OR_NULL(inode) || is_bad_inode(inode)) {
-                if (inode && !IS_ERR(inode))
+        if (IS_ERR(inode) || is_bad_inode(inode)) {
+                if (!IS_ERR(inode))
                         iput(inode);
                 return -ENOENT;
         }
@@ -3621,7 +3621,7 @@ next:
 
                 ret = find_first_extent_bit(&rc->processed_blocks,
                                             key.objectid, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
 
                 if (ret == 0 && start <= key.objectid) {
                         btrfs_release_path(path);
@@ -3674,7 +3674,8 @@ int prepare_to_relocate(struct reloc_control *rc)
         struct btrfs_trans_handle *trans;
         int ret;
 
-        rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root);
+        rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root,
+                                              BTRFS_BLOCK_RSV_TEMP);
         if (!rc->block_rsv)
                 return -ENOMEM;
 
@@ -4057,7 +4058,7 @@ int btrfs_relocate_block_group(struct btrfs_root *extent_root, u64 group_start)
                (unsigned long long)rc->block_group->flags);
 
         btrfs_start_delalloc_inodes(fs_info->tree_root, 0);
-        btrfs_wait_ordered_extents(fs_info->tree_root, 0, 0);
+        btrfs_wait_ordered_extents(fs_info->tree_root, 0);
 
         while (1) {
                 mutex_lock(&fs_info->cleaner_mutex);
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 10d8e4d88071..eb923d087da7 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -141,8 +141,10 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
                 return -ENOMEM;
 
         ret = btrfs_search_slot(trans, root, key, path, 0, 1);
-        if (ret < 0)
-                goto out_abort;
+        if (ret < 0) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         if (ret != 0) {
                 btrfs_print_leaf(root, path->nodes[0]);
@@ -166,16 +168,23 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
                 btrfs_release_path(path);
                 ret = btrfs_search_slot(trans, root, key, path,
                                 -1, 1);
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
+
                 ret = btrfs_del_item(trans, root, path);
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
                 btrfs_release_path(path);
                 ret = btrfs_insert_empty_item(trans, root, path,
                                 key, sizeof(*item));
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
                 l = path->nodes[0];
                 slot = path->slots[0];
                 ptr = btrfs_item_ptr_offset(l, slot);
@@ -192,10 +201,6 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
 out:
         btrfs_free_path(path);
         return ret;
-
-out_abort:
-        btrfs_abort_transaction(trans, root, ret);
-        goto out;
 }
 
 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index b223620cd5a6..27892f67e69b 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -352,13 +352,14 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
         struct extent_buffer *eb;
         struct btrfs_extent_item *ei;
         struct scrub_warning swarn;
-        u32 item_size;
-        int ret;
+        unsigned long ptr = 0;
+        u64 extent_item_pos;
+        u64 flags = 0;
         u64 ref_root;
+        u32 item_size;
         u8 ref_level;
-        unsigned long ptr = 0;
         const int bufsize = 4096;
-        u64 extent_item_pos;
+        int ret;
 
         path = btrfs_alloc_path();
 
@@ -375,7 +376,8 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
         if (!path || !swarn.scratch_buf || !swarn.msg_buf)
                 goto out;
 
-        ret = extent_from_logical(fs_info, swarn.logical, path, &found_key);
+        ret = extent_from_logical(fs_info, swarn.logical, path, &found_key,
+                                  &flags);
         if (ret < 0)
                 goto out;
 
@@ -387,7 +389,7 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
         item_size = btrfs_item_size_nr(eb, path->slots[0]);
         btrfs_release_path(path);
 
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
                 do {
                         ret = tree_backref_for_extent(&ptr, eb, ei, item_size,
                                                         &ref_root, &ref_level);
@@ -1029,6 +1031,7 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
                                 spin_lock(&sdev->stat_lock);
                                 sdev->stat.malloc_errors++;
                                 spin_unlock(&sdev->stat_lock);
+                                kfree(bbio);
                                 return -ENOMEM;
                         }
                         sblock->page_count++;
@@ -1666,21 +1669,6 @@ static void scrub_bio_end_io_worker(struct btrfs_work *work)
                 scrub_block_put(sblock);
         }
 
-        if (sbio->err) {
-                /* what is this good for??? */
-                sbio->bio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                sbio->bio->bi_flags |= 1 << BIO_UPTODATE;
-                sbio->bio->bi_phys_segments = 0;
-                sbio->bio->bi_idx = 0;
-
-                for (i = 0; i < sbio->page_count; i++) {
-                        struct bio_vec *bi;
-                        bi = &sbio->bio->bi_io_vec[i];
-                        bi->bv_offset = 0;
-                        bi->bv_len = PAGE_SIZE;
-                }
-        }
-
         bio_put(sbio->bio);
         sbio->bio = NULL;
         spin_lock(&sdev->list_lock);
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index fb5ffe95f869..c7beb543a4a8 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -107,7 +107,6 @@ struct send_ctx {
         int cur_inode_new;
         int cur_inode_new_gen;
         int cur_inode_deleted;
-        int cur_inode_first_ref_orphan;
         u64 cur_inode_size;
         u64 cur_inode_mode;
 
@@ -126,7 +125,15 @@ struct send_ctx {
 
 struct name_cache_entry {
         struct list_head list;
-        struct list_head use_list;
+        /*
+         * radix_tree has only 32bit entries but we need to handle 64bit inums.
+         * We use the lower 32bit of the 64bit inum to store it in the tree. If
+         * more then one inum would fall into the same entry, we use radix_list
+         * to store the additional entries. radix_list is also used to store
+         * entries where two entries have the same inum but different
+         * generations.
+         */
+        struct list_head radix_list;
         u64 ino;
         u64 gen;
         u64 parent_ino;
@@ -328,6 +335,7 @@ out:
         return ret;
 }
 
+#if 0
 static void fs_path_remove(struct fs_path *p)
 {
         BUG_ON(p->reversed);
@@ -335,6 +343,7 @@ static void fs_path_remove(struct fs_path *p)
                 p->end--;
         *p->end = 0;
 }
+#endif
 
 static int fs_path_copy(struct fs_path *p, struct fs_path *from)
 {
@@ -377,7 +386,7 @@ static struct btrfs_path *alloc_path_for_send(void)
         return path;
 }
 
-static int write_buf(struct send_ctx *sctx, const void *buf, u32 len)
+int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
 {
         int ret;
         mm_segment_t old_fs;
@@ -387,8 +396,7 @@ static int write_buf(struct send_ctx *sctx, const void *buf, u32 len)
         set_fs(KERNEL_DS);
 
         while (pos < len) {
-                ret = vfs_write(sctx->send_filp, (char *)buf + pos, len - pos,
-                                &sctx->send_off);
+                ret = vfs_write(filp, (char *)buf + pos, len - pos, off);
                 /* TODO handle that correctly */
                 /*if (ret == -ERESTARTSYS) {
                         continue;
@@ -544,7 +552,8 @@ static int send_header(struct send_ctx *sctx)
         strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
         hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
 
-        return write_buf(sctx, &hdr, sizeof(hdr));
+        return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
+                                        &sctx->send_off);
 }
 
 /*
@@ -581,7 +590,8 @@ static int send_cmd(struct send_ctx *sctx)
         crc = crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
         hdr->crc = cpu_to_le32(crc);
 
-        ret = write_buf(sctx, sctx->send_buf, sctx->send_size);
+        ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
+                                        &sctx->send_off);
 
         sctx->total_send_size += sctx->send_size;
         sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
@@ -687,7 +697,8 @@ out:
  */
 static int get_inode_info(struct btrfs_root *root,
                           u64 ino, u64 *size, u64 *gen,
-                          u64 *mode, u64 *uid, u64 *gid)
+                          u64 *mode, u64 *uid, u64 *gid,
+                          u64 *rdev)
 {
         int ret;
         struct btrfs_inode_item *ii;
@@ -721,6 +732,8 @@ static int get_inode_info(struct btrfs_root *root,
                 *uid = btrfs_inode_uid(path->nodes[0], ii);
         if (gid)
                 *gid = btrfs_inode_gid(path->nodes[0], ii);
+        if (rdev)
+                *rdev = btrfs_inode_rdev(path->nodes[0], ii);
 
 out:
         btrfs_free_path(path);
@@ -852,7 +865,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
         struct extent_buffer *eb;
         struct btrfs_item *item;
         struct btrfs_dir_item *di;
-        struct btrfs_path *tmp_path = NULL;
         struct btrfs_key di_key;
         char *buf = NULL;
         char *buf2 = NULL;
@@ -874,12 +886,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
                 goto out;
         }
 
-        tmp_path = alloc_path_for_send();
-        if (!tmp_path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
         eb = path->nodes[0];
         slot = path->slots[0];
         item = btrfs_item_nr(eb, slot);
@@ -941,7 +947,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
         }
 
 out:
-        btrfs_free_path(tmp_path);
         if (buf_virtual)
                 vfree(buf);
         else
@@ -1026,12 +1031,12 @@ struct backref_ctx {
         u64 extent_len;
 
         /* Just to check for bugs in backref resolving */
-        int found_in_send_root;
+        int found_itself;
 };
 
 static int __clone_root_cmp_bsearch(const void *key, const void *elt)
 {
-        u64 root = (u64)key;
+        u64 root = (u64)(uintptr_t)key;
         struct clone_root *cr = (struct clone_root *)elt;
 
         if (root < cr->root->objectid)
@@ -1055,6 +1060,7 @@ static int __clone_root_cmp_sort(const void *e1, const void *e2)
 
 /*
  * Called for every backref that is found for the current extent.
+ * Results are collected in sctx->clone_roots->ino/offset/found_refs
  */
 static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
 {
@@ -1064,7 +1070,7 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
         u64 i_size;
 
         /* First check if the root is in the list of accepted clone sources */
-        found = bsearch((void *)root, bctx->sctx->clone_roots,
+        found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
                         bctx->sctx->clone_roots_cnt,
                         sizeof(struct clone_root),
                         __clone_root_cmp_bsearch);
@@ -1074,14 +1080,15 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
         if (found->root == bctx->sctx->send_root &&
             ino == bctx->cur_objectid &&
             offset == bctx->cur_offset) {
-                bctx->found_in_send_root = 1;
+                bctx->found_itself = 1;
         }
 
         /*
-         * There are inodes that have extents that lie behind it's i_size. Don't
+         * There are inodes that have extents that lie behind its i_size. Don't
          * accept clones from these extents.
          */
-        ret = get_inode_info(found->root, ino, &i_size, NULL, NULL, NULL, NULL);
+        ret = get_inode_info(found->root, ino, &i_size, NULL, NULL, NULL, NULL,
+                        NULL);
         if (ret < 0)
                 return ret;
 
@@ -1101,16 +1108,12 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
                  */
                 if (ino >= bctx->cur_objectid)
                         return 0;
-                /*if (ino > ctx->cur_objectid)
+#if 0
+                if (ino > bctx->cur_objectid)
                         return 0;
-                if (offset + ctx->extent_len > ctx->cur_offset)
-                        return 0;*/
-
-                bctx->found++;
-                found->found_refs++;
-                found->ino = ino;
-                found->offset = offset;
-                return 0;
+                if (offset + bctx->extent_len > bctx->cur_offset)
+                        return 0;
+#endif
         }
 
         bctx->found++;
@@ -1130,6 +1133,12 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
 }
 
 /*
+ * Given an inode, offset and extent item, it finds a good clone for a clone
+ * instruction. Returns -ENOENT when none could be found. The function makes
+ * sure that the returned clone is usable at the point where sending is at the
+ * moment. This means, that no clones are accepted which lie behind the current
+ * inode+offset.
+ *
  * path must point to the extent item when called.
  */
 static int find_extent_clone(struct send_ctx *sctx,
@@ -1141,20 +1150,29 @@ static int find_extent_clone(struct send_ctx *sctx,
         int ret;
         int extent_type;
         u64 logical;
+        u64 disk_byte;
         u64 num_bytes;
         u64 extent_item_pos;
+        u64 flags = 0;
         struct btrfs_file_extent_item *fi;
         struct extent_buffer *eb = path->nodes[0];
-        struct backref_ctx backref_ctx;
+        struct backref_ctx *backref_ctx = NULL;
         struct clone_root *cur_clone_root;
         struct btrfs_key found_key;
         struct btrfs_path *tmp_path;
+        int compressed;
         u32 i;
 
         tmp_path = alloc_path_for_send();
         if (!tmp_path)
                 return -ENOMEM;
 
+        backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_NOFS);
+        if (!backref_ctx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
         if (data_offset >= ino_size) {
                 /*
                  * There may be extents that lie behind the file's size.
@@ -1172,22 +1190,23 @@ static int find_extent_clone(struct send_ctx *sctx,
                 ret = -ENOENT;
                 goto out;
         }
+        compressed = btrfs_file_extent_compression(eb, fi);
 
         num_bytes = btrfs_file_extent_num_bytes(eb, fi);
-        logical = btrfs_file_extent_disk_bytenr(eb, fi);
-        if (logical == 0) {
+        disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+        if (disk_byte == 0) {
                 ret = -ENOENT;
                 goto out;
         }
-        logical += btrfs_file_extent_offset(eb, fi);
+        logical = disk_byte + btrfs_file_extent_offset(eb, fi);
 
-        ret = extent_from_logical(sctx->send_root->fs_info,
-                        logical, tmp_path, &found_key);
+        ret = extent_from_logical(sctx->send_root->fs_info, disk_byte, tmp_path,
+                                  &found_key, &flags);
         btrfs_release_path(tmp_path);
 
         if (ret < 0)
                 goto out;
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
                 ret = -EIO;
                 goto out;
         }
@@ -1202,12 +1221,12 @@ static int find_extent_clone(struct send_ctx *sctx,
                 cur_clone_root->found_refs = 0;
         }
 
-        backref_ctx.sctx = sctx;
-        backref_ctx.found = 0;
-        backref_ctx.cur_objectid = ino;
-        backref_ctx.cur_offset = data_offset;
-        backref_ctx.found_in_send_root = 0;
-        backref_ctx.extent_len = num_bytes;
+        backref_ctx->sctx = sctx;
+        backref_ctx->found = 0;
+        backref_ctx->cur_objectid = ino;
+        backref_ctx->cur_offset = data_offset;
+        backref_ctx->found_itself = 0;
+        backref_ctx->extent_len = num_bytes;
 
         /*
          * The last extent of a file may be too large due to page alignment.
@@ -1215,25 +1234,31 @@ static int find_extent_clone(struct send_ctx *sctx,
          * __iterate_backrefs work.
          */
         if (data_offset + num_bytes >= ino_size)
-                backref_ctx.extent_len = ino_size - data_offset;
+                backref_ctx->extent_len = ino_size - data_offset;
 
         /*
          * Now collect all backrefs.
          */
+        if (compressed == BTRFS_COMPRESS_NONE)
+                extent_item_pos = logical - found_key.objectid;
+        else
+                extent_item_pos = 0;
+
         extent_item_pos = logical - found_key.objectid;
         ret = iterate_extent_inodes(sctx->send_root->fs_info,
                                         found_key.objectid, extent_item_pos, 1,
-                                        __iterate_backrefs, &backref_ctx);
+                                        __iterate_backrefs, backref_ctx);
+
         if (ret < 0)
                 goto out;
 
-        if (!backref_ctx.found_in_send_root) {
+        if (!backref_ctx->found_itself) {
                 /* found a bug in backref code? */
                 ret = -EIO;
                 printk(KERN_ERR "btrfs: ERROR did not find backref in "
                                 "send_root. inode=%llu, offset=%llu, "
-                                "logical=%llu\n",
-                                ino, data_offset, logical);
+                                "disk_byte=%llu found extent=%llu\n",
+                                ino, data_offset, disk_byte, found_key.objectid);
                 goto out;
         }
 
@@ -1242,7 +1267,7 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
                 "num_bytes=%llu, logical=%llu\n",
                 data_offset, ino, num_bytes, logical);
 
-        if (!backref_ctx.found)
+        if (!backref_ctx->found)
                 verbose_printk("btrfs:    no clones found\n");
 
         cur_clone_root = NULL;
@@ -1253,7 +1278,6 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
                         else if (sctx->clone_roots[i].root == sctx->send_root)
                                 /* prefer clones from send_root over others */
                                 cur_clone_root = sctx->clone_roots + i;
-                        break;
                 }
 
         }
@@ -1267,6 +1291,7 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
 
 out:
         btrfs_free_path(tmp_path);
+        kfree(backref_ctx);
         return ret;
 }
 
@@ -1307,8 +1332,6 @@ static int read_symlink(struct send_ctx *sctx,
         len = btrfs_file_extent_inline_len(path->nodes[0], ei);
 
         ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
-        if (ret < 0)
-                goto out;
 
 out:
         btrfs_free_path(path);
@@ -1404,7 +1427,7 @@ static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
         u64 right_gen;
 
         ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0 && ret != -ENOENT)
                 goto out;
         left_ret = ret;
@@ -1413,16 +1436,16 @@ static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
                 right_ret = -ENOENT;
         } else {
                 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
-                                NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
                 if (ret < 0 && ret != -ENOENT)
                         goto out;
                 right_ret = ret;
         }
 
         if (!left_ret && !right_ret) {
-                if (left_gen == gen && right_gen == gen)
+                if (left_gen == gen && right_gen == gen) {
                         ret = inode_state_no_change;
-                else if (left_gen == gen) {
+                } else if (left_gen == gen) {
                         if (ino < sctx->send_progress)
                                 ret = inode_state_did_create;
                         else
@@ -1516,6 +1539,10 @@ out:
         return ret;
 }
 
+/*
+ * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir,
+ * generation of the parent dir and the name of the dir entry.
+ */
 static int get_first_ref(struct send_ctx *sctx,
                          struct btrfs_root *root, u64 ino,
                          u64 *dir, u64 *dir_gen, struct fs_path *name)
@@ -1557,7 +1584,7 @@ static int get_first_ref(struct send_ctx *sctx,
         btrfs_release_path(path);
 
         ret = get_inode_info(root, found_key.offset, NULL, dir_gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -1586,22 +1613,28 @@ static int is_first_ref(struct send_ctx *sctx,
         if (ret < 0)
                 goto out;
 
-        if (name_len != fs_path_len(tmp_name)) {
+        if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
                 ret = 0;
                 goto out;
         }
 
-        ret = memcmp(tmp_name->start, name, name_len);
-        if (ret)
-                ret = 0;
-        else
-                ret = 1;
+        ret = !memcmp(tmp_name->start, name, name_len);
 
 out:
         fs_path_free(sctx, tmp_name);
         return ret;
 }
 
+/*
+ * Used by process_recorded_refs to determine if a new ref would overwrite an
+ * already existing ref. In case it detects an overwrite, it returns the
+ * inode/gen in who_ino/who_gen.
+ * When an overwrite is detected, process_recorded_refs does proper orphanizing
+ * to make sure later references to the overwritten inode are possible.
+ * Orphanizing is however only required for the first ref of an inode.
+ * process_recorded_refs does an additional is_first_ref check to see if
+ * orphanizing is really required.
+ */
 static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
                               const char *name, int name_len,
                               u64 *who_ino, u64 *who_gen)
@@ -1626,9 +1659,14 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
                 goto out;
         }
 
+        /*
+         * Check if the overwritten ref was already processed. If yes, the ref
+         * was already unlinked/moved, so we can safely assume that we will not
+         * overwrite anything at this point in time.
+         */
         if (other_inode > sctx->send_progress) {
                 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
-                                who_gen, NULL, NULL, NULL);
+                                who_gen, NULL, NULL, NULL, NULL);
                 if (ret < 0)
                         goto out;
 
@@ -1642,6 +1680,13 @@ out:
         return ret;
 }
 
+/*
+ * Checks if the ref was overwritten by an already processed inode. This is
+ * used by __get_cur_name_and_parent to find out if the ref was orphanized and
+ * thus the orphan name needs be used.
+ * process_recorded_refs also uses it to avoid unlinking of refs that were
+ * overwritten.
+ */
 static int did_overwrite_ref(struct send_ctx *sctx,
                             u64 dir, u64 dir_gen,
                             u64 ino, u64 ino_gen,
@@ -1671,7 +1716,7 @@ static int did_overwrite_ref(struct send_ctx *sctx,
         }
 
         ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -1690,6 +1735,11 @@ out:
         return ret;
 }
 
+/*
+ * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
+ * that got overwritten. This is used by process_recorded_refs to determine
+ * if it has to use the path as returned by get_cur_path or the orphan name.
+ */
 static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
 {
         int ret = 0;
@@ -1710,39 +1760,40 @@ static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
 
         ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
                         name->start, fs_path_len(name));
-        if (ret < 0)
-                goto out;
 
 out:
         fs_path_free(sctx, name);
         return ret;
 }
 
+/*
+ * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit,
+ * so we need to do some special handling in case we have clashes. This function
+ * takes care of this with the help of name_cache_entry::radix_list.
+ * In case of error, nce is kfreed.
+ */
 static int name_cache_insert(struct send_ctx *sctx,
                              struct name_cache_entry *nce)
 {
         int ret = 0;
-        struct name_cache_entry **ncea;
-
-        ncea = radix_tree_lookup(&sctx->name_cache, nce->ino);
-        if (ncea) {
-                if (!ncea[0])
-                        ncea[0] = nce;
-                else if (!ncea[1])
-                        ncea[1] = nce;
-                else
-                        BUG();
-        } else {
-                ncea = kmalloc(sizeof(void *) * 2, GFP_NOFS);
-                if (!ncea)
+        struct list_head *nce_head;
+
+        nce_head = radix_tree_lookup(&sctx->name_cache,
+                        (unsigned long)nce->ino);
+        if (!nce_head) {
+                nce_head = kmalloc(sizeof(*nce_head), GFP_NOFS);
+                if (!nce_head)
                         return -ENOMEM;
+                INIT_LIST_HEAD(nce_head);
 
-                ncea[0] = nce;
-                ncea[1] = NULL;
-                ret = radix_tree_insert(&sctx->name_cache, nce->ino, ncea);
-                if (ret < 0)
+                ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
+                if (ret < 0) {
+                        kfree(nce_head);
+                        kfree(nce);
                         return ret;
+                }
         }
+        list_add_tail(&nce->radix_list, nce_head);
         list_add_tail(&nce->list, &sctx->name_cache_list);
         sctx->name_cache_size++;
 
@@ -1752,50 +1803,52 @@ static int name_cache_insert(struct send_ctx *sctx,
 static void name_cache_delete(struct send_ctx *sctx,
                               struct name_cache_entry *nce)
 {
-        struct name_cache_entry **ncea;
-
-        ncea = radix_tree_lookup(&sctx->name_cache, nce->ino);
-        BUG_ON(!ncea);
-
-        if (ncea[0] == nce)
-                ncea[0] = NULL;
-        else if (ncea[1] == nce)
-                ncea[1] = NULL;
-        else
-                BUG();
+        struct list_head *nce_head;
 
-        if (!ncea[0] && !ncea[1]) {
-                radix_tree_delete(&sctx->name_cache, nce->ino);
-                kfree(ncea);
-        }
+        nce_head = radix_tree_lookup(&sctx->name_cache,
+                        (unsigned long)nce->ino);
+        BUG_ON(!nce_head);
 
+        list_del(&nce->radix_list);
         list_del(&nce->list);
-
         sctx->name_cache_size--;
+
+        if (list_empty(nce_head)) {
+                radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
+                kfree(nce_head);
+        }
 }
 
 static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
                                                     u64 ino, u64 gen)
 {
-        struct name_cache_entry **ncea;
+        struct list_head *nce_head;
+        struct name_cache_entry *cur;
 
-        ncea = radix_tree_lookup(&sctx->name_cache, ino);
-        if (!ncea)
+        nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
+        if (!nce_head)
                 return NULL;
 
-        if (ncea[0] && ncea[0]->gen == gen)
-                return ncea[0];
-        else if (ncea[1] && ncea[1]->gen == gen)
-                return ncea[1];
+        list_for_each_entry(cur, nce_head, radix_list) {
+                if (cur->ino == ino && cur->gen == gen)
+                        return cur;
+        }
         return NULL;
 }
 
+/*
+ * Removes the entry from the list and adds it back to the end. This marks the
+ * entry as recently used so that name_cache_clean_unused does not remove it.
+ */
 static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
 {
         list_del(&nce->list);
         list_add_tail(&nce->list, &sctx->name_cache_list);
 }
 
+/*
+ * Remove some entries from the beginning of name_cache_list.
+ */
 static void name_cache_clean_unused(struct send_ctx *sctx)
 {
         struct name_cache_entry *nce;
@@ -1814,13 +1867,23 @@ static void name_cache_clean_unused(struct send_ctx *sctx)
 static void name_cache_free(struct send_ctx *sctx)
 {
         struct name_cache_entry *nce;
-        struct name_cache_entry *tmp;
 
-        list_for_each_entry_safe(nce, tmp, &sctx->name_cache_list, list) {
+        while (!list_empty(&sctx->name_cache_list)) {
+                nce = list_entry(sctx->name_cache_list.next,
+                                struct name_cache_entry, list);
                 name_cache_delete(sctx, nce);
+                kfree(nce);
         }
 }
 
+/*
+ * Used by get_cur_path for each ref up to the root.
+ * Returns 0 if it succeeded.
+ * Returns 1 if the inode is not existent or got overwritten. In that case, the
+ * name is an orphan name. This instructs get_cur_path to stop iterating. If 1
+ * is returned, parent_ino/parent_gen are not guaranteed to be valid.
+ * Returns <0 in case of error.
+ */
 static int __get_cur_name_and_parent(struct send_ctx *sctx,
                                      u64 ino, u64 gen,
                                      u64 *parent_ino,
@@ -1832,6 +1895,11 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         struct btrfs_path *path = NULL;
         struct name_cache_entry *nce = NULL;
 
+        /*
+         * First check if we already did a call to this function with the same
+         * ino/gen. If yes, check if the cache entry is still up-to-date. If yes
+         * return the cached result.
+         */
         nce = name_cache_search(sctx, ino, gen);
         if (nce) {
                 if (ino < sctx->send_progress && nce->need_later_update) {
@@ -1854,6 +1922,11 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         if (!path)
                 return -ENOMEM;
 
+        /*
+         * If the inode is not existent yet, add the orphan name and return 1.
+         * This should only happen for the parent dir that we determine in
+         * __record_new_ref
+         */
         ret = is_inode_existent(sctx, ino, gen);
         if (ret < 0)
                 goto out;
@@ -1866,6 +1939,10 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
                 goto out_cache;
         }
 
+        /*
+         * Depending on whether the inode was already processed or not, use
+         * send_root or parent_root for ref lookup.
+         */
         if (ino < sctx->send_progress)
                 ret = get_first_ref(sctx, sctx->send_root, ino,
                                 parent_ino, parent_gen, dest);
@@ -1875,6 +1952,10 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         if (ret < 0)
                 goto out;
 
+        /*
+         * Check if the ref was overwritten by an inode's ref that was processed
+         * earlier. If yes, treat as orphan and return 1.
+         */
         ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
                         dest->start, dest->end - dest->start);
         if (ret < 0)
@@ -1888,6 +1969,9 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         }
 
 out_cache:
+        /*
+         * Store the result of the lookup in the name cache.
+         */
         nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_NOFS);
         if (!nce) {
                 ret = -ENOMEM;
@@ -1901,7 +1985,6 @@ out_cache:
         nce->name_len = fs_path_len(dest);
         nce->ret = ret;
         strcpy(nce->name, dest->start);
-        memset(&nce->use_list, 0, sizeof(nce->use_list));
 
         if (ino < sctx->send_progress)
                 nce->need_later_update = 0;
@@ -2107,9 +2190,6 @@ static int send_subvol_begin(struct send_ctx *sctx)
         read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
         btrfs_release_path(path);
 
-        if (ret < 0)
-                goto out;
-
         if (parent_root) {
                 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
                 if (ret < 0)
@@ -2276,7 +2356,7 @@ verbose_printk("btrfs: send_utimes %llu\n", ino);
                         btrfs_inode_mtime(ii));
         TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb,
                         btrfs_inode_ctime(ii));
-        /* TODO otime? */
+        /* TODO Add otime support when the otime patches get into upstream */
 
         ret = send_cmd(sctx);
 
@@ -2292,39 +2372,39 @@ out:
  * a valid path yet because we did not process the refs yet. So, the inode
  * is created as orphan.
  */
-static int send_create_inode(struct send_ctx *sctx, struct btrfs_path *path,
-                             struct btrfs_key *key)
+static int send_create_inode(struct send_ctx *sctx, u64 ino)
 {
         int ret = 0;
-        struct extent_buffer *eb = path->nodes[0];
-        struct btrfs_inode_item *ii;
         struct fs_path *p;
-        int slot = path->slots[0];
         int cmd;
+        u64 gen;
         u64 mode;
+        u64 rdev;
 
-verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
+verbose_printk("btrfs: send_create_inode %llu\n", ino);
 
         p = fs_path_alloc(sctx);
         if (!p)
                 return -ENOMEM;
 
-        ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
-        mode = btrfs_inode_mode(eb, ii);
+        ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode, NULL,
+                        NULL, &rdev);
+        if (ret < 0)
+                goto out;
 
-        if (S_ISREG(mode))
+        if (S_ISREG(mode)) {
                 cmd = BTRFS_SEND_C_MKFILE;
-        else if (S_ISDIR(mode))
+        } else if (S_ISDIR(mode)) {
                 cmd = BTRFS_SEND_C_MKDIR;
-        else if (S_ISLNK(mode))
+        } else if (S_ISLNK(mode)) {
                 cmd = BTRFS_SEND_C_SYMLINK;
-        else if (S_ISCHR(mode) || S_ISBLK(mode))
+        } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
                 cmd = BTRFS_SEND_C_MKNOD;
-        else if (S_ISFIFO(mode))
+        } else if (S_ISFIFO(mode)) {
                 cmd = BTRFS_SEND_C_MKFIFO;
-        else if (S_ISSOCK(mode))
+        } else if (S_ISSOCK(mode)) {
                 cmd = BTRFS_SEND_C_MKSOCK;
-        else {
+        } else {
                 printk(KERN_WARNING "btrfs: unexpected inode type %o",
                                 (int)(mode & S_IFMT));
                 ret = -ENOTSUPP;
@@ -2335,22 +2415,22 @@ verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
         if (ret < 0)
                 goto out;
 
-        ret = gen_unique_name(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
+        ret = gen_unique_name(sctx, ino, gen, p);
         if (ret < 0)
                 goto out;
 
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
-        TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, sctx->cur_ino);
+        TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
 
         if (S_ISLNK(mode)) {
                 fs_path_reset(p);
-                ret = read_symlink(sctx, sctx->send_root, sctx->cur_ino, p);
+                ret = read_symlink(sctx, sctx->send_root, ino, p);
                 if (ret < 0)
                         goto out;
                 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
         } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
                    S_ISFIFO(mode) || S_ISSOCK(mode)) {
-                TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, btrfs_inode_rdev(eb, ii));
+                TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, rdev);
         }
 
         ret = send_cmd(sctx);
@@ -2364,6 +2444,92 @@ out:
         return ret;
 }
 
+/*
+ * We need some special handling for inodes that get processed before the parent
+ * directory got created. See process_recorded_refs for details.
+ * This function does the check if we already created the dir out of order.
+ */
+static int did_create_dir(struct send_ctx *sctx, u64 dir)
+{
+        int ret = 0;
+        struct btrfs_path *path = NULL;
+        struct btrfs_key key;
+        struct btrfs_key found_key;
+        struct btrfs_key di_key;
+        struct extent_buffer *eb;
+        struct btrfs_dir_item *di;
+        int slot;
+
+        path = alloc_path_for_send();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        key.objectid = dir;
+        key.type = BTRFS_DIR_INDEX_KEY;
+        key.offset = 0;
+        while (1) {
+                ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
+                                1, 0);
+                if (ret < 0)
+                        goto out;
+                if (!ret) {
+                        eb = path->nodes[0];
+                        slot = path->slots[0];
+                        btrfs_item_key_to_cpu(eb, &found_key, slot);
+                }
+                if (ret || found_key.objectid != key.objectid ||
+                    found_key.type != key.type) {
+                        ret = 0;
+                        goto out;
+                }
+
+                di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
+                btrfs_dir_item_key_to_cpu(eb, di, &di_key);
+
+                if (di_key.objectid < sctx->send_progress) {
+                        ret = 1;
+                        goto out;
+                }
+
+                key.offset = found_key.offset + 1;
+                btrfs_release_path(path);
+        }
+
+out:
+        btrfs_free_path(path);
+        return ret;
+}
+
+/*
+ * Only creates the inode if it is:
+ * 1. Not a directory
+ * 2. Or a directory which was not created already due to out of order
+ *    directories. See did_create_dir and process_recorded_refs for details.
+ */
+static int send_create_inode_if_needed(struct send_ctx *sctx)
+{
+        int ret;
+
+        if (S_ISDIR(sctx->cur_inode_mode)) {
+                ret = did_create_dir(sctx, sctx->cur_ino);
+                if (ret < 0)
+                        goto out;
+                if (ret) {
+                        ret = 0;
+                        goto out;
+                }
+        }
+
+        ret = send_create_inode(sctx, sctx->cur_ino);
+        if (ret < 0)
+                goto out;
+
+out:
+        return ret;
+}
+
 struct recorded_ref {
         struct list_head list;
         char *dir_path;
@@ -2416,13 +2582,13 @@ static int record_ref(struct list_head *head, u64 dir,
 static void __free_recorded_refs(struct send_ctx *sctx, struct list_head *head)
 {
         struct recorded_ref *cur;
-        struct recorded_ref *tmp;
 
-        list_for_each_entry_safe(cur, tmp, head, list) {
+        while (!list_empty(head)) {
+                cur = list_entry(head->next, struct recorded_ref, list);
                 fs_path_free(sctx, cur->full_path);
+                list_del(&cur->list);
                 kfree(cur);
         }
-        INIT_LIST_HEAD(head);
 }
 
 static void free_recorded_refs(struct send_ctx *sctx)
@@ -2432,7 +2598,7 @@ static void free_recorded_refs(struct send_ctx *sctx)
 }
 
 /*
- * Renames/moves a file/dir to it's orphan name. Used when the first
+ * Renames/moves a file/dir to its orphan name. Used when the first
  * ref of an unprocessed inode gets overwritten and for all non empty
  * directories.
  */
@@ -2472,6 +2638,12 @@ static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 send_progress)
         struct btrfs_key loc;
         struct btrfs_dir_item *di;
 
+        /*
+         * Don't try to rmdir the top/root subvolume dir.
+         */
+        if (dir == BTRFS_FIRST_FREE_OBJECTID)
+                return 0;
+
         path = alloc_path_for_send();
         if (!path)
                 return -ENOMEM;
@@ -2513,160 +2685,6 @@ out:
         return ret;
 }
 
-struct finish_unordered_dir_ctx {
-        struct send_ctx *sctx;
-        struct fs_path *cur_path;
-        struct fs_path *dir_path;
-        u64 dir_ino;
-        int need_delete;
-        int delete_pass;
-};
-
-int __finish_unordered_dir(int num, struct btrfs_key *di_key,
-                           const char *name, int name_len,
-                           const char *data, int data_len,
-                           u8 type, void *ctx)
-{
-        int ret = 0;
-        struct finish_unordered_dir_ctx *fctx = ctx;
-        struct send_ctx *sctx = fctx->sctx;
-        u64 di_gen;
-        u64 di_mode;
-        int is_orphan = 0;
-
-        if (di_key->objectid >= fctx->dir_ino)
-                goto out;
-
-        fs_path_reset(fctx->cur_path);
-
-        ret = get_inode_info(sctx->send_root, di_key->objectid,
-                        NULL, &di_gen, &di_mode, NULL, NULL);
-        if (ret < 0)
-                goto out;
-
-        ret = is_first_ref(sctx, sctx->send_root, di_key->objectid,
-                        fctx->dir_ino, name, name_len);
-        if (ret < 0)
-                goto out;
-        if (ret) {
-                is_orphan = 1;
-                ret = gen_unique_name(sctx, di_key->objectid, di_gen,
-                                fctx->cur_path);
-        } else {
-                ret = get_cur_path(sctx, di_key->objectid, di_gen,
-                                fctx->cur_path);
-        }
-        if (ret < 0)
-                goto out;
-
-        ret = fs_path_add(fctx->dir_path, name, name_len);
-        if (ret < 0)
-                goto out;
-
-        if (!fctx->delete_pass) {
-                if (S_ISDIR(di_mode)) {
-                        ret = send_rename(sctx, fctx->cur_path,
-                                        fctx->dir_path);
-                } else {
-                        ret = send_link(sctx, fctx->dir_path,
-                                        fctx->cur_path);
-                        if (is_orphan)
-                                fctx->need_delete = 1;
-                }
-        } else if (!S_ISDIR(di_mode)) {
-                ret = send_unlink(sctx, fctx->cur_path);
-        } else {
-                ret = 0;
-        }
-
-        fs_path_remove(fctx->dir_path);
-
-out:
-        return ret;
-}
-
-/*
- * Go through all dir items and see if we find refs which could not be created
- * in the past because the dir did not exist at that time.
- */
-static int finish_outoforder_dir(struct send_ctx *sctx, u64 dir, u64 dir_gen)
-{
-        int ret = 0;
-        struct btrfs_path *path = NULL;
-        struct btrfs_key key;
-        struct btrfs_key found_key;
-        struct extent_buffer *eb;
-        struct finish_unordered_dir_ctx fctx;
-        int slot;
-
-        path = alloc_path_for_send();
-        if (!path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memset(&fctx, 0, sizeof(fctx));
-        fctx.sctx = sctx;
-        fctx.cur_path = fs_path_alloc(sctx);
-        fctx.dir_path = fs_path_alloc(sctx);
-        if (!fctx.cur_path || !fctx.dir_path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        fctx.dir_ino = dir;
-
-        ret = get_cur_path(sctx, dir, dir_gen, fctx.dir_path);
-        if (ret < 0)
-                goto out;
-
-        /*
-         * We do two passes. The first links in the new refs and the second
-         * deletes orphans if required. Deletion of orphans is not required for
-         * directory inodes, as we always have only one ref and use rename
-         * instead of link for those.
-         */
-
-again:
-        key.objectid = dir;
-        key.type = BTRFS_DIR_ITEM_KEY;
-        key.offset = 0;
-        while (1) {
-                ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
-                                1, 0);
-                if (ret < 0)
-                        goto out;
-                eb = path->nodes[0];
-                slot = path->slots[0];
-                btrfs_item_key_to_cpu(eb, &found_key, slot);
-
-                if (found_key.objectid != key.objectid ||
-                    found_key.type != key.type) {
-                        btrfs_release_path(path);
-                        break;
-                }
-
-                ret = iterate_dir_item(sctx, sctx->send_root, path,
-                                &found_key, __finish_unordered_dir,
-                                &fctx);
-                if (ret < 0)
-                        goto out;
-
-                key.offset = found_key.offset + 1;
-                btrfs_release_path(path);
-        }
-
-        if (!fctx.delete_pass && fctx.need_delete) {
-                fctx.delete_pass = 1;
-                goto again;
-        }
-
-out:
-        btrfs_free_path(path);
-        fs_path_free(sctx, fctx.cur_path);
-        fs_path_free(sctx, fctx.dir_path);
-        return ret;
-}
-
 /*
  * This does all the move/link/unlink/rmdir magic.
  */
@@ -2674,6 +2692,7 @@ static int process_recorded_refs(struct send_ctx *sctx)
 {
         int ret = 0;
         struct recorded_ref *cur;
+        struct recorded_ref *cur2;
         struct ulist *check_dirs = NULL;
         struct ulist_iterator uit;
         struct ulist_node *un;
@@ -2685,6 +2704,12 @@ static int process_recorded_refs(struct send_ctx *sctx)
 
 verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
 
+        /*
+         * This should never happen as the root dir always has the same ref
+         * which is always '..'
+         */
+        BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
+
         valid_path = fs_path_alloc(sctx);
         if (!valid_path) {
                 ret = -ENOMEM;
@@ -2731,6 +2756,46 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
 
         list_for_each_entry(cur, &sctx->new_refs, list) {
                 /*
+                 * We may have refs where the parent directory does not exist
+                 * yet. This happens if the parent directories inum is higher
+                 * the the current inum. To handle this case, we create the
+                 * parent directory out of order. But we need to check if this
+                 * did already happen before due to other refs in the same dir.
+                 */
+                ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
+                if (ret < 0)
+                        goto out;
+                if (ret == inode_state_will_create) {
+                        ret = 0;
+                        /*
+                         * First check if any of the current inodes refs did
+                         * already create the dir.
+                         */
+                        list_for_each_entry(cur2, &sctx->new_refs, list) {
+                                if (cur == cur2)
+                                        break;
+                                if (cur2->dir == cur->dir) {
+                                        ret = 1;
+                                        break;
+                                }
+                        }
+
+                        /*
+                         * If that did not happen, check if a previous inode
+                         * did already create the dir.
+                         */
+                        if (!ret)
+                                ret = did_create_dir(sctx, cur->dir);
+                        if (ret < 0)
+                                goto out;
+                        if (!ret) {
+                                ret = send_create_inode(sctx, cur->dir);
+                                if (ret < 0)
+                                        goto out;
+                        }
+                }
+
+                /*
                  * Check if this new ref would overwrite the first ref of
                  * another unprocessed inode. If yes, orphanize the
                  * overwritten inode. If we find an overwritten ref that is
@@ -2764,7 +2829,7 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                  * inode, move it and update valid_path. If not, link or move
                  * it depending on the inode mode.
                  */
-                if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+                if (is_orphan) {
                         ret = send_rename(sctx, valid_path, cur->full_path);
                         if (ret < 0)
                                 goto out;
@@ -2827,6 +2892,17 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                         if (ret < 0)
                                 goto out;
                 }
+        } else if (S_ISDIR(sctx->cur_inode_mode) &&
+                   !list_empty(&sctx->deleted_refs)) {
+                /*
+                 * We have a moved dir. Add the old parent to check_dirs
+                 */
+                cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
+                                list);
+                ret = ulist_add(check_dirs, cur->dir, cur->dir_gen,
+                                GFP_NOFS);
+                if (ret < 0)
+                        goto out;
         } else if (!S_ISDIR(sctx->cur_inode_mode)) {
                 /*
                  * We have a non dir inode. Go through all deleted refs and
@@ -2840,35 +2916,9 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                         if (ret < 0)
                                 goto out;
                         if (!ret) {
-                                /*
-                                 * In case the inode was moved to a directory
-                                 * that was not created yet (see
-                                 * __record_new_ref), we can not unlink the ref
-                                 * as it will be needed later when the parent
-                                 * directory is created, so that we can move in
-                                 * the inode to the new dir.
-                                 */
-                                if (!is_orphan &&
-                                    sctx->cur_inode_first_ref_orphan) {
-                                        ret = orphanize_inode(sctx,
-                                                        sctx->cur_ino,
-                                                        sctx->cur_inode_gen,
-                                                        cur->full_path);
-                                        if (ret < 0)
-                                                goto out;
-                                        ret = gen_unique_name(sctx,
-                                                        sctx->cur_ino,
-                                                        sctx->cur_inode_gen,
-                                                        valid_path);
-                                        if (ret < 0)
-                                                goto out;
-                                        is_orphan = 1;
-
-                                } else {
-                                        ret = send_unlink(sctx, cur->full_path);
-                                        if (ret < 0)
-                                                goto out;
-                                }
+                                ret = send_unlink(sctx, cur->full_path);
+                                if (ret < 0)
+                                        goto out;
                         }
                         ret = ulist_add(check_dirs, cur->dir, cur->dir_gen,
                                         GFP_NOFS);
@@ -2880,12 +2930,11 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                  * If the inode is still orphan, unlink the orphan. This may
                  * happen when a previous inode did overwrite the first ref
                  * of this inode and no new refs were added for the current
-                 * inode.
-                 * We can however not delete the orphan in case the inode relies
-                 * in a directory that was not created yet (see
-                 * __record_new_ref)
+                 * inode. Unlinking does not mean that the inode is deleted in
+                 * all cases. There may still be links to this inode in other
+                 * places.
                  */
-                if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+                if (is_orphan) {
                         ret = send_unlink(sctx, valid_path);
                         if (ret < 0)
                                 goto out;
@@ -2900,6 +2949,11 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
          */
         ULIST_ITER_INIT(&uit);
         while ((un = ulist_next(check_dirs, &uit))) {
+                /*
+                 * In case we had refs into dirs that were not processed yet,
+                 * we don't need to do the utime and rmdir logic for these dirs.
+                 * The dir will be processed later.
+                 */
                 if (un->val > sctx->cur_ino)
                         continue;
 
@@ -2929,25 +2983,6 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                 }
         }
 
-        /*
-         * Current inode is now at it's new position, so we must increase
-         * send_progress
-         */
-        sctx->send_progress = sctx->cur_ino + 1;
-
-        /*
-         * We may have a directory here that has pending refs which could not
-         * be created before (because the dir did not exist before, see
-         * __record_new_ref). finish_outoforder_dir will link/move the pending
-         * refs.
-         */
-        if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_new) {
-                ret = finish_outoforder_dir(sctx, sctx->cur_ino,
-                                sctx->cur_inode_gen);
-                if (ret < 0)
-                        goto out;
-        }
-
         ret = 0;
 
 out:
@@ -2971,34 +3006,9 @@ static int __record_new_ref(int num, u64 dir, int index,
                 return -ENOMEM;
 
         ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL, NULL,
-                        NULL);
-        if (ret < 0)
-                goto out;
-
-        /*
-         * The parent may be non-existent at this point in time. This happens
-         * if the ino of the parent dir is higher then the current ino. In this
-         * case, we can not process this ref until the parent dir is finally
-         * created. If we reach the parent dir later, process_recorded_refs
-         * will go through all dir items and process the refs that could not be
-         * processed before. In case this is the first ref, we set
-         * cur_inode_first_ref_orphan to 1 to inform process_recorded_refs to
-         * keep an orphan of the inode so that it later can be used for
-         * link/move
-         */
-        ret = is_inode_existent(sctx, dir, gen);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
-        if (!ret) {
-                ret = is_first_ref(sctx, sctx->send_root, sctx->cur_ino, dir,
-                                name->start, fs_path_len(name));
-                if (ret < 0)
-                        goto out;
-                if (ret)
-                        sctx->cur_inode_first_ref_orphan = 1;
-                ret = 0;
-                goto out;
-        }
 
         ret = get_cur_path(sctx, dir, gen, p);
         if (ret < 0)
@@ -3029,7 +3039,7 @@ static int __record_deleted_ref(int num, u64 dir, int index,
                 return -ENOMEM;
 
         ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -3206,33 +3216,28 @@ static int process_all_refs(struct send_ctx *sctx,
         key.offset = 0;
         while (1) {
                 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
-                if (ret < 0) {
-                        btrfs_release_path(path);
+                if (ret < 0)
                         goto out;
-                }
-                if (ret) {
-                        btrfs_release_path(path);
+                if (ret)
                         break;
-                }
 
                 eb = path->nodes[0];
                 slot = path->slots[0];
                 btrfs_item_key_to_cpu(eb, &found_key, slot);
 
                 if (found_key.objectid != key.objectid ||
-                    found_key.type != key.type) {
-                        btrfs_release_path(path);
+                    found_key.type != key.type)
                         break;
-                }
 
-                ret = iterate_inode_ref(sctx, sctx->parent_root, path,
-                                &found_key, 0, cb, sctx);
+                ret = iterate_inode_ref(sctx, root, path, &found_key, 0, cb,
+                                sctx);
                 btrfs_release_path(path);
                 if (ret < 0)
                         goto out;
 
                 key.offset = found_key.offset + 1;
         }
+        btrfs_release_path(path);
 
         ret = process_recorded_refs(sctx);
 
@@ -3555,7 +3560,7 @@ static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
         int ret = 0;
         struct fs_path *p;
         loff_t pos = offset;
-        int readed = 0;
+        int num_read = 0;
         mm_segment_t old_fs;
 
         p = fs_path_alloc(sctx);
@@ -3580,8 +3585,8 @@ verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
         ret = vfs_read(sctx->cur_inode_filp, sctx->read_buf, len, &pos);
         if (ret < 0)
                 goto out;
-        readed = ret;
-        if (!readed)
+        num_read = ret;
+        if (!num_read)
                 goto out;
 
         ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
@@ -3594,7 +3599,7 @@ verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
 
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
-        TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, readed);
+        TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
 
         ret = send_cmd(sctx);
 
@@ -3604,7 +3609,7 @@ out:
         set_fs(old_fs);
         if (ret < 0)
                 return ret;
-        return readed;
+        return num_read;
 }
 
 /*
@@ -3615,7 +3620,6 @@ static int send_clone(struct send_ctx *sctx,
                       struct clone_root *clone_root)
 {
         int ret = 0;
-        struct btrfs_root *clone_root2 = clone_root->root;
         struct fs_path *p;
         u64 gen;
 
@@ -3640,22 +3644,23 @@ verbose_printk("btrfs: send_clone offset=%llu, len=%d, clone_root=%llu, "
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
 
-        if (clone_root2 == sctx->send_root) {
+        if (clone_root->root == sctx->send_root) {
                 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
-                                &gen, NULL, NULL, NULL);
+                                &gen, NULL, NULL, NULL, NULL);
                 if (ret < 0)
                         goto out;
                 ret = get_cur_path(sctx, clone_root->ino, gen, p);
         } else {
-                ret = get_inode_path(sctx, clone_root2, clone_root->ino, p);
+                ret = get_inode_path(sctx, clone_root->root,
+                                clone_root->ino, p);
         }
         if (ret < 0)
                 goto out;
 
         TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
-                        clone_root2->root_item.uuid);
+                        clone_root->root->root_item.uuid);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
-                        clone_root2->root_item.ctransid);
+                        clone_root->root->root_item.ctransid);
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
                         clone_root->offset);
@@ -3684,10 +3689,17 @@ static int send_write_or_clone(struct send_ctx *sctx,
         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
                         struct btrfs_file_extent_item);
         type = btrfs_file_extent_type(path->nodes[0], ei);
-        if (type == BTRFS_FILE_EXTENT_INLINE)
+        if (type == BTRFS_FILE_EXTENT_INLINE) {
                 len = btrfs_file_extent_inline_len(path->nodes[0], ei);
-        else
+                /*
+                 * it is possible the inline item won't cover the whole page,
+                 * but there may be items after this page.  Make
+                 * sure to send the whole thing
+                 */
+                len = PAGE_CACHE_ALIGN(len);
+        } else {
                 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
+        }
 
         if (offset + len > sctx->cur_inode_size)
                 len = sctx->cur_inode_size - offset;
@@ -3735,6 +3747,8 @@ static int is_extent_unchanged(struct send_ctx *sctx,
         u64 left_offset_fixed;
         u64 left_len;
         u64 right_len;
+        u64 left_gen;
+        u64 right_gen;
         u8 left_type;
         u8 right_type;
 
@@ -3744,17 +3758,17 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 
         eb = left_path->nodes[0];
         slot = left_path->slots[0];
-
         ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
         left_type = btrfs_file_extent_type(eb, ei);
-        left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
-        left_len = btrfs_file_extent_num_bytes(eb, ei);
-        left_offset = btrfs_file_extent_offset(eb, ei);
 
         if (left_type != BTRFS_FILE_EXTENT_REG) {
                 ret = 0;
                 goto out;
         }
+        left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
+        left_len = btrfs_file_extent_num_bytes(eb, ei);
+        left_offset = btrfs_file_extent_offset(eb, ei);
+        left_gen = btrfs_file_extent_generation(eb, ei);
 
         /*
          * Following comments will refer to these graphics. L is the left
@@ -3810,6 +3824,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                 right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
                 right_len = btrfs_file_extent_num_bytes(eb, ei);
                 right_offset = btrfs_file_extent_offset(eb, ei);
+                right_gen = btrfs_file_extent_generation(eb, ei);
 
                 if (right_type != BTRFS_FILE_EXTENT_REG) {
                         ret = 0;
@@ -3820,7 +3835,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                  * Are we at extent 8? If yes, we know the extent is changed.
                  * This may only happen on the first iteration.
                  */
-                if (found_key.offset + right_len < ekey->offset) {
+                if (found_key.offset + right_len <= ekey->offset) {
                         ret = 0;
                         goto out;
                 }
@@ -3837,8 +3852,9 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                 /*
                  * Check if we have the same extent.
                  */
-                if (left_disknr + left_offset_fixed !=
-                                right_disknr + right_offset) {
+                if (left_disknr != right_disknr ||
+                    left_offset_fixed != right_offset ||
+                    left_gen != right_gen) {
                         ret = 0;
                         goto out;
                 }
@@ -3977,6 +3993,15 @@ static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end)
                 goto out;
 
         ret = process_recorded_refs(sctx);
+        if (ret < 0)
+                goto out;
+
+        /*
+         * We have processed the refs and thus need to advance send_progress.
+         * Now, calls to get_cur_xxx will take the updated refs of the current
+         * inode into account.
+         */
+        sctx->send_progress = sctx->cur_ino + 1;
 
 out:
         return ret;
@@ -4004,7 +4029,7 @@ static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
                 goto out;
 
         ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
-                        &left_mode, &left_uid, &left_gid);
+                        &left_mode, &left_uid, &left_gid, NULL);
         if (ret < 0)
                 goto out;
 
@@ -4015,7 +4040,7 @@ static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
                 } else {
                         ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
                                         NULL, NULL, &right_mode, &right_uid,
-                                        &right_gid);
+                                        &right_gid, NULL);
                         if (ret < 0)
                                 goto out;
 
@@ -4074,7 +4099,12 @@ static int changed_inode(struct send_ctx *sctx,
 
         sctx->cur_ino = key->objectid;
         sctx->cur_inode_new_gen = 0;
-        sctx->cur_inode_first_ref_orphan = 0;
+
+        /*
+         * Set send_progress to current inode. This will tell all get_cur_xxx
+         * functions that the current inode's refs are not updated yet. Later,
+         * when process_recorded_refs is finished, it is set to cur_ino + 1.
+         */
         sctx->send_progress = sctx->cur_ino;
 
         if (result == BTRFS_COMPARE_TREE_NEW ||
@@ -4098,7 +4128,14 @@ static int changed_inode(struct send_ctx *sctx,
 
                 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
                                 right_ii);
-                if (left_gen != right_gen)
+
+                /*
+                 * The cur_ino = root dir case is special here. We can't treat
+                 * the inode as deleted+reused because it would generate a
+                 * stream that tries to delete/mkdir the root dir.
+                 */
+                if (left_gen != right_gen &&
+                    sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
                         sctx->cur_inode_new_gen = 1;
         }
 
@@ -4111,8 +4148,7 @@ static int changed_inode(struct send_ctx *sctx,
                 sctx->cur_inode_mode = btrfs_inode_mode(
                                 sctx->left_path->nodes[0], left_ii);
                 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
-                        ret = send_create_inode(sctx, sctx->left_path,
-                                        sctx->cmp_key);
+                        ret = send_create_inode_if_needed(sctx);
         } else if (result == BTRFS_COMPARE_TREE_DELETED) {
                 sctx->cur_inode_gen = right_gen;
                 sctx->cur_inode_new = 0;
@@ -4122,7 +4158,17 @@ static int changed_inode(struct send_ctx *sctx,
                 sctx->cur_inode_mode = btrfs_inode_mode(
                                 sctx->right_path->nodes[0], right_ii);
         } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
+                /*
+                 * We need to do some special handling in case the inode was
+                 * reported as changed with a changed generation number. This
+                 * means that the original inode was deleted and new inode
+                 * reused the same inum. So we have to treat the old inode as
+                 * deleted and the new one as new.
+                 */
                 if (sctx->cur_inode_new_gen) {
+                        /*
+                         * First, process the inode as if it was deleted.
+                         */
                         sctx->cur_inode_gen = right_gen;
                         sctx->cur_inode_new = 0;
                         sctx->cur_inode_deleted = 1;
@@ -4135,6 +4181,9 @@ static int changed_inode(struct send_ctx *sctx,
                         if (ret < 0)
                                 goto out;
 
+                        /*
+                         * Now process the inode as if it was new.
+                         */
                         sctx->cur_inode_gen = left_gen;
                         sctx->cur_inode_new = 1;
                         sctx->cur_inode_deleted = 0;
@@ -4142,14 +4191,23 @@ static int changed_inode(struct send_ctx *sctx,
                                         sctx->left_path->nodes[0], left_ii);
                         sctx->cur_inode_mode = btrfs_inode_mode(
                                         sctx->left_path->nodes[0], left_ii);
-                        ret = send_create_inode(sctx, sctx->left_path,
-                                        sctx->cmp_key);
+                        ret = send_create_inode_if_needed(sctx);
                         if (ret < 0)
                                 goto out;
 
                         ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
                         if (ret < 0)
                                 goto out;
+                        /*
+                         * Advance send_progress now as we did not get into
+                         * process_recorded_refs_if_needed in the new_gen case.
+                         */
+                        sctx->send_progress = sctx->cur_ino + 1;
+
+                        /*
+                         * Now process all extents and xattrs of the inode as if
+                         * they were all new.
+                         */
                         ret = process_all_extents(sctx);
                         if (ret < 0)
                                 goto out;
@@ -4172,6 +4230,16 @@ out:
         return ret;
 }
 
+/*
+ * We have to process new refs before deleted refs, but compare_trees gives us
+ * the new and deleted refs mixed. To fix this, we record the new/deleted refs
+ * first and later process them in process_recorded_refs.
+ * For the cur_inode_new_gen case, we skip recording completely because
+ * changed_inode did already initiate processing of refs. The reason for this is
+ * that in this case, compare_tree actually compares the refs of 2 different
+ * inodes. To fix this, process_all_refs is used in changed_inode to handle all
+ * refs of the right tree as deleted and all refs of the left tree as new.
+ */
 static int changed_ref(struct send_ctx *sctx,
                        enum btrfs_compare_tree_result result)
 {
@@ -4192,6 +4260,11 @@ static int changed_ref(struct send_ctx *sctx,
         return ret;
 }
 
+/*
+ * Process new/deleted/changed xattrs. We skip processing in the
+ * cur_inode_new_gen case because changed_inode did already initiate processing
+ * of xattrs. The reason is the same as in changed_ref
+ */
 static int changed_xattr(struct send_ctx *sctx,
                          enum btrfs_compare_tree_result result)
 {
@@ -4211,6 +4284,11 @@ static int changed_xattr(struct send_ctx *sctx,
         return ret;
 }
 
+/*
+ * Process new/deleted/changed extents. We skip processing in the
+ * cur_inode_new_gen case because changed_inode did already initiate processing
+ * of extents. The reason is the same as in changed_ref
+ */
 static int changed_extent(struct send_ctx *sctx,
                           enum btrfs_compare_tree_result result)
 {
@@ -4227,7 +4305,10 @@ static int changed_extent(struct send_ctx *sctx,
         return ret;
 }
 
-
+/*
+ * Updates compare related fields in sctx and simply forwards to the actual
+ * changed_xxx functions.
+ */
 static int changed_cb(struct btrfs_root *left_root,
                       struct btrfs_root *right_root,
                       struct btrfs_path *left_path,
@@ -4247,6 +4328,11 @@ static int changed_cb(struct btrfs_root *left_root,
         if (ret < 0)
                 goto out;
 
+        /* Ignore non-FS objects */
+        if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
+            key->objectid == BTRFS_FREE_SPACE_OBJECTID)
+                goto out;
+
         if (key->type == BTRFS_INODE_ITEM_KEY)
                 ret = changed_inode(sctx, result);
         else if (key->type == BTRFS_INODE_REF_KEY)
@@ -4299,7 +4385,8 @@ join_trans:
         }
 
         /*
-         * Make sure the tree has not changed
+         * Make sure the tree has not changed after re-joining. We detect this
+         * by comparing start_ctransid and ctransid. They should always match.
          */
         spin_lock(&send_root->root_times_lock);
         ctransid = btrfs_root_ctransid(&send_root->root_item);
diff --git a/fs/btrfs/send.h b/fs/btrfs/send.h
index 9934e948e57f..1bf4f32fd4ef 100644
--- a/fs/btrfs/send.h
+++ b/fs/btrfs/send.h
@@ -130,4 +130,5 @@ enum {
 
 #ifdef __KERNEL__
 long btrfs_ioctl_send(struct file *mnt_file, void __user *arg);
+int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off);
 #endif
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 83d6f9f9c220..915ac14c2064 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -243,12 +243,18 @@ void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root, const char *function,
                                unsigned int line, int errno)
 {
-        WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted");
+        WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted\n");
         trans->aborted = errno;
         /* Nothing used. The other threads that have joined this
          * transaction may be able to continue. */
         if (!trans->blocks_used) {
-                btrfs_printk(root->fs_info, "Aborting unused transaction.\n");
+                char nbuf[16];
+                const char *errstr;
+
+                errstr = btrfs_decode_error(root->fs_info, errno, nbuf);
+                btrfs_printk(root->fs_info,
+                             "%s:%d: Aborting unused transaction(%s).\n",
+                             function, line, errstr);
                 return;
         }
         trans->transaction->aborted = errno;
@@ -407,7 +413,15 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_set_opt(info->mount_opt, NODATASUM);
                         break;
                 case Opt_nodatacow:
-                        printk(KERN_INFO "btrfs: setting nodatacow\n");
+                        if (!btrfs_test_opt(root, COMPRESS) ||
+                                !btrfs_test_opt(root, FORCE_COMPRESS)) {
+                                        printk(KERN_INFO "btrfs: setting nodatacow, compression disabled\n");
+                        } else {
+                                printk(KERN_INFO "btrfs: setting nodatacow\n");
+                        }
+                        info->compress_type = BTRFS_COMPRESS_NONE;
+                        btrfs_clear_opt(info->mount_opt, COMPRESS);
+                        btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
                         btrfs_set_opt(info->mount_opt, NODATACOW);
                         btrfs_set_opt(info->mount_opt, NODATASUM);
                         break;
@@ -422,10 +436,14 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                                 compress_type = "zlib";
                                 info->compress_type = BTRFS_COMPRESS_ZLIB;
                                 btrfs_set_opt(info->mount_opt, COMPRESS);
+                                btrfs_clear_opt(info->mount_opt, NODATACOW);
+                                btrfs_clear_opt(info->mount_opt, NODATASUM);
                         } else if (strcmp(args[0].from, "lzo") == 0) {
                                 compress_type = "lzo";
                                 info->compress_type = BTRFS_COMPRESS_LZO;
                                 btrfs_set_opt(info->mount_opt, COMPRESS);
+                                btrfs_clear_opt(info->mount_opt, NODATACOW);
+                                btrfs_clear_opt(info->mount_opt, NODATASUM);
                                 btrfs_set_fs_incompat(info, COMPRESS_LZO);
                         } else if (strncmp(args[0].from, "no", 2) == 0) {
                                 compress_type = "no";
@@ -543,11 +561,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
                         break;
                 case Opt_defrag:
-                        printk(KERN_INFO "btrfs: enabling auto defrag");
+                        printk(KERN_INFO "btrfs: enabling auto defrag\n");
                         btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
                         break;
                 case Opt_recovery:
-                        printk(KERN_INFO "btrfs: enabling auto recovery");
+                        printk(KERN_INFO "btrfs: enabling auto recovery\n");
                         btrfs_set_opt(info->mount_opt, RECOVERY);
                         break;
                 case Opt_skip_balance:
@@ -846,18 +864,15 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
                 return 0;
         }
 
-        btrfs_wait_ordered_extents(root, 0, 0);
-
-        spin_lock(&fs_info->trans_lock);
-        if (!fs_info->running_transaction) {
-                spin_unlock(&fs_info->trans_lock);
-                return 0;
-        }
-        spin_unlock(&fs_info->trans_lock);
+        btrfs_wait_ordered_extents(root, 0);
 
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans))
+        trans = btrfs_attach_transaction(root);
+        if (IS_ERR(trans)) {
+                /* no transaction, don't bother */
+                if (PTR_ERR(trans) == -ENOENT)
+                        return 0;
                 return PTR_ERR(trans);
+        }
         return btrfs_commit_transaction(trans, root);
 }
 
@@ -1508,17 +1523,21 @@ static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
 
 static int btrfs_freeze(struct super_block *sb)
 {
-        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-        mutex_lock(&fs_info->transaction_kthread_mutex);
-        mutex_lock(&fs_info->cleaner_mutex);
-        return 0;
+        struct btrfs_trans_handle *trans;
+        struct btrfs_root *root = btrfs_sb(sb)->tree_root;
+
+        trans = btrfs_attach_transaction(root);
+        if (IS_ERR(trans)) {
+                /* no transaction, don't bother */
+                if (PTR_ERR(trans) == -ENOENT)
+                        return 0;
+                return PTR_ERR(trans);
+        }
+        return btrfs_commit_transaction(trans, root);
 }
 
 static int btrfs_unfreeze(struct super_block *sb)
 {
-        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-        mutex_unlock(&fs_info->cleaner_mutex);
-        mutex_unlock(&fs_info->transaction_kthread_mutex);
         return 0;
 }
 
@@ -1595,7 +1614,7 @@ static int btrfs_interface_init(void)
 static void btrfs_interface_exit(void)
 {
         if (misc_deregister(&btrfs_misc) < 0)
-                printk(KERN_INFO "misc_deregister failed for control device");
+                printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
 }
 
 static int __init init_btrfs_fs(void)
@@ -1620,10 +1639,14 @@ static int __init init_btrfs_fs(void)
         if (err)
                 goto free_extent_io;
 
-        err = btrfs_delayed_inode_init();
+        err = ordered_data_init();
         if (err)
                 goto free_extent_map;
 
+        err = btrfs_delayed_inode_init();
+        if (err)
+                goto free_ordered_data;
+
         err = btrfs_interface_init();
         if (err)
                 goto free_delayed_inode;
@@ -1641,6 +1664,8 @@ unregister_ioctl:
         btrfs_interface_exit();
 free_delayed_inode:
         btrfs_delayed_inode_exit();
+free_ordered_data:
+        ordered_data_exit();
 free_extent_map:
         extent_map_exit();
 free_extent_io:
@@ -1657,6 +1682,7 @@ static void __exit exit_btrfs_fs(void)
 {
         btrfs_destroy_cachep();
         btrfs_delayed_inode_exit();
+        ordered_data_exit();
         extent_map_exit();
         extent_io_exit();
         btrfs_interface_exit();
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 27c26004e050..77db875b5116 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -53,7 +53,7 @@ static noinline void switch_commit_root(struct btrfs_root *root)
 /*
  * either allocate a new transaction or hop into the existing one
  */
-static noinline int join_transaction(struct btrfs_root *root, int nofail)
+static noinline int join_transaction(struct btrfs_root *root, int type)
 {
         struct btrfs_transaction *cur_trans;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -67,7 +67,13 @@ loop:
         }
 
         if (fs_info->trans_no_join) {
-                if (!nofail) {
+                /* 
+                 * If we are JOIN_NOLOCK we're already committing a current
+                 * transaction, we just need a handle to deal with something
+                 * when committing the transaction, such as inode cache and
+                 * space cache. It is a special case.
+                 */
+                if (type != TRANS_JOIN_NOLOCK) {
                         spin_unlock(&fs_info->trans_lock);
                         return -EBUSY;
                 }
@@ -87,6 +93,13 @@ loop:
         }
         spin_unlock(&fs_info->trans_lock);
 
+        /*
+         * If we are ATTACH, we just want to catch the current transaction,
+         * and commit it. If there is no transaction, just return ENOENT.
+         */
+        if (type == TRANS_ATTACH)
+                return -ENOENT;
+
         cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
         if (!cur_trans)
                 return -ENOMEM;
@@ -267,13 +280,6 @@ static void wait_current_trans(struct btrfs_root *root)
         }
 }
 
-enum btrfs_trans_type {
-        TRANS_START,
-        TRANS_JOIN,
-        TRANS_USERSPACE,
-        TRANS_JOIN_NOLOCK,
-};
-
 static int may_wait_transaction(struct btrfs_root *root, int type)
 {
         if (root->fs_info->log_root_recovering)
@@ -290,7 +296,8 @@ static int may_wait_transaction(struct btrfs_root *root, int type)
 }
 
 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
-                                                    u64 num_items, int type)
+                                                    u64 num_items, int type,
+                                                    int noflush)
 {
         struct btrfs_trans_handle *h;
         struct btrfs_transaction *cur_trans;
@@ -324,9 +331,14 @@ static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
                 }
 
                 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
-                ret = btrfs_block_rsv_add(root,
-                                          &root->fs_info->trans_block_rsv,
-                                          num_bytes);
+                if (noflush)
+                        ret = btrfs_block_rsv_add_noflush(root,
+                                                &root->fs_info->trans_block_rsv,
+                                                num_bytes);
+                else
+                        ret = btrfs_block_rsv_add(root,
+                                                &root->fs_info->trans_block_rsv,
+                                                num_bytes);
                 if (ret)
                         return ERR_PTR(ret);
         }
@@ -335,19 +347,34 @@ again:
         if (!h)
                 return ERR_PTR(-ENOMEM);
 
-        sb_start_intwrite(root->fs_info->sb);
+        /*
+         * If we are JOIN_NOLOCK we're already committing a transaction and
+         * waiting on this guy, so we don't need to do the sb_start_intwrite
+         * because we're already holding a ref.  We need this because we could
+         * have raced in and did an fsync() on a file which can kick a commit
+         * and then we deadlock with somebody doing a freeze.
+         *
+         * If we are ATTACH, it means we just want to catch the current
+         * transaction and commit it, so we needn't do sb_start_intwrite(). 
+         */
+        if (type < TRANS_JOIN_NOLOCK)
+                sb_start_intwrite(root->fs_info->sb);
 
         if (may_wait_transaction(root, type))
                 wait_current_trans(root);
 
         do {
-                ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
+                ret = join_transaction(root, type);
                 if (ret == -EBUSY)
                         wait_current_trans(root);
         } while (ret == -EBUSY);
 
         if (ret < 0) {
-                sb_end_intwrite(root->fs_info->sb);
+                /* We must get the transaction if we are JOIN_NOLOCK. */
+                BUG_ON(type == TRANS_JOIN_NOLOCK);
+
+                if (type < TRANS_JOIN_NOLOCK)
+                        sb_end_intwrite(root->fs_info->sb);
                 kmem_cache_free(btrfs_trans_handle_cachep, h);
                 return ERR_PTR(ret);
         }
@@ -367,7 +394,9 @@ again:
         h->aborted = 0;
         h->qgroup_reserved = qgroup_reserved;
         h->delayed_ref_elem.seq = 0;
+        h->type = type;
         INIT_LIST_HEAD(&h->qgroup_ref_list);
+        INIT_LIST_HEAD(&h->new_bgs);
 
         smp_mb();
         if (cur_trans->blocked && may_wait_transaction(root, type)) {
@@ -393,21 +422,33 @@ got_it:
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                    int num_items)
 {
-        return start_transaction(root, num_items, TRANS_START);
+        return start_transaction(root, num_items, TRANS_START, 0);
+}
+
+struct btrfs_trans_handle *btrfs_start_transaction_noflush(
+                                        struct btrfs_root *root, int num_items)
+{
+        return start_transaction(root, num_items, TRANS_START, 1);
 }
+
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_JOIN);
+        return start_transaction(root, 0, TRANS_JOIN, 0);
 }
 
 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
+        return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
 }
 
 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_USERSPACE);
+        return start_transaction(root, 0, TRANS_USERSPACE, 0);
+}
+
+struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
+{
+        return start_transaction(root, 0, TRANS_ATTACH, 0);
 }
 
 /* wait for a transaction commit to be fully complete */
@@ -506,11 +547,12 @@ int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
 }
 
 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *root, int throttle, int lock)
+                          struct btrfs_root *root, int throttle)
 {
         struct btrfs_transaction *cur_trans = trans->transaction;
         struct btrfs_fs_info *info = root->fs_info;
         int count = 0;
+        int lock = (trans->type != TRANS_JOIN_NOLOCK);
         int err = 0;
 
         if (--trans->use_count) {
@@ -536,6 +578,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
                 trans->qgroup_reserved = 0;
         }
 
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
+
         while (count < 2) {
                 unsigned long cur = trans->delayed_ref_updates;
                 trans->delayed_ref_updates = 0;
@@ -551,7 +596,8 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
         btrfs_trans_release_metadata(trans, root);
         trans->block_rsv = NULL;
 
-        sb_end_intwrite(root->fs_info->sb);
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
 
         if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
             should_end_transaction(trans, root)) {
@@ -573,6 +619,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
                 }
         }
 
+        if (trans->type < TRANS_JOIN_NOLOCK)
+                sb_end_intwrite(root->fs_info->sb);
+
         WARN_ON(cur_trans != info->running_transaction);
         WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
         atomic_dec(&cur_trans->num_writers);
@@ -604,7 +653,7 @@ int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 {
         int ret;
 
-        ret = __btrfs_end_transaction(trans, root, 0, 1);
+        ret = __btrfs_end_transaction(trans, root, 0);
         if (ret)
                 return ret;
         return 0;
@@ -615,18 +664,7 @@ int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 {
         int ret;
 
-        ret = __btrfs_end_transaction(trans, root, 1, 1);
-        if (ret)
-                return ret;
-        return 0;
-}
-
-int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
-                                 struct btrfs_root *root)
-{
-        int ret;
-
-        ret = __btrfs_end_transaction(trans, root, 0, 0);
+        ret = __btrfs_end_transaction(trans, root, 1);
         if (ret)
                 return ret;
         return 0;
@@ -635,7 +673,7 @@ int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root)
 {
-        return __btrfs_end_transaction(trans, root, 1, 1);
+        return __btrfs_end_transaction(trans, root, 1);
 }
 
 /*
@@ -649,13 +687,15 @@ int btrfs_write_marked_extents(struct btrfs_root *root,
         int err = 0;
         int werr = 0;
         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
+        struct extent_state *cached_state = NULL;
         u64 start = 0;
         u64 end;
 
         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
-                                      mark)) {
-                convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
-                                   GFP_NOFS);
+                                      mark, &cached_state)) {
+                convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
+                                   mark, &cached_state, GFP_NOFS);
+                cached_state = NULL;
                 err = filemap_fdatawrite_range(mapping, start, end);
                 if (err)
                         werr = err;
@@ -679,12 +719,14 @@ int btrfs_wait_marked_extents(struct btrfs_root *root,
         int err = 0;
         int werr = 0;
         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
+        struct extent_state *cached_state = NULL;
         u64 start = 0;
         u64 end;
 
         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
-                                      EXTENT_NEED_WAIT)) {
-                clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
+                                      EXTENT_NEED_WAIT, &cached_state)) {
+                clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
+                                 0, 0, &cached_state, GFP_NOFS);
                 err = filemap_fdatawait_range(mapping, start, end);
                 if (err)
                         werr = err;
@@ -955,6 +997,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         struct btrfs_root *parent_root;
         struct btrfs_block_rsv *rsv;
         struct inode *parent_inode;
+        struct btrfs_path *path;
+        struct btrfs_dir_item *dir_item;
         struct dentry *parent;
         struct dentry *dentry;
         struct extent_buffer *tmp;
@@ -967,18 +1011,22 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         u64 root_flags;
         uuid_le new_uuid;
 
-        rsv = trans->block_rsv;
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = pending->error = -ENOMEM;
+                goto path_alloc_fail;
+        }
 
         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
         if (!new_root_item) {
                 ret = pending->error = -ENOMEM;
-                goto fail;
+                goto root_item_alloc_fail;
         }
 
         ret = btrfs_find_free_objectid(tree_root, &objectid);
         if (ret) {
                 pending->error = ret;
-                goto fail;
+                goto no_free_objectid;
         }
 
         btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
@@ -988,22 +1036,22 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                                                   to_reserve);
                 if (ret) {
                         pending->error = ret;
-                        goto fail;
+                        goto no_free_objectid;
                 }
         }
 
         ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
                                    objectid, pending->inherit);
-        kfree(pending->inherit);
         if (ret) {
                 pending->error = ret;
-                goto fail;
+                goto no_free_objectid;
         }
 
         key.objectid = objectid;
         key.offset = (u64)-1;
         key.type = BTRFS_ROOT_ITEM_KEY;
 
+        rsv = trans->block_rsv;
         trans->block_rsv = &pending->block_rsv;
 
         dentry = pending->dentry;
@@ -1017,24 +1065,21 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
          */
         ret = btrfs_set_inode_index(parent_inode, &index);
         BUG_ON(ret); /* -ENOMEM */
-        ret = btrfs_insert_dir_item(trans, parent_root,
-                                dentry->d_name.name, dentry->d_name.len,
-                                parent_inode, &key,
-                                BTRFS_FT_DIR, index);
-        if (ret == -EEXIST) {
+
+        /* check if there is a file/dir which has the same name. */
+        dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
+                                         btrfs_ino(parent_inode),
+                                         dentry->d_name.name,
+                                         dentry->d_name.len, 0);
+        if (dir_item != NULL && !IS_ERR(dir_item)) {
                 pending->error = -EEXIST;
-                dput(parent);
                 goto fail;
-        } else if (ret) {
-                goto abort_trans_dput;
+        } else if (IS_ERR(dir_item)) {
+                ret = PTR_ERR(dir_item);
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
-
-        btrfs_i_size_write(parent_inode, parent_inode->i_size +
-                                         dentry->d_name.len * 2);
-        parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
-        ret = btrfs_update_inode(trans, parent_root, parent_inode);
-        if (ret)
-                goto abort_trans_dput;
+        btrfs_release_path(path);
 
         /*
          * pull in the delayed directory update
@@ -1043,8 +1088,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
          * snapshot
          */
         ret = btrfs_run_delayed_items(trans, root);
-        if (ret) { /* Transaction aborted */
-                dput(parent);
+        if (ret) {      /* Transaction aborted */
+                btrfs_abort_transaction(trans, root, ret);
                 goto fail;
         }
 
@@ -1079,7 +1124,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         if (ret) {
                 btrfs_tree_unlock(old);
                 free_extent_buffer(old);
-                goto abort_trans_dput;
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
 
         btrfs_set_lock_blocking(old);
@@ -1088,8 +1134,10 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         /* clean up in any case */
         btrfs_tree_unlock(old);
         free_extent_buffer(old);
-        if (ret)
-                goto abort_trans_dput;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
 
         /* see comments in should_cow_block() */
         root->force_cow = 1;
@@ -1101,8 +1149,10 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
         btrfs_tree_unlock(tmp);
         free_extent_buffer(tmp);
-        if (ret)
-                goto abort_trans_dput;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
 
         /*
          * insert root back/forward references
@@ -1111,32 +1161,58 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                                  parent_root->root_key.objectid,
                                  btrfs_ino(parent_inode), index,
                                  dentry->d_name.name, dentry->d_name.len);
-        dput(parent);
-        if (ret)
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
                 goto fail;
+        }
 
         key.offset = (u64)-1;
         pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
         if (IS_ERR(pending->snap)) {
                 ret = PTR_ERR(pending->snap);
-                goto abort_trans;
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
 
         ret = btrfs_reloc_post_snapshot(trans, pending);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        ret = btrfs_insert_dir_item(trans, parent_root,
+                                    dentry->d_name.name, dentry->d_name.len,
+                                    parent_inode, &key,
+                                    BTRFS_FT_DIR, index);
+        /* We have check then name at the beginning, so it is impossible. */
+        BUG_ON(ret == -EEXIST);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        btrfs_i_size_write(parent_inode, parent_inode->i_size +
+                                         dentry->d_name.len * 2);
+        parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
+        ret = btrfs_update_inode(trans, parent_root, parent_inode);
         if (ret)
-                goto abort_trans;
-        ret = 0;
+                btrfs_abort_transaction(trans, root, ret);
 fail:
-        kfree(new_root_item);
+        dput(parent);
         trans->block_rsv = rsv;
+no_free_objectid:
+        kfree(new_root_item);
+root_item_alloc_fail:
+        btrfs_free_path(path);
+path_alloc_fail:
         btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
         return ret;
-
-abort_trans_dput:
-        dput(parent);
-abort_trans:
-        btrfs_abort_transaction(trans, root, ret);
-        goto fail;
 }
 
 /*
@@ -1229,6 +1305,16 @@ static void do_async_commit(struct work_struct *work)
         struct btrfs_async_commit *ac =
                 container_of(work, struct btrfs_async_commit, work.work);
 
+        /*
+         * We've got freeze protection passed with the transaction.
+         * Tell lockdep about it.
+         */
+        rwsem_acquire_read(
+                &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
+                0, 1, _THIS_IP_);
+
+        current->journal_info = ac->newtrans;
+
         btrfs_commit_transaction(ac->newtrans, ac->root);
         kfree(ac);
 }
@@ -1258,6 +1344,14 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
         atomic_inc(&cur_trans->use_count);
 
         btrfs_end_transaction(trans, root);
+
+        /*
+         * Tell lockdep we've released the freeze rwsem, since the
+         * async commit thread will be the one to unlock it.
+         */
+        rwsem_release(&root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
+                      1, _THIS_IP_);
+
         schedule_delayed_work(&ac->work, 0);
 
         /* wait for transaction to start and unblock */
@@ -1348,6 +1442,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          */
         cur_trans->delayed_refs.flushing = 1;
 
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
+
         ret = btrfs_run_delayed_refs(trans, root, 0);
         if (ret)
                 goto cleanup_transaction;
@@ -1403,7 +1500,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 
                 if (flush_on_commit || snap_pending) {
                         btrfs_start_delalloc_inodes(root, 1);
-                        btrfs_wait_ordered_extents(root, 0, 1);
+                        btrfs_wait_ordered_extents(root, 1);
                 }
 
                 ret = btrfs_run_delayed_items(trans, root);
@@ -1456,13 +1553,28 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          */
         mutex_lock(&root->fs_info->reloc_mutex);
 
-        ret = btrfs_run_delayed_items(trans, root);
+        /*
+         * We needn't worry about the delayed items because we will
+         * deal with them in create_pending_snapshot(), which is the
+         * core function of the snapshot creation.
+         */
+        ret = create_pending_snapshots(trans, root->fs_info);
         if (ret) {
                 mutex_unlock(&root->fs_info->reloc_mutex);
                 goto cleanup_transaction;
         }
 
-        ret = create_pending_snapshots(trans, root->fs_info);
+        /*
+         * We insert the dir indexes of the snapshots and update the inode
+         * of the snapshots' parents after the snapshot creation, so there
+         * are some delayed items which are not dealt with. Now deal with
+         * them.
+         *
+         * We needn't worry that this operation will corrupt the snapshots,
+         * because all the tree which are snapshoted will be forced to COW
+         * the nodes and leaves.
+         */
+        ret = btrfs_run_delayed_items(trans, root);
         if (ret) {
                 mutex_unlock(&root->fs_info->reloc_mutex);
                 goto cleanup_transaction;
@@ -1584,7 +1696,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         put_transaction(cur_trans);
         put_transaction(cur_trans);
 
-        sb_end_intwrite(root->fs_info->sb);
+        if (trans->type < TRANS_JOIN_NOLOCK)
+                sb_end_intwrite(root->fs_info->sb);
 
         trace_btrfs_transaction_commit(root);
 
diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index e8b8416c688b..80961947a6b2 100644
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -47,6 +47,14 @@ struct btrfs_transaction {
         int aborted;
 };
 
+enum btrfs_trans_type {
+        TRANS_START,
+        TRANS_JOIN,
+        TRANS_USERSPACE,
+        TRANS_JOIN_NOLOCK,
+        TRANS_ATTACH,
+};
+
 struct btrfs_trans_handle {
         u64 transid;
         u64 bytes_reserved;
@@ -58,8 +66,9 @@ struct btrfs_trans_handle {
         struct btrfs_transaction *transaction;
         struct btrfs_block_rsv *block_rsv;
         struct btrfs_block_rsv *orig_rsv;
-        int aborted;
-        int adding_csums;
+        short aborted;
+        short adding_csums;
+        enum btrfs_trans_type type;
         /*
          * this root is only needed to validate that the root passed to
          * start_transaction is the same as the one passed to end_transaction.
@@ -68,6 +77,7 @@ struct btrfs_trans_handle {
         struct btrfs_root *root;
         struct seq_list delayed_ref_elem;
         struct list_head qgroup_ref_list;
+        struct list_head new_bgs;
 };
 
 struct btrfs_pending_snapshot {
@@ -88,16 +98,18 @@ static inline void btrfs_set_inode_last_trans(struct btrfs_trans_handle *trans,
 {
         BTRFS_I(inode)->last_trans = trans->transaction->transid;
         BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
 }
 
 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
                           struct btrfs_root *root);
-int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
-                                 struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                    int num_items);
+struct btrfs_trans_handle *btrfs_start_transaction_noflush(
+                                        struct btrfs_root *root, int num_items);
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root);
+struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root);
 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid);
 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index c86670f4f285..e9ebb472b28b 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -18,13 +18,16 @@
 
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/list_sort.h>
 #include "ctree.h"
 #include "transaction.h"
 #include "disk-io.h"
 #include "locking.h"
 #include "print-tree.h"
+#include "backref.h"
 #include "compat.h"
 #include "tree-log.h"
+#include "hash.h"
 
 /* magic values for the inode_only field in btrfs_log_inode:
  *
@@ -146,7 +149,7 @@ static int start_log_trans(struct btrfs_trans_handle *trans,
                         root->log_multiple_pids = true;
                 }
 
-                root->log_batch++;
+                atomic_inc(&root->log_batch);
                 atomic_inc(&root->log_writers);
                 mutex_unlock(&root->log_mutex);
                 return 0;
@@ -165,7 +168,7 @@ static int start_log_trans(struct btrfs_trans_handle *trans,
                         err = ret;
         }
         mutex_unlock(&root->fs_info->tree_log_mutex);
-        root->log_batch++;
+        atomic_inc(&root->log_batch);
         atomic_inc(&root->log_writers);
         mutex_unlock(&root->log_mutex);
         return err;
@@ -484,7 +487,6 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
         int found_type;
         u64 mask = root->sectorsize - 1;
         u64 extent_end;
-        u64 alloc_hint;
         u64 start = key->offset;
         u64 saved_nbytes;
         struct btrfs_file_extent_item *item;
@@ -550,8 +552,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
 
         saved_nbytes = inode_get_bytes(inode);
         /* drop any overlapping extents */
-        ret = btrfs_drop_extents(trans, inode, start, extent_end,
-                                 &alloc_hint, 1);
+        ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
         BUG_ON(ret);
 
         if (found_type == BTRFS_FILE_EXTENT_REG ||
@@ -744,6 +745,7 @@ out:
  */
 static noinline int backref_in_log(struct btrfs_root *log,
                                    struct btrfs_key *key,
+                                   u64 ref_objectid,
                                    char *name, int namelen)
 {
         struct btrfs_path *path;
@@ -764,8 +766,17 @@ static noinline int backref_in_log(struct btrfs_root *log,
         if (ret != 0)
                 goto out;
 
-        item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
         ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
+
+        if (key->type == BTRFS_INODE_EXTREF_KEY) {
+                if (btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                                   name, namelen, NULL))
+                        match = 1;
+
+                goto out;
+        }
+
+        item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
         ptr_end = ptr + item_size;
         while (ptr < ptr_end) {
                 ref = (struct btrfs_inode_ref *)ptr;
@@ -786,91 +797,42 @@ out:
         return match;
 }
 
-
-/*
- * replay one inode back reference item found in the log tree.
- * eb, slot and key refer to the buffer and key found in the log tree.
- * root is the destination we are replaying into, and path is for temp
- * use by this function.  (it should be released on return).
- */
-static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
+static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
                                   struct btrfs_root *root,
-                                  struct btrfs_root *log,
                                   struct btrfs_path *path,
-                                  struct extent_buffer *eb, int slot,
-                                  struct btrfs_key *key)
+                                  struct btrfs_root *log_root,
+                                  struct inode *dir, struct inode *inode,
+                                  struct extent_buffer *eb,
+                                  u64 inode_objectid, u64 parent_objectid,
+                                  u64 ref_index, char *name, int namelen,
+                                  int *search_done)
 {
-        struct btrfs_inode_ref *ref;
-        struct btrfs_dir_item *di;
-        struct inode *dir;
-        struct inode *inode;
-        unsigned long ref_ptr;
-        unsigned long ref_end;
-        char *name;
-        int namelen;
         int ret;
-        int search_done = 0;
-
-        /*
-         * it is possible that we didn't log all the parent directories
-         * for a given inode.  If we don't find the dir, just don't
-         * copy the back ref in.  The link count fixup code will take
-         * care of the rest
-         */
-        dir = read_one_inode(root, key->offset);
-        if (!dir)
-                return -ENOENT;
-
-        inode = read_one_inode(root, key->objectid);
-        if (!inode) {
-                iput(dir);
-                return -EIO;
-        }
-
-        ref_ptr = btrfs_item_ptr_offset(eb, slot);
-        ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
+        char *victim_name;
+        int victim_name_len;
+        struct extent_buffer *leaf;
+        struct btrfs_dir_item *di;
+        struct btrfs_key search_key;
+        struct btrfs_inode_extref *extref;
 
 again:
-        ref = (struct btrfs_inode_ref *)ref_ptr;
-
-        namelen = btrfs_inode_ref_name_len(eb, ref);
-        name = kmalloc(namelen, GFP_NOFS);
-        BUG_ON(!name);
-
-        read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen);
-
-        /* if we already have a perfect match, we're done */
-        if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
-                         btrfs_inode_ref_index(eb, ref),
-                         name, namelen)) {
-                goto out;
-        }
-
-        /*
-         * look for a conflicting back reference in the metadata.
-         * if we find one we have to unlink that name of the file
-         * before we add our new link.  Later on, we overwrite any
-         * existing back reference, and we don't want to create
-         * dangling pointers in the directory.
-         */
-
-        if (search_done)
-                goto insert;
-
-        ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
+        /* Search old style refs */
+        search_key.objectid = inode_objectid;
+        search_key.type = BTRFS_INODE_REF_KEY;
+        search_key.offset = parent_objectid;
+        ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
         if (ret == 0) {
-                char *victim_name;
-                int victim_name_len;
                 struct btrfs_inode_ref *victim_ref;
                 unsigned long ptr;
                 unsigned long ptr_end;
-                struct extent_buffer *leaf = path->nodes[0];
+
+                leaf = path->nodes[0];
 
                 /* are we trying to overwrite a back ref for the root directory
                  * if so, just jump out, we're done
                  */
-                if (key->objectid == key->offset)
-                        goto out_nowrite;
+                if (search_key.objectid == search_key.offset)
+                        return 1;
 
                 /* check all the names in this back reference to see
                  * if they are in the log.  if so, we allow them to stay
@@ -889,7 +851,9 @@ again:
                                            (unsigned long)(victim_ref + 1),
                                            victim_name_len);
 
-                        if (!backref_in_log(log, key, victim_name,
+                        if (!backref_in_log(log_root, &search_key,
+                                            parent_objectid,
+                                            victim_name,
                                             victim_name_len)) {
                                 btrfs_inc_nlink(inode);
                                 btrfs_release_path(path);
@@ -897,9 +861,14 @@ again:
                                 ret = btrfs_unlink_inode(trans, root, dir,
                                                          inode, victim_name,
                                                          victim_name_len);
+                                BUG_ON(ret);
                                 btrfs_run_delayed_items(trans, root);
+                                kfree(victim_name);
+                                *search_done = 1;
+                                goto again;
                         }
                         kfree(victim_name);
+
                         ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
                 }
                 BUG_ON(ret);
@@ -908,14 +877,78 @@ again:
                  * NOTE: we have searched root tree and checked the
                  * coresponding ref, it does not need to check again.
                  */
-                search_done = 1;
+                *search_done = 1;
+        }
+        btrfs_release_path(path);
+
+        /* Same search but for extended refs */
+        extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
+                                           inode_objectid, parent_objectid, 0,
+                                           0);
+        if (!IS_ERR_OR_NULL(extref)) {
+                u32 item_size;
+                u32 cur_offset = 0;
+                unsigned long base;
+                struct inode *victim_parent;
+
+                leaf = path->nodes[0];
+
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                base = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+                while (cur_offset < item_size) {
+                        extref = (struct btrfs_inode_extref *)base + cur_offset;
+
+                        victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                        if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
+                                goto next;
+
+                        victim_name = kmalloc(victim_name_len, GFP_NOFS);
+                        read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
+                                           victim_name_len);
+
+                        search_key.objectid = inode_objectid;
+                        search_key.type = BTRFS_INODE_EXTREF_KEY;
+                        search_key.offset = btrfs_extref_hash(parent_objectid,
+                                                              victim_name,
+                                                              victim_name_len);
+                        ret = 0;
+                        if (!backref_in_log(log_root, &search_key,
+                                            parent_objectid, victim_name,
+                                            victim_name_len)) {
+                                ret = -ENOENT;
+                                victim_parent = read_one_inode(root,
+                                                               parent_objectid);
+                                if (victim_parent) {
+                                        btrfs_inc_nlink(inode);
+                                        btrfs_release_path(path);
+
+                                        ret = btrfs_unlink_inode(trans, root,
+                                                                 victim_parent,
+                                                                 inode,
+                                                                 victim_name,
+                                                                 victim_name_len);
+                                        btrfs_run_delayed_items(trans, root);
+                                }
+                                BUG_ON(ret);
+                                iput(victim_parent);
+                                kfree(victim_name);
+                                *search_done = 1;
+                                goto again;
+                        }
+                        kfree(victim_name);
+                        BUG_ON(ret);
+next:
+                        cur_offset += victim_name_len + sizeof(*extref);
+                }
+                *search_done = 1;
         }
         btrfs_release_path(path);
 
         /* look for a conflicting sequence number */
         di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
-                                         btrfs_inode_ref_index(eb, ref),
-                                         name, namelen, 0);
+                                         ref_index, name, namelen, 0);
         if (di && !IS_ERR(di)) {
                 ret = drop_one_dir_item(trans, root, path, dir, di);
                 BUG_ON(ret);
@@ -931,25 +964,173 @@ again:
         }
         btrfs_release_path(path);
 
-insert:
-        /* insert our name */
-        ret = btrfs_add_link(trans, dir, inode, name, namelen, 0,
-                             btrfs_inode_ref_index(eb, ref));
-        BUG_ON(ret);
+        return 0;
+}
 
-        btrfs_update_inode(trans, root, inode);
+static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
+                             u32 *namelen, char **name, u64 *index,
+                             u64 *parent_objectid)
+{
+        struct btrfs_inode_extref *extref;
 
-out:
-        ref_ptr = (unsigned long)(ref + 1) + namelen;
-        kfree(name);
-        if (ref_ptr < ref_end)
-                goto again;
+        extref = (struct btrfs_inode_extref *)ref_ptr;
+
+        *namelen = btrfs_inode_extref_name_len(eb, extref);
+        *name = kmalloc(*namelen, GFP_NOFS);
+        if (*name == NULL)
+                return -ENOMEM;
+
+        read_extent_buffer(eb, *name, (unsigned long)&extref->name,
+                           *namelen);
+
+        *index = btrfs_inode_extref_index(eb, extref);
+        if (parent_objectid)
+                *parent_objectid = btrfs_inode_extref_parent(eb, extref);
+
+        return 0;
+}
+
+static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
+                          u32 *namelen, char **name, u64 *index)
+{
+        struct btrfs_inode_ref *ref;
+
+        ref = (struct btrfs_inode_ref *)ref_ptr;
+
+        *namelen = btrfs_inode_ref_name_len(eb, ref);
+        *name = kmalloc(*namelen, GFP_NOFS);
+        if (*name == NULL)
+                return -ENOMEM;
+
+        read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
+
+        *index = btrfs_inode_ref_index(eb, ref);
+
+        return 0;
+}
+
+/*
+ * replay one inode back reference item found in the log tree.
+ * eb, slot and key refer to the buffer and key found in the log tree.
+ * root is the destination we are replaying into, and path is for temp
+ * use by this function.  (it should be released on return).
+ */
+static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
+                                  struct btrfs_root *root,
+                                  struct btrfs_root *log,
+                                  struct btrfs_path *path,
+                                  struct extent_buffer *eb, int slot,
+                                  struct btrfs_key *key)
+{
+        struct inode *dir;
+        struct inode *inode;
+        unsigned long ref_ptr;
+        unsigned long ref_end;
+        char *name;
+        int namelen;
+        int ret;
+        int search_done = 0;
+        int log_ref_ver = 0;
+        u64 parent_objectid;
+        u64 inode_objectid;
+        u64 ref_index = 0;
+        int ref_struct_size;
+
+        ref_ptr = btrfs_item_ptr_offset(eb, slot);
+        ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
+
+        if (key->type == BTRFS_INODE_EXTREF_KEY) {
+                struct btrfs_inode_extref *r;
+
+                ref_struct_size = sizeof(struct btrfs_inode_extref);
+                log_ref_ver = 1;
+                r = (struct btrfs_inode_extref *)ref_ptr;
+                parent_objectid = btrfs_inode_extref_parent(eb, r);
+        } else {
+                ref_struct_size = sizeof(struct btrfs_inode_ref);
+                parent_objectid = key->offset;
+        }
+        inode_objectid = key->objectid;
+
+        /*
+         * it is possible that we didn't log all the parent directories
+         * for a given inode.  If we don't find the dir, just don't
+         * copy the back ref in.  The link count fixup code will take
+         * care of the rest
+         */
+        dir = read_one_inode(root, parent_objectid);
+        if (!dir)
+                return -ENOENT;
+
+        inode = read_one_inode(root, inode_objectid);
+        if (!inode) {
+                iput(dir);
+                return -EIO;
+        }
+
+        while (ref_ptr < ref_end) {
+                if (log_ref_ver) {
+                        ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
+                                                &ref_index, &parent_objectid);
+                        /*
+                         * parent object can change from one array
+                         * item to another.
+                         */
+                        if (!dir)
+                                dir = read_one_inode(root, parent_objectid);
+                        if (!dir)
+                                return -ENOENT;
+                } else {
+                        ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
+                                             &ref_index);
+                }
+                if (ret)
+                        return ret;
+
+                /* if we already have a perfect match, we're done */
+                if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
+                                  ref_index, name, namelen)) {
+                        /*
+                         * look for a conflicting back reference in the
+                         * metadata. if we find one we have to unlink that name
+                         * of the file before we add our new link.  Later on, we
+                         * overwrite any existing back reference, and we don't
+                         * want to create dangling pointers in the directory.
+                         */
+
+                        if (!search_done) {
+                                ret = __add_inode_ref(trans, root, path, log,
+                                                      dir, inode, eb,
+                                                      inode_objectid,
+                                                      parent_objectid,
+                                                      ref_index, name, namelen,
+                                                      &search_done);
+                                if (ret == 1)
+                                        goto out;
+                                BUG_ON(ret);
+                        }
+
+                        /* insert our name */
+                        ret = btrfs_add_link(trans, dir, inode, name, namelen,
+                                             0, ref_index);
+                        BUG_ON(ret);
+
+                        btrfs_update_inode(trans, root, inode);
+                }
+
+                ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
+                kfree(name);
+                if (log_ref_ver) {
+                        iput(dir);
+                        dir = NULL;
+                }
+        }
 
         /* finally write the back reference in the inode */
         ret = overwrite_item(trans, root, path, eb, slot, key);
         BUG_ON(ret);
 
-out_nowrite:
+out:
         btrfs_release_path(path);
         iput(dir);
         iput(inode);
@@ -966,25 +1147,55 @@ static int insert_orphan_item(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static int count_inode_extrefs(struct btrfs_root *root,
+                               struct inode *inode, struct btrfs_path *path)
+{
+        int ret = 0;
+        int name_len;
+        unsigned int nlink = 0;
+        u32 item_size;
+        u32 cur_offset = 0;
+        u64 inode_objectid = btrfs_ino(inode);
+        u64 offset = 0;
+        unsigned long ptr;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
 
-/*
- * There are a few corners where the link count of the file can't
- * be properly maintained during replay.  So, instead of adding
- * lots of complexity to the log code, we just scan the backrefs
- * for any file that has been through replay.
- *
- * The scan will update the link count on the inode to reflect the
- * number of back refs found.  If it goes down to zero, the iput
- * will free the inode.
- */
-static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
-                                           struct btrfs_root *root,
-                                           struct inode *inode)
+        while (1) {
+                ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
+                                            &extref, &offset);
+                if (ret)
+                        break;
+
+                leaf = path->nodes[0];
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+                while (cur_offset < item_size) {
+                        extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
+                        name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                        nlink++;
+
+                        cur_offset += name_len + sizeof(*extref);
+                }
+
+                offset++;
+                btrfs_release_path(path);
+        }
+        btrfs_release_path(path);
+
+        if (ret < 0)
+                return ret;
+        return nlink;
+}
+
+static int count_inode_refs(struct btrfs_root *root,
+                               struct inode *inode, struct btrfs_path *path)
 {
-        struct btrfs_path *path;
         int ret;
         struct btrfs_key key;
-        u64 nlink = 0;
+        unsigned int nlink = 0;
         unsigned long ptr;
         unsigned long ptr_end;
         int name_len;
@@ -994,10 +1205,6 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
         key.type = BTRFS_INODE_REF_KEY;
         key.offset = (u64)-1;
 
-        path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
-
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
@@ -1031,6 +1238,50 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
                 btrfs_release_path(path);
         }
         btrfs_release_path(path);
+
+        return nlink;
+}
+
+/*
+ * There are a few corners where the link count of the file can't
+ * be properly maintained during replay.  So, instead of adding
+ * lots of complexity to the log code, we just scan the backrefs
+ * for any file that has been through replay.
+ *
+ * The scan will update the link count on the inode to reflect the
+ * number of back refs found.  If it goes down to zero, the iput
+ * will free the inode.
+ */
+static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
+                                           struct btrfs_root *root,
+                                           struct inode *inode)
+{
+        struct btrfs_path *path;
+        int ret;
+        u64 nlink = 0;
+        u64 ino = btrfs_ino(inode);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        ret = count_inode_refs(root, inode, path);
+        if (ret < 0)
+                goto out;
+
+        nlink = ret;
+
+        ret = count_inode_extrefs(root, inode, path);
+        if (ret == -ENOENT)
+                ret = 0;
+
+        if (ret < 0)
+                goto out;
+
+        nlink += ret;
+
+        ret = 0;
+
         if (nlink != inode->i_nlink) {
                 set_nlink(inode, nlink);
                 btrfs_update_inode(trans, root, inode);
@@ -1046,9 +1297,10 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
                 ret = insert_orphan_item(trans, root, ino);
                 BUG_ON(ret);
         }
-        btrfs_free_path(path);
 
-        return 0;
+out:
+        btrfs_free_path(path);
+        return ret;
 }
 
 static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
@@ -1695,6 +1947,10 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                         ret = add_inode_ref(wc->trans, root, log, path,
                                             eb, i, &key);
                         BUG_ON(ret && ret != -ENOENT);
+                } else if (key.type == BTRFS_INODE_EXTREF_KEY) {
+                        ret = add_inode_ref(wc->trans, root, log, path,
+                                            eb, i, &key);
+                        BUG_ON(ret && ret != -ENOENT);
                 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
                         ret = replay_one_extent(wc->trans, root, path,
                                                 eb, i, &key);
@@ -2037,7 +2293,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
                 wait_log_commit(trans, root, root->log_transid - 1);
         while (1) {
-                unsigned long batch = root->log_batch;
+                int batch = atomic_read(&root->log_batch);
                 /* when we're on an ssd, just kick the log commit out */
                 if (!btrfs_test_opt(root, SSD) && root->log_multiple_pids) {
                         mutex_unlock(&root->log_mutex);
@@ -2045,7 +2301,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
                         mutex_lock(&root->log_mutex);
                 }
                 wait_for_writer(trans, root);
-                if (batch == root->log_batch)
+                if (batch == atomic_read(&root->log_batch))
                         break;
         }
 
@@ -2074,7 +2330,6 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
 
         btrfs_set_root_node(&log->root_item, log->node);
 
-        root->log_batch = 0;
         root->log_transid++;
         log->log_transid = root->log_transid;
         root->log_start_pid = 0;
@@ -2087,7 +2342,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         mutex_unlock(&root->log_mutex);
 
         mutex_lock(&log_root_tree->log_mutex);
-        log_root_tree->log_batch++;
+        atomic_inc(&log_root_tree->log_batch);
         atomic_inc(&log_root_tree->log_writers);
         mutex_unlock(&log_root_tree->log_mutex);
 
@@ -2157,7 +2412,6 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
                                 btrfs_header_level(log_root_tree->node));
 
-        log_root_tree->log_batch = 0;
         log_root_tree->log_transid++;
         smp_mb();
 
@@ -2171,9 +2425,12 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
          * in and cause problems either.
          */
         btrfs_scrub_pause_super(root);
-        write_ctree_super(trans, root->fs_info->tree_root, 1);
+        ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
         btrfs_scrub_continue_super(root);
-        ret = 0;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out_wake_log_root;
+        }
 
         mutex_lock(&root->log_mutex);
         if (root->last_log_commit < log_transid)
@@ -2209,7 +2466,8 @@ static void free_log_tree(struct btrfs_trans_handle *trans,
 
         while (1) {
                 ret = find_first_extent_bit(&log->dirty_log_pages,
-                                0, &start, &end, EXTENT_DIRTY | EXTENT_NEW);
+                                0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
+                                NULL);
                 if (ret)
                         break;
 
@@ -2646,6 +2904,7 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
         int ret;
         struct btrfs_key key;
         struct btrfs_key found_key;
+        int start_slot;
 
         key.objectid = objectid;
         key.type = max_key_type;
@@ -2667,8 +2926,18 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
                 if (found_key.objectid != objectid)
                         break;
 
-                ret = btrfs_del_item(trans, log, path);
-                if (ret)
+                found_key.offset = 0;
+                found_key.type = 0;
+                ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
+                                       &start_slot);
+
+                ret = btrfs_del_items(trans, log, path, start_slot,
+                                      path->slots[0] - start_slot + 1);
+                /*
+                 * If start slot isn't 0 then we don't need to re-search, we've
+                 * found the last guy with the objectid in this tree.
+                 */
+                if (ret || start_slot != 0)
                         break;
                 btrfs_release_path(path);
         }
@@ -2678,14 +2947,64 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static void fill_inode_item(struct btrfs_trans_handle *trans,
+                            struct extent_buffer *leaf,
+                            struct btrfs_inode_item *item,
+                            struct inode *inode, int log_inode_only)
+{
+        btrfs_set_inode_uid(leaf, item, inode->i_uid);
+        btrfs_set_inode_gid(leaf, item, inode->i_gid);
+        btrfs_set_inode_mode(leaf, item, inode->i_mode);
+        btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
+
+        btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
+                               inode->i_atime.tv_sec);
+        btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
+                                inode->i_atime.tv_nsec);
+
+        btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
+                               inode->i_mtime.tv_sec);
+        btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
+                                inode->i_mtime.tv_nsec);
+
+        btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
+                               inode->i_ctime.tv_sec);
+        btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
+                                inode->i_ctime.tv_nsec);
+
+        btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
+
+        btrfs_set_inode_sequence(leaf, item, inode->i_version);
+        btrfs_set_inode_transid(leaf, item, trans->transid);
+        btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
+        btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
+        btrfs_set_inode_block_group(leaf, item, 0);
+
+        if (log_inode_only) {
+                /* set the generation to zero so the recover code
+                 * can tell the difference between an logging
+                 * just to say 'this inode exists' and a logging
+                 * to say 'update this inode with these values'
+                 */
+                btrfs_set_inode_generation(leaf, item, 0);
+                btrfs_set_inode_size(leaf, item, 0);
+        } else {
+                btrfs_set_inode_generation(leaf, item,
+                                           BTRFS_I(inode)->generation);
+                btrfs_set_inode_size(leaf, item, inode->i_size);
+        }
+
+}
+
 static noinline int copy_items(struct btrfs_trans_handle *trans,
-                               struct btrfs_root *log,
+                               struct inode *inode,
                                struct btrfs_path *dst_path,
                                struct extent_buffer *src,
                                int start_slot, int nr, int inode_only)
 {
         unsigned long src_offset;
         unsigned long dst_offset;
+        struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
         struct btrfs_file_extent_item *extent;
         struct btrfs_inode_item *inode_item;
         int ret;
@@ -2694,6 +3013,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
         char *ins_data;
         int i;
         struct list_head ordered_sums;
+        int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         INIT_LIST_HEAD(&ordered_sums);
 
@@ -2722,29 +3042,23 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
 
                 src_offset = btrfs_item_ptr_offset(src, start_slot + i);
 
-                copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
-                                   src_offset, ins_sizes[i]);
-
-                if (inode_only == LOG_INODE_EXISTS &&
-                    ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
+                if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
                         inode_item = btrfs_item_ptr(dst_path->nodes[0],
                                                     dst_path->slots[0],
                                                     struct btrfs_inode_item);
-                        btrfs_set_inode_size(dst_path->nodes[0], inode_item, 0);
-
-                        /* set the generation to zero so the recover code
-                         * can tell the difference between an logging
-                         * just to say 'this inode exists' and a logging
-                         * to say 'update this inode with these values'
-                         */
-                        btrfs_set_inode_generation(dst_path->nodes[0],
-                                                   inode_item, 0);
+                        fill_inode_item(trans, dst_path->nodes[0], inode_item,
+                                        inode, inode_only == LOG_INODE_EXISTS);
+                } else {
+                        copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
+                                           src_offset, ins_sizes[i]);
                 }
+
                 /* take a reference on file data extents so that truncates
                  * or deletes of this inode don't have to relog the inode
                  * again
                  */
-                if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY) {
+                if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY &&
+                    !skip_csum) {
                         int found_type;
                         extent = btrfs_item_ptr(src, start_slot + i,
                                                 struct btrfs_file_extent_item);
@@ -2753,8 +3067,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
                                 continue;
 
                         found_type = btrfs_file_extent_type(src, extent);
-                        if (found_type == BTRFS_FILE_EXTENT_REG ||
-                            found_type == BTRFS_FILE_EXTENT_PREALLOC) {
+                        if (found_type == BTRFS_FILE_EXTENT_REG) {
                                 u64 ds, dl, cs, cl;
                                 ds = btrfs_file_extent_disk_bytenr(src,
                                                                 extent);
@@ -2803,6 +3116,239 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
+{
+        struct extent_map *em1, *em2;
+
+        em1 = list_entry(a, struct extent_map, list);
+        em2 = list_entry(b, struct extent_map, list);
+
+        if (em1->start < em2->start)
+                return -1;
+        else if (em1->start > em2->start)
+                return 1;
+        return 0;
+}
+
+struct log_args {
+        struct extent_buffer *src;
+        u64 next_offset;
+        int start_slot;
+        int nr;
+};
+
+static int log_one_extent(struct btrfs_trans_handle *trans,
+                          struct inode *inode, struct btrfs_root *root,
+                          struct extent_map *em, struct btrfs_path *path,
+                          struct btrfs_path *dst_path, struct log_args *args)
+{
+        struct btrfs_root *log = root->log_root;
+        struct btrfs_file_extent_item *fi;
+        struct btrfs_key key;
+        u64 start = em->mod_start;
+        u64 search_start = start;
+        u64 len = em->mod_len;
+        u64 num_bytes;
+        int nritems;
+        int ret;
+
+        if (BTRFS_I(inode)->logged_trans == trans->transid) {
+                ret = __btrfs_drop_extents(trans, log, inode, dst_path, start,
+                                           start + len, NULL, 0);
+                if (ret)
+                        return ret;
+        }
+
+        while (len) {
+                if (args->nr)
+                        goto next_slot;
+again:
+                key.objectid = btrfs_ino(inode);
+                key.type = BTRFS_EXTENT_DATA_KEY;
+                key.offset = search_start;
+
+                ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+                if (ret < 0)
+                        return ret;
+
+                if (ret) {
+                        /*
+                         * A rare case were we can have an em for a section of a
+                         * larger extent so we need to make sure that this em
+                         * falls within the extent we've found.  If not we just
+                         * bail and go back to ye-olde way of doing things but
+                         * it happens often enough in testing that we need to do
+                         * this dance to make sure.
+                         */
+                        do {
+                                if (path->slots[0] == 0) {
+                                        btrfs_release_path(path);
+                                        if (search_start == 0)
+                                                return -ENOENT;
+                                        search_start--;
+                                        goto again;
+                                }
+
+                                path->slots[0]--;
+                                btrfs_item_key_to_cpu(path->nodes[0], &key,
+                                                      path->slots[0]);
+                                if (key.objectid != btrfs_ino(inode) ||
+                                    key.type != BTRFS_EXTENT_DATA_KEY) {
+                                        btrfs_release_path(path);
+                                        return -ENOENT;
+                                }
+                        } while (key.offset > start);
+
+                        fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                                            struct btrfs_file_extent_item);
+                        num_bytes = btrfs_file_extent_num_bytes(path->nodes[0],
+                                                                fi);
+                        if (key.offset + num_bytes <= start) {
+                                btrfs_release_path(path);
+                                return -ENOENT;
+                        }
+                }
+                args->src = path->nodes[0];
+next_slot:
+                btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
+                fi = btrfs_item_ptr(args->src, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                if (args->nr &&
+                    args->start_slot + args->nr == path->slots[0]) {
+                        args->nr++;
+                } else if (args->nr) {
+                        ret = copy_items(trans, inode, dst_path, args->src,
+                                         args->start_slot, args->nr,
+                                         LOG_INODE_ALL);
+                        if (ret)
+                                return ret;
+                        args->nr = 1;
+                        args->start_slot = path->slots[0];
+                } else if (!args->nr) {
+                        args->nr = 1;
+                        args->start_slot = path->slots[0];
+                }
+                nritems = btrfs_header_nritems(path->nodes[0]);
+                path->slots[0]++;
+                num_bytes = btrfs_file_extent_num_bytes(args->src, fi);
+                if (len < num_bytes) {
+                        /* I _think_ this is ok, envision we write to a
+                         * preallocated space that is adjacent to a previously
+                         * written preallocated space that gets merged when we
+                         * mark this preallocated space written.  If we do not
+                         * have the adjacent extent in cache then when we copy
+                         * this extent it could end up being larger than our EM
+                         * thinks it is, which is a-ok, so just set len to 0.
+                         */
+                        len = 0;
+                } else {
+                        len -= num_bytes;
+                }
+                start = key.offset + num_bytes;
+                args->next_offset = start;
+                search_start = start;
+
+                if (path->slots[0] < nritems) {
+                        if (len)
+                                goto next_slot;
+                        break;
+                }
+
+                if (args->nr) {
+                        ret = copy_items(trans, inode, dst_path, args->src,
+                                         args->start_slot, args->nr,
+                                         LOG_INODE_ALL);
+                        if (ret)
+                                return ret;
+                        args->nr = 0;
+                        btrfs_release_path(path);
+                }
+        }
+
+        return 0;
+}
+
+static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
+                                     struct btrfs_root *root,
+                                     struct inode *inode,
+                                     struct btrfs_path *path,
+                                     struct btrfs_path *dst_path)
+{
+        struct log_args args;
+        struct extent_map *em, *n;
+        struct list_head extents;
+        struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
+        u64 test_gen;
+        int ret = 0;
+
+        INIT_LIST_HEAD(&extents);
+
+        memset(&args, 0, sizeof(args));
+
+        write_lock(&tree->lock);
+        test_gen = root->fs_info->last_trans_committed;
+
+        list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
+                list_del_init(&em->list);
+                if (em->generation <= test_gen)
+                        continue;
+                /* Need a ref to keep it from getting evicted from cache */
+                atomic_inc(&em->refs);
+                set_bit(EXTENT_FLAG_LOGGING, &em->flags);
+                list_add_tail(&em->list, &extents);
+        }
+
+        list_sort(NULL, &extents, extent_cmp);
+
+        while (!list_empty(&extents)) {
+                em = list_entry(extents.next, struct extent_map, list);
+
+                list_del_init(&em->list);
+                clear_bit(EXTENT_FLAG_LOGGING, &em->flags);
+
+                /*
+                 * If we had an error we just need to delete everybody from our
+                 * private list.
+                 */
+                if (ret) {
+                        free_extent_map(em);
+                        continue;
+                }
+
+                write_unlock(&tree->lock);
+
+                /*
+                 * If the previous EM and the last extent we left off on aren't
+                 * sequential then we need to copy the items we have and redo
+                 * our search
+                 */
+                if (args.nr && em->mod_start != args.next_offset) {
+                        ret = copy_items(trans, inode, dst_path, args.src,
+                                         args.start_slot, args.nr,
+                                         LOG_INODE_ALL);
+                        if (ret) {
+                                free_extent_map(em);
+                                write_lock(&tree->lock);
+                                continue;
+                        }
+                        btrfs_release_path(path);
+                        args.nr = 0;
+                }
+
+                ret = log_one_extent(trans, inode, root, em, path, dst_path, &args);
+                free_extent_map(em);
+                write_lock(&tree->lock);
+        }
+        WARN_ON(!list_empty(&extents));
+        write_unlock(&tree->lock);
+
+        if (!ret && args.nr)
+                ret = copy_items(trans, inode, dst_path, args.src,
+                                 args.start_slot, args.nr, LOG_INODE_ALL);
+        btrfs_release_path(path);
+        return ret;
+}
+
 /* log a single inode in the tree log.
  * At least one parent directory for this inode must exist in the tree
  * or be logged already.
@@ -2832,6 +3378,7 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
         int nritems;
         int ins_start_slot = 0;
         int ins_nr;
+        bool fast_search = false;
         u64 ino = btrfs_ino(inode);
 
         log = root->log_root;
@@ -2851,21 +3398,23 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
 
         max_key.objectid = ino;
 
-        /* today the code can only do partial logging of directories */
-        if (!S_ISDIR(inode->i_mode))
-            inode_only = LOG_INODE_ALL;
 
+        /* today the code can only do partial logging of directories */
         if (inode_only == LOG_INODE_EXISTS || S_ISDIR(inode->i_mode))
                 max_key.type = BTRFS_XATTR_ITEM_KEY;
         else
                 max_key.type = (u8)-1;
         max_key.offset = (u64)-1;
 
-        ret = btrfs_commit_inode_delayed_items(trans, inode);
-        if (ret) {
-                btrfs_free_path(path);
-                btrfs_free_path(dst_path);
-                return ret;
+        /* Only run delayed items if we are a dir or a new file */
+        if (S_ISDIR(inode->i_mode) ||
+            BTRFS_I(inode)->generation > root->fs_info->last_trans_committed) {
+                ret = btrfs_commit_inode_delayed_items(trans, inode);
+                if (ret) {
+                        btrfs_free_path(path);
+                        btrfs_free_path(dst_path);
+                        return ret;
+                }
         }
 
         mutex_lock(&BTRFS_I(inode)->log_mutex);
@@ -2881,7 +3430,16 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                         max_key_type = BTRFS_XATTR_ITEM_KEY;
                 ret = drop_objectid_items(trans, log, path, ino, max_key_type);
         } else {
-                ret = btrfs_truncate_inode_items(trans, log, inode, 0, 0);
+                if (test_and_clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                       &BTRFS_I(inode)->runtime_flags)) {
+                        ret = btrfs_truncate_inode_items(trans, log,
+                                                         inode, 0, 0);
+                } else {
+                        fast_search = true;
+                        max_key.type = BTRFS_XATTR_ITEM_KEY;
+                        ret = drop_objectid_items(trans, log, path, ino,
+                                                  BTRFS_XATTR_ITEM_KEY);
+                }
         }
         if (ret) {
                 err = ret;
@@ -2912,7 +3470,7 @@ again:
                         goto next_slot;
                 }
 
-                ret = copy_items(trans, log, dst_path, src, ins_start_slot,
+                ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
                                  ins_nr, inode_only);
                 if (ret) {
                         err = ret;
@@ -2930,7 +3488,7 @@ next_slot:
                         goto again;
                 }
                 if (ins_nr) {
-                        ret = copy_items(trans, log, dst_path, src,
+                        ret = copy_items(trans, inode, dst_path, src,
                                          ins_start_slot,
                                          ins_nr, inode_only);
                         if (ret) {
@@ -2951,8 +3509,7 @@ next_slot:
                         break;
         }
         if (ins_nr) {
-                ret = copy_items(trans, log, dst_path, src,
-                                 ins_start_slot,
+                ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
                                  ins_nr, inode_only);
                 if (ret) {
                         err = ret;
@@ -2960,7 +3517,24 @@ next_slot:
                 }
                 ins_nr = 0;
         }
-        WARN_ON(ins_nr);
+
+        if (fast_search) {
+                btrfs_release_path(path);
+                btrfs_release_path(dst_path);
+                ret = btrfs_log_changed_extents(trans, root, inode, path,
+                                                dst_path);
+                if (ret) {
+                        err = ret;
+                        goto out_unlock;
+                }
+        } else {
+                struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
+                struct extent_map *em, *n;
+
+                list_for_each_entry_safe(em, n, &tree->modified_extents, list)
+                        list_del_init(&em->list);
+        }
+
         if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
                 btrfs_release_path(path);
                 btrfs_release_path(dst_path);
@@ -2971,6 +3545,7 @@ next_slot:
                 }
         }
         BTRFS_I(inode)->logged_trans = trans->transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
 out_unlock:
         mutex_unlock(&BTRFS_I(inode)->log_mutex);
 
@@ -3138,7 +3713,7 @@ int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
 end_trans:
         dput(old_parent);
         if (ret < 0) {
-                BUG_ON(ret != -ENOSPC);
+                WARN_ON(ret != -ENOSPC);
                 root->fs_info->last_trans_log_full_commit = trans->transid;
                 ret = 1;
         }
diff --git a/fs/btrfs/ulist.c b/fs/btrfs/ulist.c
index ab942f46b3dd..99be4c138db6 100644
--- a/fs/btrfs/ulist.c
+++ b/fs/btrfs/ulist.c
@@ -143,14 +143,13 @@ EXPORT_SYMBOL(ulist_free);
  * In case of allocation failure -ENOMEM is returned and the ulist stays
  * unaltered.
  */
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-              gfp_t gfp_mask)
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask)
 {
         return ulist_add_merge(ulist, val, aux, NULL, gfp_mask);
 }
 
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                    unsigned long *old_aux, gfp_t gfp_mask)
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                    u64 *old_aux, gfp_t gfp_mask)
 {
         int i;
 
diff --git a/fs/btrfs/ulist.h b/fs/btrfs/ulist.h
index 21bdc8ec8130..21a1963439c3 100644
--- a/fs/btrfs/ulist.h
+++ b/fs/btrfs/ulist.h
@@ -33,7 +33,7 @@ struct ulist_iterator {
  */
 struct ulist_node {
         u64 val;                /* value to store */
-        unsigned long aux;      /* auxiliary value saved along with the val */
+        u64 aux;                /* auxiliary value saved along with the val */
 };
 
 struct ulist {
@@ -65,10 +65,9 @@ void ulist_fini(struct ulist *ulist);
 void ulist_reinit(struct ulist *ulist);
 struct ulist *ulist_alloc(gfp_t gfp_mask);
 void ulist_free(struct ulist *ulist);
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-              gfp_t gfp_mask);
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                    unsigned long *old_aux, gfp_t gfp_mask);
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask);
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                    u64 *old_aux, gfp_t gfp_mask);
 struct ulist_node *ulist_next(struct ulist *ulist,
                               struct ulist_iterator *uiter);
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 88b969aeeb71..029b903a4ae3 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -639,7 +639,7 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
 
                 bdev = blkdev_get_by_path(device->name->str, flags, holder);
                 if (IS_ERR(bdev)) {
-                        printk(KERN_INFO "open %s failed\n", device->name->str);
+                        printk(KERN_INFO "btrfs: open %s failed\n", device->name->str);
                         goto error;
                 }
                 filemap_write_and_wait(bdev->bd_inode->i_mapping);
@@ -1475,6 +1475,9 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                 free_fs_devices(cur_devices);
         }
 
+        root->fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
+
         /*
          * at this point, the device is zero sized.  We want to
          * remove it from the devices list and zero out the old super
@@ -1775,15 +1778,21 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
 
         if (seeding_dev) {
                 ret = init_first_rw_device(trans, root, device);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
                 ret = btrfs_finish_sprout(trans, root);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
         } else {
                 ret = btrfs_add_device(trans, root, device);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
         }
 
         /*
@@ -1793,6 +1802,8 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
         btrfs_clear_space_info_full(root->fs_info);
 
         unlock_chunks(root);
+        root->fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
         ret = btrfs_commit_transaction(trans, root);
 
         if (seeding_dev) {
@@ -1814,7 +1825,6 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
 
 error_trans:
         unlock_chunks(root);
-        btrfs_abort_transaction(trans, root, ret);
         btrfs_end_transaction(trans, root);
         rcu_string_free(device->name);
         kfree(device);
@@ -2804,6 +2814,26 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 }
         }
 
+        if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
+                int num_tolerated_disk_barrier_failures;
+                u64 target = bctl->sys.target;
+
+                num_tolerated_disk_barrier_failures =
+                        btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
+                if (num_tolerated_disk_barrier_failures > 0 &&
+                    (target &
+                     (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
+                      BTRFS_AVAIL_ALLOC_BIT_SINGLE)))
+                        num_tolerated_disk_barrier_failures = 0;
+                else if (num_tolerated_disk_barrier_failures > 1 &&
+                         (target &
+                          (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)))
+                        num_tolerated_disk_barrier_failures = 1;
+
+                fs_info->num_tolerated_disk_barrier_failures =
+                        num_tolerated_disk_barrier_failures;
+        }
+
         ret = insert_balance_item(fs_info->tree_root, bctl);
         if (ret && ret != -EEXIST)
                 goto out;
@@ -2836,6 +2866,11 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 __cancel_balance(fs_info);
         }
 
+        if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
+                fs_info->num_tolerated_disk_barrier_failures =
+                        btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
+        }
+
         wake_up(&fs_info->balance_wait_q);
 
         return ret;
@@ -3608,12 +3643,16 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
         ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map,
                                   &sys_chunk_size, &sys_stripe_size,
                                   sys_chunk_offset, alloc_profile);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         ret = btrfs_add_device(trans, fs_info->chunk_root, device);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         /*
          * Modifying chunk tree needs allocating new blocks from both
@@ -3623,19 +3662,19 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
          */
         ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
                                    chunk_size, stripe_size);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         ret = __finish_chunk_alloc(trans, extent_root, sys_map,
                                    sys_chunk_offset, sys_chunk_size,
                                    sys_stripe_size);
         if (ret)
-                goto abort;
+                btrfs_abort_transaction(trans, root, ret);
 
-        return 0;
+out:
 
-abort:
-        btrfs_abort_transaction(trans, root, ret);
         return ret;
 }
 
@@ -3760,7 +3799,7 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         read_unlock(&em_tree->lock);
 
         if (!em) {
-                printk(KERN_CRIT "unable to find logical %llu len %llu\n",
+                printk(KERN_CRIT "btrfs: unable to find logical %llu len %llu\n",
                        (unsigned long long)logical,
                        (unsigned long long)*length);
                 BUG();
@@ -4217,7 +4256,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
 
         total_devs = bbio->num_stripes;
         if (map_length < length) {
-                printk(KERN_CRIT "mapping failed logical %llu bio len %llu "
+                printk(KERN_CRIT "btrfs: mapping failed logical %llu bio len %llu "
                        "len %llu\n", (unsigned long long)logical,
                        (unsigned long long)length,
                        (unsigned long long)map_length);
diff --git a/fs/btrfs/zlib.c b/fs/btrfs/zlib.c
index 92c20654cc55..9acb846c3e7f 100644
--- a/fs/btrfs/zlib.c
+++ b/fs/btrfs/zlib.c
@@ -97,7 +97,7 @@ static int zlib_compress_pages(struct list_head *ws,
         *total_in = 0;
 
         if (Z_OK != zlib_deflateInit(&workspace->def_strm, 3)) {
-                printk(KERN_WARNING "deflateInit failed\n");
+                printk(KERN_WARNING "btrfs: deflateInit failed\n");
                 ret = -1;
                 goto out;
         }
@@ -125,7 +125,7 @@ static int zlib_compress_pages(struct list_head *ws,
         while (workspace->def_strm.total_in < len) {
                 ret = zlib_deflate(&workspace->def_strm, Z_SYNC_FLUSH);
                 if (ret != Z_OK) {
-                        printk(KERN_DEBUG "btrfs deflate in loop returned %d\n",
+                        printk(KERN_DEBUG "btrfs: deflate in loop returned %d\n",
                                ret);
                         zlib_deflateEnd(&workspace->def_strm);
                         ret = -1;
@@ -252,7 +252,7 @@ static int zlib_decompress_biovec(struct list_head *ws, struct page **pages_in,
         }
 
         if (Z_OK != zlib_inflateInit2(&workspace->inf_strm, wbits)) {
-                printk(KERN_WARNING "inflateInit failed\n");
+                printk(KERN_WARNING "btrfs: inflateInit failed\n");
                 return -1;
         }
         while (workspace->inf_strm.total_in < srclen) {
@@ -336,7 +336,7 @@ static int zlib_decompress(struct list_head *ws, unsigned char *data_in,
         }
 
         if (Z_OK != zlib_inflateInit2(&workspace->inf_strm, wbits)) {
-                printk(KERN_WARNING "inflateInit failed\n");
+                printk(KERN_WARNING "btrfs: inflateInit failed\n");
                 return -1;
         }
 
diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index 53cf2aabce87..71d5d0a5f6b2 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -203,6 +203,27 @@ cifs_strtoUTF16(__le16 *to, const char *from, int len,
         int i;
         wchar_t wchar_to; /* needed to quiet sparse */
 
+        /* special case for utf8 to handle no plane0 chars */
+        if (!strcmp(codepage->charset, "utf8")) {
+                /*
+                 * convert utf8 -> utf16, we assume we have enough space
+                 * as caller should have assumed conversion does not overflow
+                 * in destination len is length in wchar_t units (16bits)
+                 */
+                i  = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
+                                       (wchar_t *) to, len);
+
+                /* if success terminate and exit */
+                if (i >= 0)
+                        goto success;
+                /*
+                 * if fails fall back to UCS encoding as this
+                 * function should not return negative values
+                 * currently can fail only if source contains
+                 * invalid encoded characters
+                 */
+        }
+
         for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
                 charlen = codepage->char2uni(from, len, &wchar_to);
                 if (charlen < 1) {
@@ -215,6 +236,7 @@ cifs_strtoUTF16(__le16 *to, const char *from, int len,
                 put_unaligned_le16(wchar_to, &to[i]);
         }
 
+success:
         put_unaligned_le16(0, &to[i]);
         return i;
 }
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 2fdbe08a7a23..5c670b998ffb 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -67,6 +67,7 @@ enum {
         /* Mount options that take no arguments */
         Opt_user_xattr, Opt_nouser_xattr,
         Opt_forceuid, Opt_noforceuid,
+        Opt_forcegid, Opt_noforcegid,
         Opt_noblocksend, Opt_noautotune,
         Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
         Opt_mapchars, Opt_nomapchars, Opt_sfu,
@@ -117,6 +118,8 @@ static const match_table_t cifs_mount_option_tokens = {
         { Opt_nouser_xattr, "nouser_xattr" },
         { Opt_forceuid, "forceuid" },
         { Opt_noforceuid, "noforceuid" },
+        { Opt_forcegid, "forcegid" },
+        { Opt_noforcegid, "noforcegid" },
         { Opt_noblocksend, "noblocksend" },
         { Opt_noautotune, "noautotune" },
         { Opt_hard, "hard" },
@@ -1195,6 +1198,12 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                 case Opt_noforceuid:
                         override_uid = 0;
                         break;
+                case Opt_forcegid:
+                        override_gid = 1;
+                        break;
+                case Opt_noforcegid:
+                        override_gid = 0;
+                        break;
                 case Opt_noblocksend:
                         vol->noblocksnd = 1;
                         break;
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 2126ab185045..76d974c952fe 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -183,6 +183,12 @@ smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
                 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
                                     n_vec - first_vec, remaining);
                 if (rc == -ENOSPC || rc == -EAGAIN) {
+                        /*
+                         * Catch if a low level driver returns -ENOSPC. This
+                         * WARN_ON will be removed by 3.10 if no one reports
+                         * seeing this.
+                         */
+                        WARN_ON_ONCE(rc == -ENOSPC);
                         i++;
                         if (i >= 14 || (!server->noblocksnd && (i > 2))) {
                                 cERROR(1, "sends on sock %p stuck for 15 "
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index ff487954cd96..d3d8799e2187 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -100,6 +100,10 @@ static int jffs2_sync_fs(struct super_block *sb, int wait)
 {
         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 
+#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
+        cancel_delayed_work_sync(&c->wbuf_dwork);
+#endif
+
         mutex_lock(&c->alloc_sem);
         jffs2_flush_wbuf_pad(c);
         mutex_unlock(&c->alloc_sem);
diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index 6f4529d3697f..a6597d60d76d 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -1044,10 +1044,10 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
         ops.datbuf = NULL;
 
         ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
-        if (ret || ops.oobretlen != ops.ooblen) {
+        if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
                 pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
                        jeb->offset, ops.ooblen, ops.oobretlen, ret);
-                if (!ret)
+                if (!ret || mtd_is_bitflip(ret))
                         ret = -EIO;
                 return ret;
         }
@@ -1086,10 +1086,10 @@ int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
         ops.datbuf = NULL;
 
         ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
-        if (ret || ops.oobretlen != ops.ooblen) {
+        if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
                 pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
                        jeb->offset, ops.ooblen, ops.oobretlen, ret);
-                if (!ret)
+                if (!ret || mtd_is_bitflip(ret))
                         ret = -EIO;
                 return ret;
         }
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index 6ba45d2b99db..1cf1749440ac 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -522,6 +522,8 @@ struct bcma_sflash {
         u32 blocksize;
         u16 numblocks;
         u32 size;
+
+        struct mtd_info *mtd;
 };
 #endif
 
diff --git a/include/linux/dw_dmac.h b/include/linux/dw_dmac.h
index 2412e02d7c0f..e1c8c9e919ac 100644
--- a/include/linux/dw_dmac.h
+++ b/include/linux/dw_dmac.h
@@ -19,6 +19,10 @@
  * @nr_channels: Number of channels supported by hardware (max 8)
  * @is_private: The device channels should be marked as private and not for
  *      by the general purpose DMA channel allocator.
+ * @block_size: Maximum block size supported by the controller
+ * @nr_masters: Number of AHB masters supported by the controller
+ * @data_width: Maximum data width supported by hardware per AHB master
+ *              (0 - 8bits, 1 - 16bits, ..., 5 - 256bits)
  */
 struct dw_dma_platform_data {
         unsigned int    nr_channels;
@@ -29,6 +33,9 @@ struct dw_dma_platform_data {
 #define CHAN_PRIORITY_ASCENDING         0       /* chan0 highest */
 #define CHAN_PRIORITY_DESCENDING        1       /* chan7 highest */
         unsigned char   chan_priority;
+        unsigned short  block_size;
+        unsigned char   nr_masters;
+        unsigned char   data_width[4];
 };
 
 /* bursts size */
diff --git a/include/linux/edma.h b/include/linux/edma.h
new file mode 100644
index 000000000000..a1307e7827e8
--- /dev/null
+++ b/include/linux/edma.h
@@ -0,0 +1,29 @@
+/*
+ * TI EDMA DMA engine driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __LINUX_EDMA_H
+#define __LINUX_EDMA_H
+
+struct dma_chan;
+
+#if defined(CONFIG_TI_EDMA) || defined(CONFIG_TI_EDMA_MODULE)
+bool edma_filter_fn(struct dma_chan *, void *);
+#else
+static inline bool edma_filter_fn(struct dma_chan *chan, void *param)
+{
+        return false;
+}
+#endif
+
+#endif
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 4b27f9f503e4..943550dfe9ea 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -57,6 +57,7 @@ struct mmc_ext_csd {
         unsigned int            sa_timeout;             /* Units: 100ns */
         unsigned int            generic_cmd6_time;      /* Units: 10ms */
         unsigned int            power_off_longtime;     /* Units: ms */
+        u8                      power_off_notification; /* state */
         unsigned int            hs_max_dtr;
 #define MMC_HIGH_26_MAX_DTR     26000000
 #define MMC_HIGH_52_MAX_DTR     52000000
@@ -76,10 +77,13 @@ struct mmc_ext_csd {
         bool                    hpi_en;                 /* HPI enablebit */
         bool                    hpi;                    /* HPI support bit */
         unsigned int            hpi_cmd;                /* cmd used as HPI */
+        bool                    bkops;          /* background support bit */
+        bool                    bkops_en;       /* background enable bit */
         unsigned int            data_sector_size;       /* 512 bytes or 4KB */
         unsigned int            data_tag_unit_size;     /* DATA TAG UNIT size */
         unsigned int            boot_ro_lock;           /* ro lock support */
         bool                    boot_ro_lockable;
+        u8                      raw_exception_status;   /* 53 */
         u8                      raw_partition_support;  /* 160 */
         u8                      raw_erased_mem_count;   /* 181 */
         u8                      raw_ext_csd_structure;  /* 194 */
@@ -93,6 +97,7 @@ struct mmc_ext_csd {
         u8                      raw_sec_erase_mult;     /* 230 */
         u8                      raw_sec_feature_support;/* 231 */
         u8                      raw_trim_mult;          /* 232 */
+        u8                      raw_bkops_status;       /* 246 */
         u8                      raw_sectors[4];         /* 212 - 4 bytes */
 
         unsigned int            feature_support;
@@ -225,7 +230,7 @@ struct mmc_card {
 #define MMC_CARD_SDXC           (1<<6)          /* card is SDXC */
 #define MMC_CARD_REMOVED        (1<<7)          /* card has been removed */
 #define MMC_STATE_HIGHSPEED_200 (1<<8)          /* card is in HS200 mode */
-#define MMC_STATE_SLEEP         (1<<9)          /* card is in sleep state */
+#define MMC_STATE_DOING_BKOPS   (1<<10)         /* card is doing BKOPS */
         unsigned int            quirks;         /* card quirks */
 #define MMC_QUIRK_LENIENT_FN0   (1<<0)          /* allow SDIO FN0 writes outside of the VS CCCR range */
 #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1)    /* use func->cur_blksize */
@@ -241,11 +246,6 @@ struct mmc_card {
 #define MMC_QUIRK_LONG_READ_TIME (1<<9)         /* Data read time > CSD says */
 #define MMC_QUIRK_SEC_ERASE_TRIM_BROKEN (1<<10) /* Skip secure for erase/trim */
                                                 /* byte mode */
-        unsigned int    poweroff_notify_state;  /* eMMC4.5 notify feature */
-#define MMC_NO_POWER_NOTIFICATION       0
-#define MMC_POWERED_ON                  1
-#define MMC_POWEROFF_SHORT              2
-#define MMC_POWEROFF_LONG               3
 
         unsigned int            erase_size;     /* erase size in sectors */
         unsigned int            erase_shift;    /* if erase unit is power 2 */
@@ -392,7 +392,7 @@ static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
 #define mmc_sd_card_uhs(c)      ((c)->state & MMC_STATE_ULTRAHIGHSPEED)
 #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
 #define mmc_card_removed(c)     ((c) && ((c)->state & MMC_CARD_REMOVED))
-#define mmc_card_is_sleep(c)    ((c)->state & MMC_STATE_SLEEP)
+#define mmc_card_doing_bkops(c) ((c)->state & MMC_STATE_DOING_BKOPS)
 
 #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT)
 #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
@@ -404,9 +404,9 @@ static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
 #define mmc_sd_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED)
 #define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC)
 #define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED)
-#define mmc_card_set_sleep(c)   ((c)->state |= MMC_STATE_SLEEP)
+#define mmc_card_set_doing_bkops(c)     ((c)->state |= MMC_STATE_DOING_BKOPS)
+#define mmc_card_clr_doing_bkops(c)     ((c)->state &= ~MMC_STATE_DOING_BKOPS)
 
-#define mmc_card_clr_sleep(c)   ((c)->state &= ~MMC_STATE_SLEEP)
 /*
  * Quirk add/remove for MMC products.
  */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 1b431c728b9a..9b9cdafc7737 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -134,6 +134,8 @@ struct mmc_host;
 struct mmc_card;
 struct mmc_async_req;
 
+extern int mmc_stop_bkops(struct mmc_card *);
+extern int mmc_read_bkops_status(struct mmc_card *);
 extern struct mmc_async_req *mmc_start_req(struct mmc_host *,
                                            struct mmc_async_req *, int *);
 extern int mmc_interrupt_hpi(struct mmc_card *);
@@ -142,6 +144,8 @@ extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
 extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
         struct mmc_command *, int);
+extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
+extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
 
 #define MMC_ERASE_ARG           0x00000000
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 7a7ebd367cfd..7c6a1139d8fa 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -78,6 +78,10 @@ struct mmc_data;
  * @data_offset: Set the offset of DATA register according to VERID.
  * @dev: Device associated with the MMC controller.
  * @pdata: Platform data associated with the MMC controller.
+ * @drv_data: Driver specific data for identified variant of the controller
+ * @priv: Implementation defined private data.
+ * @biu_clk: Pointer to bus interface unit clock instance.
+ * @ciu_clk: Pointer to card interface unit clock instance.
  * @slot: Slots sharing this MMC controller.
  * @fifo_depth: depth of FIFO.
  * @data_shift: log2 of FIFO item size.
@@ -156,8 +160,12 @@ struct dw_mci {
         u32                     fifoth_val;
         u16                     verid;
         u16                     data_offset;
-        struct device           dev;
+        struct device           *dev;
         struct dw_mci_board     *pdata;
+        struct dw_mci_drv_data  *drv_data;
+        void                    *priv;
+        struct clk              *biu_clk;
+        struct clk              *ciu_clk;
         struct dw_mci_slot      *slot[MAX_MCI_SLOTS];
 
         /* FIFO push and pull */
@@ -201,7 +209,8 @@ struct dw_mci_dma_ops {
 #define DW_MCI_QUIRK_HIGHSPEED                  BIT(2)
 /* Unreliable card detection */
 #define DW_MCI_QUIRK_BROKEN_CARD_DETECTION      BIT(3)
-
+/* Write Protect detection not available */
+#define DW_MCI_QUIRK_NO_WRITE_PROTECT           BIT(4)
 
 struct dma_pdata;
 
@@ -218,7 +227,7 @@ struct dw_mci_board {
         u32 num_slots;
 
         u32 quirks; /* Workaround / Quirk flags */
-        unsigned int bus_hz; /* Bus speed */
+        unsigned int bus_hz; /* Clock speed at the cclk_in pad */
 
         unsigned int caps;      /* Capabilities */
         unsigned int caps2;     /* More capabilities */
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index f578a71d82a6..7abb0e1f7bda 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -259,10 +259,6 @@ struct mmc_host {
 #define MMC_CAP2_RO_ACTIVE_HIGH (1 << 11)       /* Write-protect signal active high */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
-        unsigned int        power_notify_type;
-#define MMC_HOST_PW_NOTIFY_NONE         0
-#define MMC_HOST_PW_NOTIFY_SHORT        1
-#define MMC_HOST_PW_NOTIFY_LONG         2
 
 #ifdef CONFIG_MMC_CLKGATE
         int                     clk_requests;   /* internal reference counter */
@@ -300,6 +296,7 @@ struct mmc_host {
 #endif
 
         int                     rescan_disable; /* disable card detection */
+        int                     rescan_entered; /* used with nonremovable devices */
 
         struct mmc_card         *card;          /* device attached to this host */
 
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index d425cab144d9..01e4b394029b 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -139,6 +139,7 @@ static inline bool mmc_op_multi(u32 opcode)
 #define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
 #define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
 #define R1_SWITCH_ERROR         (1 << 7)        /* sx, c */
+#define R1_EXCEPTION_EVENT      (1 << 6)        /* sx, a */
 #define R1_APP_CMD              (1 << 5)        /* sr, c */
 
 #define R1_STATE_IDLE   0
@@ -274,12 +275,15 @@ struct _mmc_csd {
 #define EXT_CSD_FLUSH_CACHE             32      /* W */
 #define EXT_CSD_CACHE_CTRL              33      /* R/W */
 #define EXT_CSD_POWER_OFF_NOTIFICATION  34      /* R/W */
+#define EXT_CSD_EXP_EVENTS_STATUS       54      /* RO */
 #define EXT_CSD_DATA_SECTOR_SIZE        61      /* R */
 #define EXT_CSD_GP_SIZE_MULT            143     /* R/W */
 #define EXT_CSD_PARTITION_ATTRIBUTE     156     /* R/W */
 #define EXT_CSD_PARTITION_SUPPORT       160     /* RO */
 #define EXT_CSD_HPI_MGMT                161     /* R/W */
 #define EXT_CSD_RST_N_FUNCTION          162     /* R/W */
+#define EXT_CSD_BKOPS_EN                163     /* R/W */
+#define EXT_CSD_BKOPS_START             164     /* W */
 #define EXT_CSD_SANITIZE_START          165     /* W */
 #define EXT_CSD_WR_REL_PARAM            166     /* RO */
 #define EXT_CSD_BOOT_WP                 173     /* R/W */
@@ -313,11 +317,13 @@ struct _mmc_csd {
 #define EXT_CSD_PWR_CL_200_360          237     /* RO */
 #define EXT_CSD_PWR_CL_DDR_52_195       238     /* RO */
 #define EXT_CSD_PWR_CL_DDR_52_360       239     /* RO */
+#define EXT_CSD_BKOPS_STATUS            246     /* RO */
 #define EXT_CSD_POWER_OFF_LONG_TIME     247     /* RO */
 #define EXT_CSD_GENERIC_CMD6_TIME       248     /* RO */
 #define EXT_CSD_CACHE_SIZE              249     /* RO, 4 bytes */
 #define EXT_CSD_TAG_UNIT_SIZE           498     /* RO */
 #define EXT_CSD_DATA_TAG_SUPPORT        499     /* RO */
+#define EXT_CSD_BKOPS_SUPPORT           502     /* RO */
 #define EXT_CSD_HPI_FEATURES            503     /* RO */
 
 /*
@@ -378,6 +384,19 @@ struct _mmc_csd {
 #define EXT_CSD_PWR_CL_8BIT_SHIFT       4
 #define EXT_CSD_PWR_CL_4BIT_SHIFT       0
 /*
+ * EXCEPTION_EVENT_STATUS field
+ */
+#define EXT_CSD_URGENT_BKOPS            BIT(0)
+#define EXT_CSD_DYNCAP_NEEDED           BIT(1)
+#define EXT_CSD_SYSPOOL_EXHAUSTED       BIT(2)
+#define EXT_CSD_PACKED_FAILURE          BIT(3)
+
+/*
+ * BKOPS status level
+ */
+#define EXT_CSD_BKOPS_LEVEL_2           0x2
+
+/*
  * MMC_SWITCH access modes
  */
 
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index ac83b105bedd..fa8529a859b8 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -97,7 +97,8 @@ struct sdhci_host {
 
         const struct sdhci_ops *ops;    /* Low level hw interface */
 
-        struct regulator *vmmc; /* Power regulator */
+        struct regulator *vmmc;         /* Power regulator (vmmc) */
+        struct regulator *vqmmc;        /* Signaling regulator (vccq) */
 
         /* Internal data */
         struct mmc_host *mmc;   /* MMC structure */
diff --git a/include/linux/mtd/bbm.h b/include/linux/mtd/bbm.h
index 650ef352f045..211ff67e8b0d 100644
--- a/include/linux/mtd/bbm.h
+++ b/include/linux/mtd/bbm.h
@@ -78,8 +78,6 @@ struct nand_bbt_descr {
 #define NAND_BBT_LASTBLOCK      0x00000010
 /* The bbt is at the given page, else we must scan for the bbt */
 #define NAND_BBT_ABSPAGE        0x00000020
-/* The bbt is at the given page, else we must scan for the bbt */
-#define NAND_BBT_SEARCH         0x00000040
 /* bbt is stored per chip on multichip devices */
 #define NAND_BBT_PERCHIP        0x00000080
 /* bbt has a version counter at offset veroffs */
@@ -110,7 +108,10 @@ struct nand_bbt_descr {
  * OOB area. This option is passed to the default bad block table function.
  */
 #define NAND_BBT_USE_FLASH      0x00020000
-/* Do not store flash based bad block table in OOB area; store it in-band */
+/*
+ * Do not store flash based bad block table marker in the OOB area; store it
+ * in-band.
+ */
 #define NAND_BBT_NO_OOB         0x00040000
 /*
  * Do not write new bad block markers to OOB; useful, e.g., when ECC covers
diff --git a/include/linux/mtd/lpc32xx_mlc.h b/include/linux/mtd/lpc32xx_mlc.h
new file mode 100644
index 000000000000..d91b1e35631e
--- /dev/null
+++ b/include/linux/mtd/lpc32xx_mlc.h
@@ -0,0 +1,20 @@
+/*
+ * Platform data for LPC32xx SoC MLC NAND controller
+ *
+ * Copyright © 2012 Roland Stigge
+ *
+ * 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 __LINUX_MTD_LPC32XX_MLC_H
+#define __LINUX_MTD_LPC32XX_MLC_H
+
+#include <linux/dmaengine.h>
+
+struct lpc32xx_mlc_platform_data {
+        bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
+};
+
+#endif  /* __LINUX_MTD_LPC32XX_MLC_H */
diff --git a/include/linux/mtd/lpc32xx_slc.h b/include/linux/mtd/lpc32xx_slc.h
new file mode 100644
index 000000000000..1169548a1535
--- /dev/null
+++ b/include/linux/mtd/lpc32xx_slc.h
@@ -0,0 +1,20 @@
+/*
+ * Platform data for LPC32xx SoC SLC NAND controller
+ *
+ * Copyright © 2012 Roland Stigge
+ *
+ * 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 __LINUX_MTD_LPC32XX_SLC_H
+#define __LINUX_MTD_LPC32XX_SLC_H
+
+#include <linux/dmaengine.h>
+
+struct lpc32xx_slc_platform_data {
+        bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
+};
+
+#endif  /* __LINUX_MTD_LPC32XX_SLC_H */
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 63dadc0dfb62..81d61e704599 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -265,14 +265,7 @@ int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
                     const u_char *buf);
 
-static inline int mtd_read_oob(struct mtd_info *mtd, loff_t from,
-                               struct mtd_oob_ops *ops)
-{
-        ops->retlen = ops->oobretlen = 0;
-        if (!mtd->_read_oob)
-                return -EOPNOTSUPP;
-        return mtd->_read_oob(mtd, from, ops);
-}
+int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops);
 
 static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to,
                                 struct mtd_oob_ops *ops)
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 57977c640529..24e915957e4f 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -56,7 +56,7 @@ extern int nand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
  * is supported now. If you add a chip with bigger oobsize/page
  * adjust this accordingly.
  */
-#define NAND_MAX_OOBSIZE        576
+#define NAND_MAX_OOBSIZE        640
 #define NAND_MAX_PAGESIZE       8192
 
 /*
@@ -92,6 +92,8 @@ extern int nand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
 #define NAND_CMD_READID         0x90
 #define NAND_CMD_ERASE2         0xd0
 #define NAND_CMD_PARAM          0xec
+#define NAND_CMD_GET_FEATURES   0xee
+#define NAND_CMD_SET_FEATURES   0xef
 #define NAND_CMD_RESET          0xff
 
 #define NAND_CMD_LOCK           0x2a
@@ -185,12 +187,6 @@ typedef enum {
  * This happens with the Renesas AG-AND chips, possibly others.
  */
 #define BBT_AUTO_REFRESH        0x00000080
-/*
- * Chip does not require ready check on read. True
- * for all large page devices, as they do not support
- * autoincrement.
- */
-#define NAND_NO_READRDY         0x00000100
 /* Chip does not allow subpage writes */
 #define NAND_NO_SUBPAGE_WRITE   0x00000200
 
@@ -200,6 +196,9 @@ typedef enum {
 /* Device behaves just like nand, but is readonly */
 #define NAND_ROM                0x00000800
 
+/* Device supports subpage reads */
+#define NAND_SUBPAGE_READ       0x00001000
+
 /* Options valid for Samsung large page devices */
 #define NAND_SAMSUNG_LP_OPTIONS \
         (NAND_NO_PADDING | NAND_CACHEPRG | NAND_COPYBACK)
@@ -208,12 +207,7 @@ typedef enum {
 #define NAND_MUST_PAD(chip) (!(chip->options & NAND_NO_PADDING))
 #define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
 #define NAND_HAS_COPYBACK(chip) ((chip->options & NAND_COPYBACK))
-/* Large page NAND with SOFT_ECC should support subpage reads */
-#define NAND_SUBPAGE_READ(chip) ((chip->ecc.mode == NAND_ECC_SOFT) \
-                                        && (chip->page_shift > 9))
-
-/* Mask to zero out the chip options, which come from the id table */
-#define NAND_CHIPOPTIONS_MSK    0x0000ffff
+#define NAND_HAS_SUBPAGE_READ(chip) ((chip->options & NAND_SUBPAGE_READ))
 
 /* Non chip related options */
 /* This option skips the bbt scan during initialization. */
@@ -237,6 +231,21 @@ typedef enum {
 /* Keep gcc happy */
 struct nand_chip;
 
+/* ONFI timing mode, used in both asynchronous and synchronous mode */
+#define ONFI_TIMING_MODE_0              (1 << 0)
+#define ONFI_TIMING_MODE_1              (1 << 1)
+#define ONFI_TIMING_MODE_2              (1 << 2)
+#define ONFI_TIMING_MODE_3              (1 << 3)
+#define ONFI_TIMING_MODE_4              (1 << 4)
+#define ONFI_TIMING_MODE_5              (1 << 5)
+#define ONFI_TIMING_MODE_UNKNOWN        (1 << 6)
+
+/* ONFI feature address */
+#define ONFI_FEATURE_ADDR_TIMING_MODE   0x1
+
+/* ONFI subfeature parameters length */
+#define ONFI_SUBFEATURE_PARAM_LEN       4
+
 struct nand_onfi_params {
         /* rev info and features block */
         /* 'O' 'N' 'F' 'I'  */
@@ -334,8 +343,10 @@ struct nand_hw_control {
  * @read_page_raw:      function to read a raw page without ECC
  * @write_page_raw:     function to write a raw page without ECC
  * @read_page:  function to read a page according to the ECC generator
- *              requirements.
- * @read_subpage:       function to read parts of the page covered by ECC.
+ *              requirements; returns maximum number of bitflips corrected in
+ *              any single ECC step, 0 if bitflips uncorrectable, -EIO hw error
+ * @read_subpage:       function to read parts of the page covered by ECC;
+ *                      returns same as read_page()
  * @write_page: function to write a page according to the ECC generator
  *              requirements.
  * @write_oob_raw:      function to write chip OOB data without ECC
@@ -361,13 +372,13 @@ struct nand_ecc_ctrl {
                         uint8_t *calc_ecc);
         int (*read_page_raw)(struct mtd_info *mtd, struct nand_chip *chip,
                         uint8_t *buf, int oob_required, int page);
-        void (*write_page_raw)(struct mtd_info *mtd, struct nand_chip *chip,
+        int (*write_page_raw)(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, int oob_required);
         int (*read_page)(struct mtd_info *mtd, struct nand_chip *chip,
                         uint8_t *buf, int oob_required, int page);
         int (*read_subpage)(struct mtd_info *mtd, struct nand_chip *chip,
                         uint32_t offs, uint32_t len, uint8_t *buf);
-        void (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
+        int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, int oob_required);
         int (*write_oob_raw)(struct mtd_info *mtd, struct nand_chip *chip,
                         int page);
@@ -403,8 +414,6 @@ struct nand_buffers {
  * @read_word:          [REPLACEABLE] read one word from the chip
  * @write_buf:          [REPLACEABLE] write data from the buffer to the chip
  * @read_buf:           [REPLACEABLE] read data from the chip into the buffer
- * @verify_buf:         [REPLACEABLE] verify buffer contents against the chip
- *                      data.
  * @select_chip:        [REPLACEABLE] select chip nr
  * @block_bad:          [REPLACEABLE] check, if the block is bad
  * @block_markbad:      [REPLACEABLE] mark the block bad
@@ -462,6 +471,8 @@ struct nand_buffers {
  *                      non 0 if ONFI supported.
  * @onfi_params:        [INTERN] holds the ONFI page parameter when ONFI is
  *                      supported, 0 otherwise.
+ * @onfi_set_features   [REPLACEABLE] set the features for ONFI nand
+ * @onfi_get_features   [REPLACEABLE] get the features for ONFI nand
  * @ecclayout:          [REPLACEABLE] the default ECC placement scheme
  * @bbt:                [INTERN] bad block table pointer
  * @bbt_td:             [REPLACEABLE] bad block table descriptor for flash
@@ -487,7 +498,6 @@ struct nand_chip {
         u16 (*read_word)(struct mtd_info *mtd);
         void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
         void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
-        int (*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
         void (*select_chip)(struct mtd_info *mtd, int chip);
         int (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
         int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
@@ -505,6 +515,10 @@ struct nand_chip {
         int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, int oob_required, int page,
                         int cached, int raw);
+        int (*onfi_set_features)(struct mtd_info *mtd, struct nand_chip *chip,
+                        int feature_addr, uint8_t *subfeature_para);
+        int (*onfi_get_features)(struct mtd_info *mtd, struct nand_chip *chip,
+                        int feature_addr, uint8_t *subfeature_para);
 
         int chip_delay;
         unsigned int options;
@@ -559,6 +573,7 @@ struct nand_chip {
 #define NAND_MFR_MICRON         0x2c
 #define NAND_MFR_AMD            0x01
 #define NAND_MFR_MACRONIX       0xc2
+#define NAND_MFR_EON            0x92
 
 /**
  * struct nand_flash_dev - NAND Flash Device ID Structure
@@ -641,6 +656,7 @@ struct platform_device;
  *                      ALE/CLE/nCE. Also used to write command and address
  * @write_buf:          platform specific function for write buffer
  * @read_buf:           platform specific function for read buffer
+ * @read_byte:          platform specific function to read one byte from chip
  * @priv:               private data to transport driver specific settings
  *
  * All fields are optional and depend on the hardware driver requirements
@@ -677,4 +693,20 @@ struct platform_nand_chip *get_platform_nandchip(struct mtd_info *mtd)
         return chip->priv;
 }
 
+/* return the supported asynchronous timing mode. */
+static inline int onfi_get_async_timing_mode(struct nand_chip *chip)
+{
+        if (!chip->onfi_version)
+                return ONFI_TIMING_MODE_UNKNOWN;
+        return le16_to_cpu(chip->onfi_params.async_timing_mode);
+}
+
+/* return the supported synchronous timing mode. */
+static inline int onfi_get_sync_timing_mode(struct nand_chip *chip)
+{
+        if (!chip->onfi_version)
+                return ONFI_TIMING_MODE_UNKNOWN;
+        return le16_to_cpu(chip->onfi_params.src_sync_timing_mode);
+}
+
 #endif /* __LINUX_MTD_NAND_H */
diff --git a/include/linux/mtd/sh_flctl.h b/include/linux/mtd/sh_flctl.h
index a38e1fa8af01..01e4b15b280e 100644
--- a/include/linux/mtd/sh_flctl.h
+++ b/include/linux/mtd/sh_flctl.h
@@ -49,7 +49,6 @@
 #define FLERRADR(f)             (f->reg + 0x98)
 
 /* FLCMNCR control bits */
-#define ECCPOS2         (0x1 << 25)
 #define _4ECCCNTEN      (0x1 << 24)
 #define _4ECCEN         (0x1 << 23)
 #define _4ECCCORRECT    (0x1 << 22)
@@ -59,9 +58,6 @@
 #define QTSEL_E         (0x1 << 17)
 #define ENDIAN          (0x1 << 16)     /* 1 = little endian */
 #define FCKSEL_E        (0x1 << 15)
-#define ECCPOS_00       (0x00 << 12)
-#define ECCPOS_01       (0x01 << 12)
-#define ECCPOS_02       (0x02 << 12)
 #define ACM_SACCES_MODE (0x01 << 10)
 #define NANWF_E         (0x1 << 9)
 #define SE_D            (0x1 << 8)      /* Spare area disable */
@@ -107,6 +103,14 @@
 #define DOCMD2_E        (0x1 << 17)     /* 2nd cmd stage execute */
 #define DOCMD1_E        (0x1 << 16)     /* 1st cmd stage execute */
 
+/* FLINTDMACR control bits */
+#define ESTERINTE       (0x1 << 24)     /* ECC error interrupt enable */
+#define AC1CLR          (0x1 << 19)     /* ECC FIFO clear */
+#define AC0CLR          (0x1 << 18)     /* Data FIFO clear */
+#define ECERB           (0x1 << 9)      /* ECC error */
+#define STERB           (0x1 << 8)      /* Status error */
+#define STERINTE        (0x1 << 4)      /* Status error enable */
+
 /* FLTRCR control bits */
 #define TRSTRT          (0x1 << 0)      /* translation start */
 #define TREND           (0x1 << 1)      /* translation end */
@@ -125,9 +129,15 @@
 #define _4ECCEND        (0x1 << 1)      /* 4 symbols end */
 #define _4ECCEXST       (0x1 << 0)      /* 4 symbols exist */
 
-#define INIT_FL4ECCRESULT_VAL   0x03FF03FF
 #define LOOP_TIMEOUT_MAX        0x00010000
 
+enum flctl_ecc_res_t {
+        FL_SUCCESS,
+        FL_REPAIRABLE,
+        FL_ERROR,
+        FL_TIMEOUT
+};
+
 struct sh_flctl {
         struct mtd_info         mtd;
         struct nand_chip        chip;
@@ -145,8 +155,7 @@ struct sh_flctl {
         uint32_t erase_ADRCNT;          /* bits of FLCMDCR in ERASE1 cmd */
         uint32_t rw_ADRCNT;     /* bits of FLCMDCR in READ WRITE cmd */
         uint32_t flcmncr_base;  /* base value of FLCMNCR */
-
-        int     hwecc_cant_correct[4];
+        uint32_t flintdmacr_base;       /* irq enable bits */
 
         unsigned page_size:1;   /* NAND page size (0 = 512, 1 = 2048) */
         unsigned hwecc:1;       /* Hardware ECC (0 = disabled, 1 = enabled) */
diff --git a/include/linux/platform_data/mmp_dma.h b/include/linux/platform_data/mmp_dma.h
new file mode 100644
index 000000000000..2a330ec9e2af
--- /dev/null
+++ b/include/linux/platform_data/mmp_dma.h
@@ -0,0 +1,19 @@
+/*
+ *  MMP Platform DMA Management
+ *
+ *  Copyright (c) 2011 Marvell Semiconductors Inc.
+ *
+ *  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 MMP_DMA_H
+#define MMP_DMA_H
+
+struct mmp_dma_platdata {
+        int dma_channels;
+};
+
+#endif /* MMP_DMA_H */
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
index 51ad0995abac..59acd987ed34 100644
--- a/include/linux/platform_data/pxa_sdhci.h
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -49,6 +49,7 @@ struct sdhci_pxa_platdata {
         bool            ext_cd_gpio_invert;
         unsigned int    max_speed;
         unsigned int    host_caps;
+        unsigned int    host_caps2;
         unsigned int    quirks;
         unsigned int    pm_caps;
 };
diff --git a/include/mtd/Kbuild b/include/mtd/Kbuild
index 192f8fb7d546..e69de29bb2d1 100644
--- a/include/mtd/Kbuild
+++ b/include/mtd/Kbuild
@@ -1,5 +0,0 @@
-header-y += inftl-user.h
-header-y += mtd-abi.h
-header-y += mtd-user.h
-header-y += nftl-user.h
-header-y += ubi-user.h
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 91b91e805673..54fab041b22a 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -445,6 +445,7 @@ TRACE_EVENT(btrfs_delayed_tree_ref,
                 __field(        u64,  ref_root          )
                 __field(        int,  level             )
                 __field(        int,  type              )
+                __field(        u64,  seq               )
         ),
 
         TP_fast_assign(
@@ -455,17 +456,19 @@ TRACE_EVENT(btrfs_delayed_tree_ref,
                 __entry->ref_root       = full_ref->root;
                 __entry->level          = full_ref->level;
                 __entry->type           = ref->type;
+                __entry->seq            = ref->seq;
         ),
 
         TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
                   "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
-                  "type = %s",
+                  "type = %s, seq = %llu",
                   (unsigned long long)__entry->bytenr,
                   (unsigned long long)__entry->num_bytes,
                   show_ref_action(__entry->action),
                   show_root_type(__entry->parent),
                   show_root_type(__entry->ref_root),
-                  __entry->level, show_ref_type(__entry->type))
+                  __entry->level, show_ref_type(__entry->type),
+                  (unsigned long long)__entry->seq)
 );
 
 TRACE_EVENT(btrfs_delayed_data_ref,
@@ -485,6 +488,7 @@ TRACE_EVENT(btrfs_delayed_data_ref,
                 __field(        u64,  owner             )
                 __field(        u64,  offset            )
                 __field(        int,  type              )
+                __field(        u64,  seq               )
         ),
 
         TP_fast_assign(
@@ -496,11 +500,12 @@ TRACE_EVENT(btrfs_delayed_data_ref,
                 __entry->owner          = full_ref->objectid;
                 __entry->offset         = full_ref->offset;
                 __entry->type           = ref->type;
+                __entry->seq            = ref->seq;
         ),
 
         TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
                   "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
-                  "offset = %llu, type = %s",
+                  "offset = %llu, type = %s, seq = %llu",
                   (unsigned long long)__entry->bytenr,
                   (unsigned long long)__entry->num_bytes,
                   show_ref_action(__entry->action),
@@ -508,7 +513,8 @@ TRACE_EVENT(btrfs_delayed_data_ref,
                   show_root_type(__entry->ref_root),
                   (unsigned long long)__entry->owner,
                   (unsigned long long)__entry->offset,
-                  show_ref_type(__entry->type))
+                  show_ref_type(__entry->type),
+                  (unsigned long long)__entry->seq)
 );
 
 TRACE_EVENT(btrfs_delayed_ref_head,
diff --git a/include/uapi/mtd/Kbuild b/include/uapi/mtd/Kbuild
index aafaa5aa54d4..5a691e10cd0e 100644
--- a/include/uapi/mtd/Kbuild
+++ b/include/uapi/mtd/Kbuild
@@ -1 +1,6 @@
 # UAPI Header export list
+header-y += inftl-user.h
+header-y += mtd-abi.h
+header-y += mtd-user.h
+header-y += nftl-user.h
+header-y += ubi-user.h
diff --git a/include/mtd/inftl-user.h b/include/uapi/mtd/inftl-user.h
index 8376bd1a9e01..8376bd1a9e01 100644
--- a/include/mtd/inftl-user.h
+++ b/include/uapi/mtd/inftl-user.h
diff --git a/include/mtd/mtd-abi.h b/include/uapi/mtd/mtd-abi.h
index 36eace03b2ac..36eace03b2ac 100644
--- a/include/mtd/mtd-abi.h
+++ b/include/uapi/mtd/mtd-abi.h
diff --git a/include/mtd/mtd-user.h b/include/uapi/mtd/mtd-user.h
index 83327c808c86..83327c808c86 100644
--- a/include/mtd/mtd-user.h
+++ b/include/uapi/mtd/mtd-user.h
diff --git a/include/mtd/nftl-user.h b/include/uapi/mtd/nftl-user.h
index bdeabd86ad99..bdeabd86ad99 100644
--- a/include/mtd/nftl-user.h
+++ b/include/uapi/mtd/nftl-user.h
diff --git a/include/mtd/ubi-user.h b/include/uapi/mtd/ubi-user.h
index 53cae1e11e57..53cae1e11e57 100644
--- a/include/mtd/ubi-user.h
+++ b/include/uapi/mtd/ubi-user.h