Merge tag 'asoc-v3.14' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into for-next

ASoC: Updates  for v3.14

Not a lot going on framework wise, partly due to Christmas at least in
the case of the work I've been doing, but there's been quite a lot of
cleanup activity going on and the usual trickle of new drivers:

 - Update to the generic DMA code to support deferred probe and managed
   resources.
 - New drivers for BCM2835 (used in Raspberry Pi), Tegra with MAX98090
   and Analog Devices AXI I2S and S/PDIF controller IPs.
 - Device tree support for the simple card, max98090 and cs42l52.
 - Conversion of the Samsung drivers to native dmaengine, making them
   multiplatform compatible and hopefully helping keep them more modern
   and up to date.
 - More regmap conversions, including a very welcome one for twl6040
   from Peter Ujfalusi.
 - A big overhaul of the DaVinci drivers also from Peter Ujfalusi.

450 files changed, 9901 insertions, 5195 deletions

diff --git a/Documentation/block/null_blk.txt b/Documentation/block/null_blk.txt
new file mode 100644
index 000000000000..b2830b435895
--- /dev/null
+++ b/Documentation/block/null_blk.txt
@@ -0,0 +1,72 @@
+Null block device driver
+================================================================================
+
+I. Overview
+
+The null block device (/dev/nullb*) is used for benchmarking the various
+block-layer implementations. It emulates a block device of X gigabytes in size.
+The following instances are possible:
+
+  Single-queue block-layer
+    - Request-based.
+    - Single submission queue per device.
+    - Implements IO scheduling algorithms (CFQ, Deadline, noop).
+  Multi-queue block-layer
+    - Request-based.
+    - Configurable submission queues per device.
+  No block-layer (Known as bio-based)
+    - Bio-based. IO requests are submitted directly to the device driver.
+    - Directly accepts bio data structure and returns them.
+
+All of them have a completion queue for each core in the system.
+
+II. Module parameters applicable for all instances:
+
+queue_mode=[0-2]: Default: 2-Multi-queue
+  Selects which block-layer the module should instantiate with.
+
+  0: Bio-based.
+  1: Single-queue.
+  2: Multi-queue.
+
+home_node=[0--nr_nodes]: Default: NUMA_NO_NODE
+  Selects what CPU node the data structures are allocated from.
+
+gb=[Size in GB]: Default: 250GB
+  The size of the device reported to the system.
+
+bs=[Block size (in bytes)]: Default: 512 bytes
+  The block size reported to the system.
+
+nr_devices=[Number of devices]: Default: 2
+  Number of block devices instantiated. They are instantiated as /dev/nullb0,
+  etc.
+
+irq_mode=[0-2]: Default: 1-Soft-irq
+  The completion mode used for completing IOs to the block-layer.
+
+  0: None.
+  1: Soft-irq. Uses IPI to complete IOs across CPU nodes. Simulates the overhead
+     when IOs are issued from another CPU node than the home the device is
+     connected to.
+  2: Timer: Waits a specific period (completion_nsec) for each IO before
+     completion.
+
+completion_nsec=[ns]: Default: 10.000ns
+  Combined with irq_mode=2 (timer). The time each completion event must wait.
+
+submit_queues=[0..nr_cpus]:
+  The number of submission queues attached to the device driver. If unset, it
+  defaults to 1 on single-queue and bio-based instances. For multi-queue,
+  it is ignored when use_per_node_hctx module parameter is 1.
+
+hw_queue_depth=[0..qdepth]: Default: 64
+  The hardware queue depth of the device.
+
+III: Multi-queue specific parameters
+
+use_per_node_hctx=[0/1]: Default: 0
+  0: The number of submit queues are set to the value of the submit_queues
+     parameter.
+  1: The multi-queue block layer is instantiated with a hardware dispatch
+     queue for each CPU node in the system.
diff --git a/Documentation/devicetree/bindings/sound/adi,axi-i2s.txt b/Documentation/devicetree/bindings/sound/adi,axi-i2s.txt
new file mode 100644
index 000000000000..5875ca459ed1
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/adi,axi-i2s.txt
@@ -0,0 +1,31 @@
+ADI AXI-I2S controller
+
+Required properties:
+ - compatible : Must be "adi,axi-i2s-1.00.a"
+ - reg : Must contain I2S core's registers location and length
+ - clocks : Pairs of phandle and specifier referencing the controller's clocks.
+   The controller expects two clocks, the clock used for the AXI interface and
+   the clock used as the sampling rate reference clock sample.
+ - clock-names : "axi" for the clock to the AXI interface, "ref" for the sample
+   rate reference clock.
+ - dmas: Pairs of phandle and specifier for the DMA channels that are used by
+   the core. The core expects two dma channels, one for transmit and one for
+   receive.
+ - dma-names : "tx" for the transmit channel, "rx" for the receive channel.
+
+For more details on the 'dma', 'dma-names', 'clock' and 'clock-names' properties
+please check:
+        * resource-names.txt
+        * clock/clock-bindings.txt
+        * dma/dma.txt
+
+Example:
+
+        i2s: i2s@0x77600000 {
+                compatible = "adi,axi-i2s-1.00.a";
+                reg = <0x77600000 0x1000>;
+                clocks = <&clk 15>, <&audio_clock>;
+                clock-names = "axi", "ref";
+                dmas = <&ps7_dma 0>, <&ps7_dma 1>;
+                dma-names = "tx", "rx";
+        };
diff --git a/Documentation/devicetree/bindings/sound/adi,axi-spdif-tx.txt b/Documentation/devicetree/bindings/sound/adi,axi-spdif-tx.txt
new file mode 100644
index 000000000000..46f344965313
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/adi,axi-spdif-tx.txt
@@ -0,0 +1,30 @@
+ADI AXI-SPDIF controller
+
+Required properties:
+ - compatible : Must be "adi,axi-spdif-1.00.a"
+ - reg : Must contain SPDIF core's registers location and length
+ - clocks : Pairs of phandle and specifier referencing the controller's clocks.
+   The controller expects two clocks, the clock used for the AXI interface and
+   the clock used as the sampling rate reference clock sample.
+ - clock-names: "axi" for the clock to the AXI interface, "ref" for the sample
+   rate reference clock.
+ - dmas: Pairs of phandle and specifier for the DMA channel that is used by
+   the core. The core expects one dma channel for transmit.
+ - dma-names : Must be "tx"
+
+For more details on the 'dma', 'dma-names', 'clock' and 'clock-names' properties
+please check:
+        * resource-names.txt
+        * clock/clock-bindings.txt
+        * dma/dma.txt
+
+Example:
+
+        spdif: spdif@0x77400000 {
+                compatible = "adi,axi-spdif-tx-1.00.a";
+                reg = <0x77600000 0x1000>;
+                clocks = <&clk 15>, <&audio_clock>;
+                clock-names = "axi", "ref";
+                dmas = <&ps7_dma 0>;
+                dma-names = "tx";
+        };
diff --git a/Documentation/devicetree/bindings/sound/bcm2835-i2s.txt b/Documentation/devicetree/bindings/sound/bcm2835-i2s.txt
new file mode 100644
index 000000000000..65783de0aedf
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/bcm2835-i2s.txt
@@ -0,0 +1,25 @@
+* Broadcom BCM2835 SoC I2S/PCM module
+
+Required properties:
+- compatible: "brcm,bcm2835-i2s"
+- reg: A list of base address and size entries:
+        * The first entry should cover the PCM registers
+        * The second entry should cover the PCM clock registers
+- dmas: List of DMA controller phandle and DMA request line ordered pairs.
+- dma-names: Identifier string for each DMA request line in the dmas property.
+  These strings correspond 1:1 with the ordered pairs in dmas.
+
+  One of the DMA channels will be responsible for transmission (should be
+  named "tx") and one for reception (should be named "rx").
+
+Example:
+
+bcm2835_i2s: i2s@7e203000 {
+        compatible = "brcm,bcm2835-i2s";
+        reg = <0x7e203000 0x20>,
+              <0x7e101098 0x02>;
+
+        dmas = <&dma 2>,
+               <&dma 3>;
+        dma-names = "tx", "rx";
+};
diff --git a/Documentation/devicetree/bindings/sound/cs42l52.txt b/Documentation/devicetree/bindings/sound/cs42l52.txt
new file mode 100644
index 000000000000..bc03c9312a19
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/cs42l52.txt
@@ -0,0 +1,46 @@
+CS42L52 audio CODEC
+
+Required properties:
+
+  - compatible : "cirrus,cs42l52"
+
+  - reg : the I2C address of the device for I2C
+
+Optional properties:
+
+  - cirrus,reset-gpio : GPIO controller's phandle and the number
+  of the GPIO used to reset the codec.
+
+  - cirrus,chgfreq-divisor : Values used to set the Charge Pump Frequency.
+  Allowable values of 0x00 through 0x0F. These are raw values written to the
+  register, not the actual frequency. The frequency is determined by the following.
+  Frequency = (64xFs)/(N+2)
+  N = chgfreq_val
+  Fs = Sample Rate (variable)
+
+  - cirrus,mica-differential-cfg : boolean, If present, then the MICA input is configured
+  as a differential input. If not present then the MICA input is configured as
+  Single-ended input. Single-ended mode allows for MIC1 or MIC2 muxing for input.
+
+  - cirrus,micb-differential-cfg : boolean, If present, then the MICB input is configured
+  as a differential input. If not present then the MICB input is configured as
+  Single-ended input. Single-ended mode allows for MIC1 or MIC2 muxing for input.
+
+  - cirrus,micbias-lvl: Set the output voltage level on the MICBIAS Pin
+  0 = 0.5 x VA
+  1 = 0.6 x VA
+  2 = 0.7 x VA
+  3 = 0.8 x VA
+  4 = 0.83 x VA
+  5 = 0.91 x VA
+
+Example:
+
+codec: codec@4a {
+        compatible = "cirrus,cs42l52";
+        reg = <0x4a>;
+        reset-gpio = <&gpio 10 0>;
+        cirrus,chgfreq-divisor = <0x05>;
+        cirrus.mica-differential-cfg;
+        cirrus,micbias-lvl = <5>;
+};
diff --git a/Documentation/devicetree/bindings/sound/davinci-mcasp-audio.txt b/Documentation/devicetree/bindings/sound/davinci-mcasp-audio.txt
index ed785b3f67be..569b26c4a81e 100644
--- a/Documentation/devicetree/bindings/sound/davinci-mcasp-audio.txt
+++ b/Documentation/devicetree/bindings/sound/davinci-mcasp-audio.txt
@@ -4,7 +4,8 @@ Required properties:
 - compatible :
         "ti,dm646x-mcasp-audio" : for DM646x platforms
         "ti,da830-mcasp-audio"  : for both DA830 & DA850 platforms
-        "ti,am33xx-mcasp-audio" : for AM33xx platforms (AM33xx, TI81xx)
+        "ti,am33xx-mcasp-audio" : for AM33xx platforms (AM33xx, AM43xx, TI81xx)
+        "ti,dra7-mcasp-audio"   : for DRA7xx platforms
 
 - reg : Should contain reg specifiers for the entries in the reg-names property.
 - reg-names : Should contain:
@@ -36,7 +37,8 @@ Optional properties:
 - pinctrl-0: Should specify pin control group used for this controller.
 - pinctrl-names: Should contain only one value - "default", for more details
                  please refer to pinctrl-bindings.txt
-  
+- fck_parent : Should contain a valid clock name which will be used as parent
+               for the McASP fck
 
 Example:
 
diff --git a/Documentation/devicetree/bindings/sound/fsl-sai.txt b/Documentation/devicetree/bindings/sound/fsl-sai.txt
new file mode 100644
index 000000000000..98611a6761c0
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/fsl-sai.txt
@@ -0,0 +1,40 @@
+Freescale Synchronous Audio Interface (SAI).
+
+The SAI is based on I2S module that used communicating with audio codecs,
+which provides a synchronous audio interface that supports fullduplex
+serial interfaces with frame synchronization such as I2S, AC97, TDM, and
+codec/DSP interfaces.
+
+
+Required properties:
+- compatible: Compatible list, contains "fsl,vf610-sai".
+- reg: Offset and length of the register set for the device.
+- clocks: Must contain an entry for each entry in clock-names.
+- clock-names : Must include the "sai" entry.
+- dmas : Generic dma devicetree binding as described in
+  Documentation/devicetree/bindings/dma/dma.txt.
+- dma-names : Two dmas have to be defined, "tx" and "rx".
+- pinctrl-names: Must contain a "default" entry.
+- pinctrl-NNN: One property must exist for each entry in pinctrl-names.
+  See ../pinctrl/pinctrl-bindings.txt for details of the property values.
+- big-endian-regs: If this property is absent, the little endian mode will
+  be in use as default, or the big endian mode will be in use for all the
+  device registers.
+- big-endian-data: If this property is absent, the little endian mode will
+  be in use as default, or the big endian mode will be in use for all the
+  fifo data.
+
+Example:
+sai2: sai@40031000 {
+              compatible = "fsl,vf610-sai";
+              reg = <0x40031000 0x1000>;
+              pinctrl-names = "default";
+              pinctrl-0 = <&pinctrl_sai2_1>;
+              clocks = <&clks VF610_CLK_SAI2>;
+              clock-names = "sai";
+              dma-names = "tx", "rx";
+              dmas = <&edma0 0 VF610_EDMA_MUXID0_SAI2_TX>,
+                   <&edma0 0 VF610_EDMA_MUXID0_SAI2_RX>;
+              big-endian-regs;
+              big-endian-data;
+};
diff --git a/Documentation/devicetree/bindings/sound/hdmi.txt b/Documentation/devicetree/bindings/sound/hdmi.txt
new file mode 100644
index 000000000000..31af7bca3099
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/hdmi.txt
@@ -0,0 +1,17 @@
+Device-Tree bindings for dummy HDMI codec
+
+Required properties:
+        - compatible: should be "linux,hdmi-audio".
+
+CODEC output pins:
+  * TX
+
+CODEC input pins:
+  * RX
+
+Example node:
+
+        hdmi_audio: hdmi_audio@0 {
+                compatible = "linux,hdmi-audio";
+                status = "okay";
+        };
diff --git a/Documentation/devicetree/bindings/sound/max98090.txt b/Documentation/devicetree/bindings/sound/max98090.txt
new file mode 100644
index 000000000000..e4c8b36dcf89
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/max98090.txt
@@ -0,0 +1,43 @@
+MAX98090 audio CODEC
+
+This device supports I2C only.
+
+Required properties:
+
+- compatible : "maxim,max98090".
+
+- reg : The I2C address of the device.
+
+- interrupts : The CODEC's interrupt output.
+
+Pins on the device (for linking into audio routes):
+
+  * MIC1
+  * MIC2
+  * DMICL
+  * DMICR
+  * IN1
+  * IN2
+  * IN3
+  * IN4
+  * IN5
+  * IN6
+  * IN12
+  * IN34
+  * IN56
+  * HPL
+  * HPR
+  * SPKL
+  * SPKR
+  * RCVL
+  * RCVR
+  * MICBIAS
+
+Example:
+
+audio-codec@10 {
+        compatible = "maxim,max98090";
+        reg = <0x10>;
+        interrupt-parent = <&gpio>;
+        interrupts = <TEGRA_GPIO(H, 4) GPIO_ACTIVE_HIGH>;
+};
diff --git a/Documentation/devicetree/bindings/sound/nvidia,tegra-audio-max98090.txt b/Documentation/devicetree/bindings/sound/nvidia,tegra-audio-max98090.txt
new file mode 100644
index 000000000000..9c7c55c71370
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/nvidia,tegra-audio-max98090.txt
@@ -0,0 +1,51 @@
+NVIDIA Tegra audio complex, with MAX98090 CODEC
+
+Required properties:
+- compatible : "nvidia,tegra-audio-max98090"
+- clocks : Must contain an entry for each entry in clock-names.
+  See ../clocks/clock-bindings.txt for details.
+- clock-names : Must include the following entries:
+  - pll_a
+  - pll_a_out0
+  - mclk (The Tegra cdev1/extern1 clock, which feeds the CODEC's mclk)
+- nvidia,model : The user-visible name of this sound complex.
+- nvidia,audio-routing : A list of the connections between audio components.
+  Each entry is a pair of strings, the first being the connection's sink,
+  the second being the connection's source. Valid names for sources and
+  sinks are the MAX98090's pins (as documented in its binding), and the jacks
+  on the board:
+
+  * Headphones
+  * Speakers
+  * Mic Jack
+
+- nvidia,i2s-controller : The phandle of the Tegra I2S controller that's
+  connected to the CODEC.
+- nvidia,audio-codec : The phandle of the MAX98090 audio codec.
+
+Optional properties:
+- nvidia,hp-det-gpios : The GPIO that detect headphones are plugged in
+
+Example:
+
+sound {
+        compatible = "nvidia,tegra-audio-max98090-venice2",
+                     "nvidia,tegra-audio-max98090";
+        nvidia,model = "NVIDIA Tegra Venice2";
+
+        nvidia,audio-routing =
+                "Headphones", "HPR",
+                "Headphones", "HPL",
+                "Speakers", "SPKR",
+                "Speakers", "SPKL",
+                "Mic Jack", "MICBIAS",
+                "IN34", "Mic Jack";
+
+        nvidia,i2s-controller = <&tegra_i2s1>;
+        nvidia,audio-codec = <&acodec>;
+
+        clocks = <&tegra_car TEGRA124_CLK_PLL_A>,
+                 <&tegra_car TEGRA124_CLK_PLL_A_OUT0>,
+                 <&tegra_car TEGRA124_CLK_EXTERN1>;
+        clock-names = "pll_a", "pll_a_out0", "mclk";
+};
diff --git a/Documentation/devicetree/bindings/sound/simple-card.txt b/Documentation/devicetree/bindings/sound/simple-card.txt
new file mode 100644
index 000000000000..2ee80c76ca64
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/simple-card.txt
@@ -0,0 +1,77 @@
+Simple-Card:
+
+Simple-Card specifies audio DAI connection of SoC <-> codec.
+
+Required properties:
+
+- compatible                            : "simple-audio-card"
+
+Optional properties:
+
+- simple-audio-card,format              : CPU/CODEC common audio format.
+                                          "i2s", "right_j", "left_j" , "dsp_a"
+                                          "dsp_b", "ac97", "pdm", "msb", "lsb"
+- simple-audio-routing                  : A list of the connections between audio components.
+                                          Each entry is a pair of strings, the first being the
+                                          connection's sink, the second being the connection's
+                                          source.
+
+Required subnodes:
+
+- simple-audio-card,cpu                 : CPU   sub-node
+- simple-audio-card,codec               : CODEC sub-node
+
+Required CPU/CODEC subnodes properties:
+
+- sound-dai                             : phandle and port of CPU/CODEC
+
+Optional CPU/CODEC subnodes properties:
+
+- format                                : CPU/CODEC specific audio format if needed.
+                                          see simple-audio-card,format
+- frame-master                          : bool property. add this if subnode is frame master
+- bitclock-master                       : bool property. add this if subnode is bitclock master
+- bitclock-inversion                    : bool property. add this if subnode has clock inversion
+- frame-inversion                       : bool property. add this if subnode has frame inversion
+- clocks / system-clock-frequency       : specify subnode's clock if needed.
+                                          it can be specified via "clocks" if system has
+                                          clock node (= common clock), or "system-clock-frequency"
+                                          (if system doens't support common clock)
+
+Example:
+
+sound {
+        compatible = "simple-audio-card";
+        simple-audio-card,format = "left_j";
+        simple-audio-routing =
+                "MIC_IN", "Mic Jack",
+                "Headphone Jack", "HP_OUT",
+                "Ext Spk", "LINE_OUT";
+
+        simple-audio-card,cpu {
+                sound-dai = <&sh_fsi2 0>;
+        };
+
+        simple-audio-card,codec {
+                sound-dai = <&ak4648>;
+                bitclock-master;
+                frame-master;
+                clocks = <&osc>;
+        };
+};
+
+&i2c0 {
+        ak4648: ak4648@12 {
+                #sound-dai-cells = <0>;
+                compatible = "asahi-kasei,ak4648";
+                reg = <0x12>;
+        };
+};
+
+sh_fsi2: sh_fsi2@ec230000 {
+        #sound-dai-cells = <1>;
+        compatible = "renesas,sh_fsi2";
+        reg = <0xec230000 0x400>;
+        interrupt-parent = <&gic>;
+        interrupts = <0 146 0x4>;
+};
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 50680a59a2ff..b9e9bd854298 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1529,6 +1529,8 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
 
                         * atapi_dmadir: Enable ATAPI DMADIR bridge support
 
+                        * disable: Disable this device.
+
                         If there are multiple matching configurations changing
                         the same attribute, the last one is used.
 
diff --git a/Documentation/module-signing.txt b/Documentation/module-signing.txt
new file mode 100644
index 000000000000..2b40e04d3c49
--- /dev/null
+++ b/Documentation/module-signing.txt
@@ -0,0 +1,240 @@
+                        ==============================
+                        KERNEL MODULE SIGNING FACILITY
+                        ==============================
+
+CONTENTS
+
+ - Overview.
+ - Configuring module signing.
+ - Generating signing keys.
+ - Public keys in the kernel.
+ - Manually signing modules.
+ - Signed modules and stripping.
+ - Loading signed modules.
+ - Non-valid signatures and unsigned modules.
+ - Administering/protecting the private key.
+
+
+========
+OVERVIEW
+========
+
+The kernel module signing facility cryptographically signs modules during
+installation and then checks the signature upon loading the module.  This
+allows increased kernel security by disallowing the loading of unsigned modules
+or modules signed with an invalid key.  Module signing increases security by
+making it harder to load a malicious module into the kernel.  The module
+signature checking is done by the kernel so that it is not necessary to have
+trusted userspace bits.
+
+This facility uses X.509 ITU-T standard certificates to encode the public keys
+involved.  The signatures are not themselves encoded in any industrial standard
+type.  The facility currently only supports the RSA public key encryption
+standard (though it is pluggable and permits others to be used).  The possible
+hash algorithms that can be used are SHA-1, SHA-224, SHA-256, SHA-384, and
+SHA-512 (the algorithm is selected by data in the signature).
+
+
+==========================
+CONFIGURING MODULE SIGNING
+==========================
+
+The module signing facility is enabled by going to the "Enable Loadable Module
+Support" section of the kernel configuration and turning on
+
+        CONFIG_MODULE_SIG       "Module signature verification"
+
+This has a number of options available:
+
+ (1) "Require modules to be validly signed" (CONFIG_MODULE_SIG_FORCE)
+
+     This specifies how the kernel should deal with a module that has a
+     signature for which the key is not known or a module that is unsigned.
+
+     If this is off (ie. "permissive"), then modules for which the key is not
+     available and modules that are unsigned are permitted, but the kernel will
+     be marked as being tainted.
+
+     If this is on (ie. "restrictive"), only modules that have a valid
+     signature that can be verified by a public key in the kernel's possession
+     will be loaded.  All other modules will generate an error.
+
+     Irrespective of the setting here, if the module has a signature block that
+     cannot be parsed, it will be rejected out of hand.
+
+
+ (2) "Automatically sign all modules" (CONFIG_MODULE_SIG_ALL)
+
+     If this is on then modules will be automatically signed during the
+     modules_install phase of a build.  If this is off, then the modules must
+     be signed manually using:
+
+        scripts/sign-file
+
+
+ (3) "Which hash algorithm should modules be signed with?"
+
+     This presents a choice of which hash algorithm the installation phase will
+     sign the modules with:
+
+        CONFIG_SIG_SHA1         "Sign modules with SHA-1"
+        CONFIG_SIG_SHA224       "Sign modules with SHA-224"
+        CONFIG_SIG_SHA256       "Sign modules with SHA-256"
+        CONFIG_SIG_SHA384       "Sign modules with SHA-384"
+        CONFIG_SIG_SHA512       "Sign modules with SHA-512"
+
+     The algorithm selected here will also be built into the kernel (rather
+     than being a module) so that modules signed with that algorithm can have
+     their signatures checked without causing a dependency loop.
+
+
+=======================
+GENERATING SIGNING KEYS
+=======================
+
+Cryptographic keypairs are required to generate and check signatures.  A
+private key is used to generate a signature and the corresponding public key is
+used to check it.  The private key is only needed during the build, after which
+it can be deleted or stored securely.  The public key gets built into the
+kernel so that it can be used to check the signatures as the modules are
+loaded.
+
+Under normal conditions, the kernel build will automatically generate a new
+keypair using openssl if one does not exist in the files:
+
+        signing_key.priv
+        signing_key.x509
+
+during the building of vmlinux (the public part of the key needs to be built
+into vmlinux) using parameters in the:
+
+        x509.genkey
+
+file (which is also generated if it does not already exist).
+
+It is strongly recommended that you provide your own x509.genkey file.
+
+Most notably, in the x509.genkey file, the req_distinguished_name section
+should be altered from the default:
+
+        [ req_distinguished_name ]
+        O = Magrathea
+        CN = Glacier signing key
+        emailAddress = slartibartfast@magrathea.h2g2
+
+The generated RSA key size can also be set with:
+
+        [ req ]
+        default_bits = 4096
+
+
+It is also possible to manually generate the key private/public files using the
+x509.genkey key generation configuration file in the root node of the Linux
+kernel sources tree and the openssl command.  The following is an example to
+generate the public/private key files:
+
+        openssl req -new -nodes -utf8 -sha256 -days 36500 -batch -x509 \
+           -config x509.genkey -outform DER -out signing_key.x509 \
+           -keyout signing_key.priv
+
+
+=========================
+PUBLIC KEYS IN THE KERNEL
+=========================
+
+The kernel contains a ring of public keys that can be viewed by root.  They're
+in a keyring called ".system_keyring" that can be seen by:
+
+        [root@deneb ~]# cat /proc/keys
+        ...
+        223c7853 I------     1 perm 1f030000     0     0 keyring   .system_keyring: 1
+        302d2d52 I------     1 perm 1f010000     0     0 asymmetri Fedora kernel signing key: d69a84e6bce3d216b979e9505b3e3ef9a7118079: X509.RSA a7118079 []
+        ...
+
+Beyond the public key generated specifically for module signing, any file
+placed in the kernel source root directory or the kernel build root directory
+whose name is suffixed with ".x509" will be assumed to be an X.509 public key
+and will be added to the keyring.
+
+Further, the architecture code may take public keys from a hardware store and
+add those in also (e.g. from the UEFI key database).
+
+Finally, it is possible to add additional public keys by doing:
+
+        keyctl padd asymmetric "" [.system_keyring-ID] <[key-file]
+
+e.g.:
+
+        keyctl padd asymmetric "" 0x223c7853 <my_public_key.x509
+
+Note, however, that the kernel will only permit keys to be added to
+.system_keyring _if_ the new key's X.509 wrapper is validly signed by a key
+that is already resident in the .system_keyring at the time the key was added.
+
+
+=========================
+MANUALLY SIGNING MODULES
+=========================
+
+To manually sign a module, use the scripts/sign-file tool available in
+the Linux kernel source tree.  The script requires 4 arguments:
+
+        1.  The hash algorithm (e.g., sha256)
+        2.  The private key filename
+        3.  The public key filename
+        4.  The kernel module to be signed
+
+The following is an example to sign a kernel module:
+
+        scripts/sign-file sha512 kernel-signkey.priv \
+                kernel-signkey.x509 module.ko
+
+The hash algorithm used does not have to match the one configured, but if it
+doesn't, you should make sure that hash algorithm is either built into the
+kernel or can be loaded without requiring itself.
+
+
+============================
+SIGNED MODULES AND STRIPPING
+============================
+
+A signed module has a digital signature simply appended at the end.  The string
+"~Module signature appended~." at the end of the module's file confirms that a
+signature is present but it does not confirm that the signature is valid!
+
+Signed modules are BRITTLE as the signature is outside of the defined ELF
+container.  Thus they MAY NOT be stripped once the signature is computed and
+attached.  Note the entire module is the signed payload, including any and all
+debug information present at the time of signing.
+
+
+======================
+LOADING SIGNED MODULES
+======================
+
+Modules are loaded with insmod, modprobe, init_module() or finit_module(),
+exactly as for unsigned modules as no processing is done in userspace.  The
+signature checking is all done within the kernel.
+
+
+=========================================
+NON-VALID SIGNATURES AND UNSIGNED MODULES
+=========================================
+
+If CONFIG_MODULE_SIG_FORCE is enabled or enforcemodulesig=1 is supplied on
+the kernel command line, the kernel will only load validly signed modules
+for which it has a public key.   Otherwise, it will also load modules that are
+unsigned.   Any module for which the kernel has a key, but which proves to have
+a signature mismatch will not be permitted to load.
+
+Any module that has an unparseable signature will be rejected.
+
+
+=========================================
+ADMINISTERING/PROTECTING THE PRIVATE KEY
+=========================================
+
+Since the private key is used to sign modules, viruses and malware could use
+the private key to sign modules and compromise the operating system.  The
+private key must be either destroyed or moved to a secure location and not kept
+in the root node of the kernel source tree.
diff --git a/Documentation/networking/ip-sysctl.txt b/Documentation/networking/ip-sysctl.txt
index 3c12d9a7ed00..8a984e994e61 100644
--- a/Documentation/networking/ip-sysctl.txt
+++ b/Documentation/networking/ip-sysctl.txt
@@ -16,8 +16,12 @@ ip_default_ttl - INTEGER
         Default: 64 (as recommended by RFC1700)
 
 ip_no_pmtu_disc - BOOLEAN
-        Disable Path MTU Discovery.
-        default FALSE
+        Disable Path MTU Discovery. If enabled and a
+        fragmentation-required ICMP is received, the PMTU to this
+        destination will be set to min_pmtu (see below). You will need
+        to raise min_pmtu to the smallest interface MTU on your system
+        manually if you want to avoid locally generated fragments.
+        Default: FALSE
 
 min_pmtu - INTEGER
         default 552 - minimum discovered Path MTU
diff --git a/MAINTAINERS b/MAINTAINERS
index 1344816c4c06..d5e4ff328cc7 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1008,6 +1008,8 @@ M:	Santosh Shilimkar <santosh.shilimkar@ti.com>
 L:      linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
 S:      Maintained
 F:      arch/arm/mach-keystone/
+F:      drivers/clk/keystone/
+T:      git git://git.kernel.org/pub/scm/linux/kernel/git/ssantosh/linux-keystone.git
 
 ARM/LOGICPD PXA270 MACHINE SUPPORT
 M:      Lennert Buytenhek <kernel@wantstofly.org>
@@ -3761,9 +3763,11 @@ F:	include/uapi/linux/gigaset_dev.h
 
 GPIO SUBSYSTEM
 M:      Linus Walleij <linus.walleij@linaro.org>
-S:      Maintained
+M:      Alexandre Courbot <gnurou@gmail.com>
 L:      linux-gpio@vger.kernel.org
-F:      Documentation/gpio.txt
+T:      git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio.git
+S:      Maintained
+F:      Documentation/gpio/
 F:      drivers/gpio/
 F:      include/linux/gpio*
 F:      include/asm-generic/gpio.h
@@ -3831,6 +3835,12 @@ T:	git git://linuxtv.org/media_tree.git
 S:      Maintained
 F:      drivers/media/usb/gspca/
 
+GUID PARTITION TABLE (GPT)
+M:      Davidlohr Bueso <davidlohr@hp.com>
+L:      linux-efi@vger.kernel.org
+S:      Maintained
+F:      block/partitions/efi.*
+
 STK1160 USB VIDEO CAPTURE DRIVER
 M:      Ezequiel Garcia <elezegarcia@gmail.com>
 L:      linux-media@vger.kernel.org
@@ -5911,12 +5921,21 @@ M:	Steffen Klassert <steffen.klassert@secunet.com>
 M:      Herbert Xu <herbert@gondor.apana.org.au>
 M:      "David S. Miller" <davem@davemloft.net>
 L:      netdev@vger.kernel.org
-T:      git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git
+T:      git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec.git
+T:      git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec-next.git
 S:      Maintained
 F:      net/xfrm/
 F:      net/key/
 F:      net/ipv4/xfrm*
+F:      net/ipv4/esp4.c
+F:      net/ipv4/ah4.c
+F:      net/ipv4/ipcomp.c
+F:      net/ipv4/ip_vti.c
 F:      net/ipv6/xfrm*
+F:      net/ipv6/esp6.c
+F:      net/ipv6/ah6.c
+F:      net/ipv6/ipcomp6.c
+F:      net/ipv6/ip6_vti.c
 F:      include/uapi/linux/xfrm.h
 F:      include/net/xfrm.h
 
@@ -9571,7 +9590,7 @@ F:	drivers/xen/*swiotlb*
 
 XFS FILESYSTEM
 P:      Silicon Graphics Inc
-M:      Dave Chinner <dchinner@fromorbit.com>
+M:      Dave Chinner <david@fromorbit.com>
 M:      Ben Myers <bpm@sgi.com>
 M:      xfs@oss.sgi.com
 L:      xfs@oss.sgi.com
diff --git a/Makefile b/Makefile
index 858a147fd836..ab80be7a38bc 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 3
 PATCHLEVEL = 13
 SUBLEVEL = 0
-EXTRAVERSION = -rc4
+EXTRAVERSION = -rc6
 NAME = One Giant Leap for Frogkind
 
 # *DOCUMENTATION*
@@ -732,19 +732,15 @@ export mod_strip_cmd
 # Select initial ramdisk compression format, default is gzip(1).
 # This shall be used by the dracut(8) tool while creating an initramfs image.
 #
-INITRD_COMPRESS=gzip
-ifeq ($(CONFIG_RD_BZIP2), y)
-        INITRD_COMPRESS=bzip2
-else ifeq ($(CONFIG_RD_LZMA), y)
-        INITRD_COMPRESS=lzma
-else ifeq ($(CONFIG_RD_XZ), y)
-        INITRD_COMPRESS=xz
-else ifeq ($(CONFIG_RD_LZO), y)
-        INITRD_COMPRESS=lzo
-else ifeq ($(CONFIG_RD_LZ4), y)
-        INITRD_COMPRESS=lz4
-endif
-export INITRD_COMPRESS
+INITRD_COMPRESS-y                  := gzip
+INITRD_COMPRESS-$(CONFIG_RD_BZIP2) := bzip2
+INITRD_COMPRESS-$(CONFIG_RD_LZMA)  := lzma
+INITRD_COMPRESS-$(CONFIG_RD_XZ)    := xz
+INITRD_COMPRESS-$(CONFIG_RD_LZO)   := lzo
+INITRD_COMPRESS-$(CONFIG_RD_LZ4)   := lz4
+# do not export INITRD_COMPRESS, since we didn't actually
+# choose a sane default compression above.
+# export INITRD_COMPRESS := $(INITRD_COMPRESS-y)
 
 ifdef CONFIG_MODULE_SIG_ALL
 MODSECKEY = ./signing_key.priv
diff --git a/arch/arc/include/uapi/asm/unistd.h b/arch/arc/include/uapi/asm/unistd.h
index 68125dd766c6..39e58d1cdf90 100644
--- a/arch/arc/include/uapi/asm/unistd.h
+++ b/arch/arc/include/uapi/asm/unistd.h
@@ -8,7 +8,11 @@
 
 /******** no-legacy-syscalls-ABI *******/
 
-#ifndef _UAPI_ASM_ARC_UNISTD_H
+/*
+ * Non-typical guard macro to enable inclusion twice in ARCH sys.c
+ * That is how the Generic syscall wrapper generator works
+ */
+#if !defined(_UAPI_ASM_ARC_UNISTD_H) || defined(__SYSCALL)
 #define _UAPI_ASM_ARC_UNISTD_H
 
 #define __ARCH_WANT_SYS_EXECVE
@@ -36,4 +40,6 @@ __SYSCALL(__NR_arc_gettls, sys_arc_gettls)
 #define __NR_sysfs              (__NR_arch_specific_syscall + 3)
 __SYSCALL(__NR_sysfs, sys_sysfs)
 
+#undef __SYSCALL
+
 #endif
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index c1f1a7eee953..ba0e23234ecf 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -723,6 +723,7 @@ config ARCH_S3C64XX
         bool "Samsung S3C64XX"
         select ARCH_HAS_CPUFREQ
         select ARCH_REQUIRE_GPIOLIB
+        select ARM_AMBA
         select ARM_VIC
         select CLKDEV_LOOKUP
         select CLKSRC_SAMSUNG_PWM
diff --git a/arch/arm/boot/dts/r8a7790.dtsi b/arch/arm/boot/dts/r8a7790.dtsi
index ee845fad939b..9987dd0e9c59 100644
--- a/arch/arm/boot/dts/r8a7790.dtsi
+++ b/arch/arm/boot/dts/r8a7790.dtsi
@@ -87,9 +87,9 @@
                 interrupts = <1 9 0xf04>;
         };
 
-        gpio0: gpio@ffc40000 {
+        gpio0: gpio@e6050000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc40000 0 0x2c>;
+                reg = <0 0xe6050000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 4 0x4>;
                 #gpio-cells = <2>;
@@ -99,9 +99,9 @@
                 interrupt-controller;
         };
 
-        gpio1: gpio@ffc41000 {
+        gpio1: gpio@e6051000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc41000 0 0x2c>;
+                reg = <0 0xe6051000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 5 0x4>;
                 #gpio-cells = <2>;
@@ -111,9 +111,9 @@
                 interrupt-controller;
         };
 
-        gpio2: gpio@ffc42000 {
+        gpio2: gpio@e6052000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc42000 0 0x2c>;
+                reg = <0 0xe6052000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 6 0x4>;
                 #gpio-cells = <2>;
@@ -123,9 +123,9 @@
                 interrupt-controller;
         };
 
-        gpio3: gpio@ffc43000 {
+        gpio3: gpio@e6053000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc43000 0 0x2c>;
+                reg = <0 0xe6053000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 7 0x4>;
                 #gpio-cells = <2>;
@@ -135,9 +135,9 @@
                 interrupt-controller;
         };
 
-        gpio4: gpio@ffc44000 {
+        gpio4: gpio@e6054000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc44000 0 0x2c>;
+                reg = <0 0xe6054000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 8 0x4>;
                 #gpio-cells = <2>;
@@ -147,9 +147,9 @@
                 interrupt-controller;
         };
 
-        gpio5: gpio@ffc45000 {
+        gpio5: gpio@e6055000 {
                 compatible = "renesas,gpio-r8a7790", "renesas,gpio-rcar";
-                reg = <0 0xffc45000 0 0x2c>;
+                reg = <0 0xe6055000 0 0x50>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 9 0x4>;
                 #gpio-cells = <2>;
@@ -241,7 +241,7 @@
 
         sdhi0: sdhi@ee100000 {
                 compatible = "renesas,sdhi-r8a7790";
-                reg = <0 0xee100000 0 0x100>;
+                reg = <0 0xee100000 0 0x200>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 165 4>;
                 cap-sd-highspeed;
@@ -250,7 +250,7 @@
 
         sdhi1: sdhi@ee120000 {
                 compatible = "renesas,sdhi-r8a7790";
-                reg = <0 0xee120000 0 0x100>;
+                reg = <0 0xee120000 0 0x200>;
                 interrupt-parent = <&gic>;
                 interrupts = <0 166 4>;
                 cap-sd-highspeed;
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
index 4ec8d82b0492..44a59c3abfb0 100644
--- a/arch/arm/mach-omap2/board-ldp.c
+++ b/arch/arm/mach-omap2/board-ldp.c
@@ -242,12 +242,18 @@ static void __init ldp_display_init(void)
 
 static int ldp_twl_gpio_setup(struct device *dev, unsigned gpio, unsigned ngpio)
 {
+        int res;
+
         /* LCD enable GPIO */
         ldp_lcd_pdata.enable_gpio = gpio + 7;
 
         /* Backlight enable GPIO */
         ldp_lcd_pdata.backlight_gpio = gpio + 15;
 
+        res = platform_device_register(&ldp_lcd_device);
+        if (res)
+                pr_err("Unable to register LCD: %d\n", res);
+
         return 0;
 }
 
@@ -346,7 +352,6 @@ static struct omap2_hsmmc_info mmc[] __initdata = {
 
 static struct platform_device *ldp_devices[] __initdata = {
         &ldp_gpio_keys_device,
-        &ldp_lcd_device,
 };
 
 #ifdef CONFIG_OMAP_MUX
diff --git a/arch/arm/mach-omap2/display.c b/arch/arm/mach-omap2/display.c
index 58347bb874a0..4cf165502b35 100644
--- a/arch/arm/mach-omap2/display.c
+++ b/arch/arm/mach-omap2/display.c
@@ -101,13 +101,51 @@ static const struct omap_dss_hwmod_data omap4_dss_hwmod_data[] __initconst = {
         { "dss_hdmi", "omapdss_hdmi", -1 },
 };
 
+static int omap4_dsi_mux_pads(int dsi_id, unsigned lanes)
+{
+        u32 enable_mask, enable_shift;
+        u32 pipd_mask, pipd_shift;
+        u32 reg;
+
+        if (dsi_id == 0) {
+                enable_mask = OMAP4_DSI1_LANEENABLE_MASK;
+                enable_shift = OMAP4_DSI1_LANEENABLE_SHIFT;
+                pipd_mask = OMAP4_DSI1_PIPD_MASK;
+                pipd_shift = OMAP4_DSI1_PIPD_SHIFT;
+        } else if (dsi_id == 1) {
+                enable_mask = OMAP4_DSI2_LANEENABLE_MASK;
+                enable_shift = OMAP4_DSI2_LANEENABLE_SHIFT;
+                pipd_mask = OMAP4_DSI2_PIPD_MASK;
+                pipd_shift = OMAP4_DSI2_PIPD_SHIFT;
+        } else {
+                return -ENODEV;
+        }
+
+        reg = omap4_ctrl_pad_readl(OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_DSIPHY);
+
+        reg &= ~enable_mask;
+        reg &= ~pipd_mask;
+
+        reg |= (lanes << enable_shift) & enable_mask;
+        reg |= (lanes << pipd_shift) & pipd_mask;
+
+        omap4_ctrl_pad_writel(reg, OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_DSIPHY);
+
+        return 0;
+}
+
 static int omap_dsi_enable_pads(int dsi_id, unsigned lane_mask)
 {
+        if (cpu_is_omap44xx())
+                return omap4_dsi_mux_pads(dsi_id, lane_mask);
+
         return 0;
 }
 
 static void omap_dsi_disable_pads(int dsi_id, unsigned lane_mask)
 {
+        if (cpu_is_omap44xx())
+                omap4_dsi_mux_pads(dsi_id, 0);
 }
 
 static int omap_dss_set_min_bus_tput(struct device *dev, unsigned long tput)
diff --git a/arch/arm/mach-omap2/omap_hwmod_2xxx_ipblock_data.c b/arch/arm/mach-omap2/omap_hwmod_2xxx_ipblock_data.c
index 56cebb05509e..d23c77fadb31 100644
--- a/arch/arm/mach-omap2/omap_hwmod_2xxx_ipblock_data.c
+++ b/arch/arm/mach-omap2/omap_hwmod_2xxx_ipblock_data.c
@@ -796,7 +796,7 @@ struct omap_hwmod omap2xxx_counter_32k_hwmod = {
 
 /* gpmc */
 static struct omap_hwmod_irq_info omap2xxx_gpmc_irqs[] = {
-        { .irq = 20 },
+        { .irq = 20 + OMAP_INTC_START, },
         { .irq = -1 }
 };
 
@@ -841,7 +841,7 @@ static struct omap_hwmod_class omap2_rng_hwmod_class = {
 };
 
 static struct omap_hwmod_irq_info omap2_rng_mpu_irqs[] = {
-        { .irq = 52 },
+        { .irq = 52 + OMAP_INTC_START, },
         { .irq = -1 }
 };
 
diff --git a/arch/arm/mach-omap2/omap_hwmod_3xxx_data.c b/arch/arm/mach-omap2/omap_hwmod_3xxx_data.c
index d33742908f97..4c3b1e6df508 100644
--- a/arch/arm/mach-omap2/omap_hwmod_3xxx_data.c
+++ b/arch/arm/mach-omap2/omap_hwmod_3xxx_data.c
@@ -2165,7 +2165,7 @@ static struct omap_hwmod_class omap3xxx_gpmc_hwmod_class = {
 };
 
 static struct omap_hwmod_irq_info omap3xxx_gpmc_irqs[] = {
-        { .irq = 20 },
+        { .irq = 20 + OMAP_INTC_START, },
         { .irq = -1 }
 };
 
@@ -2999,7 +2999,7 @@ static struct omap_mmu_dev_attr mmu_isp_dev_attr = {
 
 static struct omap_hwmod omap3xxx_mmu_isp_hwmod;
 static struct omap_hwmod_irq_info omap3xxx_mmu_isp_irqs[] = {
-        { .irq = 24 },
+        { .irq = 24 + OMAP_INTC_START, },
         { .irq = -1 }
 };
 
@@ -3041,7 +3041,7 @@ static struct omap_mmu_dev_attr mmu_iva_dev_attr = {
 
 static struct omap_hwmod omap3xxx_mmu_iva_hwmod;
 static struct omap_hwmod_irq_info omap3xxx_mmu_iva_irqs[] = {
-        { .irq = 28 },
+        { .irq = 28 + OMAP_INTC_START, },
         { .irq = -1 }
 };
 
diff --git a/arch/arm/mach-omap2/omap_hwmod_7xx_data.c b/arch/arm/mach-omap2/omap_hwmod_7xx_data.c
index db32d5380b11..18f333c440db 100644
--- a/arch/arm/mach-omap2/omap_hwmod_7xx_data.c
+++ b/arch/arm/mach-omap2/omap_hwmod_7xx_data.c
@@ -1637,7 +1637,7 @@ static struct omap_hwmod dra7xx_uart1_hwmod = {
         .class          = &dra7xx_uart_hwmod_class,
         .clkdm_name     = "l4per_clkdm",
         .main_clk       = "uart1_gfclk_mux",
-        .flags          = HWMOD_SWSUP_SIDLE_ACT,
+        .flags          = HWMOD_SWSUP_SIDLE_ACT | DEBUG_OMAP2UART1_FLAGS,
         .prcm = {
                 .omap4 = {
                         .clkctrl_offs = DRA7XX_CM_L4PER_UART1_CLKCTRL_OFFSET,
diff --git a/arch/arm/mach-pxa/include/mach/lubbock.h b/arch/arm/mach-pxa/include/mach/lubbock.h
index 2a086e8373eb..958cd6af9384 100644
--- a/arch/arm/mach-pxa/include/mach/lubbock.h
+++ b/arch/arm/mach-pxa/include/mach/lubbock.h
@@ -10,6 +10,8 @@
  * published by the Free Software Foundation.
  */
 
+#include <mach/irqs.h>
+
 #define LUBBOCK_ETH_PHYS        PXA_CS3_PHYS
 
 #define LUBBOCK_FPGA_PHYS       PXA_CS2_PHYS
diff --git a/arch/arm/mach-s3c64xx/Kconfig b/arch/arm/mach-s3c64xx/Kconfig
index 2cb8dc55b50e..7094bccbae91 100644
--- a/arch/arm/mach-s3c64xx/Kconfig
+++ b/arch/arm/mach-s3c64xx/Kconfig
@@ -17,9 +17,10 @@ config CPU_S3C6410
         help
           Enable S3C6410 CPU support
 
-config S3C64XX_DMA
-        bool "S3C64XX DMA"
-        select S3C_DMA
+config S3C64XX_PL080
+        bool "S3C64XX DMA using generic PL08x driver"
+        select AMBA_PL08X
+        select SAMSUNG_DMADEV
 
 config S3C64XX_SETUP_SDHCI
         bool
diff --git a/arch/arm/mach-s3c64xx/Makefile b/arch/arm/mach-s3c64xx/Makefile
index 6faedcffce04..58069a702a43 100644
--- a/arch/arm/mach-s3c64xx/Makefile
+++ b/arch/arm/mach-s3c64xx/Makefile
@@ -26,7 +26,7 @@ obj-$(CONFIG_CPU_IDLE)		+= cpuidle.o
 
 # DMA support
 
-obj-$(CONFIG_S3C64XX_DMA)       += dma.o
+obj-$(CONFIG_S3C64XX_PL080)     += pl080.o
 
 # Device support
 
diff --git a/arch/arm/mach-s3c64xx/common.h b/arch/arm/mach-s3c64xx/common.h
index bd3bd562011e..7043e7a3a67e 100644
--- a/arch/arm/mach-s3c64xx/common.h
+++ b/arch/arm/mach-s3c64xx/common.h
@@ -58,4 +58,9 @@ int __init s3c64xx_pm_late_initcall(void);
 static inline int s3c64xx_pm_late_initcall(void) { return 0; }
 #endif
 
+#ifdef CONFIG_S3C64XX_PL080
+extern struct pl08x_platform_data s3c64xx_dma0_plat_data;
+extern struct pl08x_platform_data s3c64xx_dma1_plat_data;
+#endif
+
 #endif /* __ARCH_ARM_MACH_S3C64XX_COMMON_H */
diff --git a/arch/arm/mach-s3c64xx/dma.c b/arch/arm/mach-s3c64xx/dma.c
deleted file mode 100644
index 7e22c2113816..000000000000
--- a/arch/arm/mach-s3c64xx/dma.c
+++ /dev/null
@@ -1,762 +0,0 @@
-/* linux/arch/arm/plat-s3c64xx/dma.c
- *
- * Copyright 2009 Openmoko, Inc.
- * Copyright 2009 Simtec Electronics
- *      Ben Dooks <ben@simtec.co.uk>
- *      http://armlinux.simtec.co.uk/
- *
- * S3C64XX DMA core
- *
- * 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.
-*/
-
-/*
- * NOTE: Code in this file is not used when booting with Device Tree support.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/dmapool.h>
-#include <linux/device.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/clk.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/amba/pl080.h>
-#include <linux/of.h>
-
-#include <mach/dma.h>
-#include <mach/map.h>
-#include <mach/irqs.h>
-
-#include "regs-sys.h"
-
-/* dma channel state information */
-
-struct s3c64xx_dmac {
-        struct device           dev;
-        struct clk              *clk;
-        void __iomem            *regs;
-        struct s3c2410_dma_chan *channels;
-        enum dma_ch              chanbase;
-};
-
-/* pool to provide LLI buffers */
-static struct dma_pool *dma_pool;
-
-/* Debug configuration and code */
-
-static unsigned char debug_show_buffs = 0;
-
-static void dbg_showchan(struct s3c2410_dma_chan *chan)
-{
-        pr_debug("DMA%d: %08x->%08x L %08x C %08x,%08x S %08x\n",
-                 chan->number,
-                 readl(chan->regs + PL080_CH_SRC_ADDR),
-                 readl(chan->regs + PL080_CH_DST_ADDR),
-                 readl(chan->regs + PL080_CH_LLI),
-                 readl(chan->regs + PL080_CH_CONTROL),
-                 readl(chan->regs + PL080S_CH_CONTROL2),
-                 readl(chan->regs + PL080S_CH_CONFIG));
-}
-
-static void show_lli(struct pl080s_lli *lli)
-{
-        pr_debug("LLI[%p] %08x->%08x, NL %08x C %08x,%08x\n",
-                 lli, lli->src_addr, lli->dst_addr, lli->next_lli,
-                 lli->control0, lli->control1);
-}
-
-static void dbg_showbuffs(struct s3c2410_dma_chan *chan)
-{
-        struct s3c64xx_dma_buff *ptr;
-        struct s3c64xx_dma_buff *end;
-
-        pr_debug("DMA%d: buffs next %p, curr %p, end %p\n",
-                 chan->number, chan->next, chan->curr, chan->end);
-
-        ptr = chan->next;
-        end = chan->end;
-
-        if (debug_show_buffs) {
-                for (; ptr != NULL; ptr = ptr->next) {
-                        pr_debug("DMA%d: %08x ",
-                                 chan->number, ptr->lli_dma);
-                        show_lli(ptr->lli);
-                }
-        }
-}
-
-/* End of Debug */
-
-static struct s3c2410_dma_chan *s3c64xx_dma_map_channel(unsigned int channel)
-{
-        struct s3c2410_dma_chan *chan;
-        unsigned int start, offs;
-
-        start = 0;
-
-        if (channel >= DMACH_PCM1_TX)
-                start = 8;
-
-        for (offs = 0; offs < 8; offs++) {
-                chan = &s3c2410_chans[start + offs];
-                if (!chan->in_use)
-                        goto found;
-        }
-
-        return NULL;
-
-found:
-        s3c_dma_chan_map[channel] = chan;
-        return chan;
-}
-
-int s3c2410_dma_config(enum dma_ch channel, int xferunit)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-
-        if (chan == NULL)
-                return -EINVAL;
-
-        switch (xferunit) {
-        case 1:
-                chan->hw_width = 0;
-                break;
-        case 2:
-                chan->hw_width = 1;
-                break;
-        case 4:
-                chan->hw_width = 2;
-                break;
-        default:
-                printk(KERN_ERR "%s: illegal width %d\n", __func__, xferunit);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(s3c2410_dma_config);
-
-static void s3c64xx_dma_fill_lli(struct s3c2410_dma_chan *chan,
-                                 struct pl080s_lli *lli,
-                                 dma_addr_t data, int size)
-{
-        dma_addr_t src, dst;
-        u32 control0, control1;
-
-        switch (chan->source) {
-        case DMA_FROM_DEVICE:
-                src = chan->dev_addr;
-                dst = data;
-                control0 = PL080_CONTROL_SRC_AHB2;
-                control0 |= PL080_CONTROL_DST_INCR;
-                break;
-
-        case DMA_TO_DEVICE:
-                src = data;
-                dst = chan->dev_addr;
-                control0 = PL080_CONTROL_DST_AHB2;
-                control0 |= PL080_CONTROL_SRC_INCR;
-                break;
-        default:
-                BUG();
-        }
-
-        /* note, we do not currently setup any of the burst controls */
-
-        control1 = size >> chan->hw_width;      /* size in no of xfers */
-        control0 |= PL080_CONTROL_PROT_SYS;     /* always in priv. mode */
-        control0 |= PL080_CONTROL_TC_IRQ_EN;    /* always fire IRQ */
-        control0 |= (u32)chan->hw_width << PL080_CONTROL_DWIDTH_SHIFT;
-        control0 |= (u32)chan->hw_width << PL080_CONTROL_SWIDTH_SHIFT;
-
-        lli->src_addr = src;
-        lli->dst_addr = dst;
-        lli->next_lli = 0;
-        lli->control0 = control0;
-        lli->control1 = control1;
-}
-
-static void s3c64xx_lli_to_regs(struct s3c2410_dma_chan *chan,
-                                struct pl080s_lli *lli)
-{
-        void __iomem *regs = chan->regs;
-
-        pr_debug("%s: LLI %p => regs\n", __func__, lli);
-        show_lli(lli);
-
-        writel(lli->src_addr, regs + PL080_CH_SRC_ADDR);
-        writel(lli->dst_addr, regs + PL080_CH_DST_ADDR);
-        writel(lli->next_lli, regs + PL080_CH_LLI);
-        writel(lli->control0, regs + PL080_CH_CONTROL);
-        writel(lli->control1, regs + PL080S_CH_CONTROL2);
-}
-
-static int s3c64xx_dma_start(struct s3c2410_dma_chan *chan)
-{
-        struct s3c64xx_dmac *dmac = chan->dmac;
-        u32 config;
-        u32 bit = chan->bit;
-
-        dbg_showchan(chan);
-
-        pr_debug("%s: clearing interrupts\n", __func__);
-
-        /* clear interrupts */
-        writel(bit, dmac->regs + PL080_TC_CLEAR);
-        writel(bit, dmac->regs + PL080_ERR_CLEAR);
-
-        pr_debug("%s: starting channel\n", __func__);
-
-        config = readl(chan->regs + PL080S_CH_CONFIG);
-        config |= PL080_CONFIG_ENABLE;
-        config &= ~PL080_CONFIG_HALT;
-
-        pr_debug("%s: writing config %08x\n", __func__, config);
-        writel(config, chan->regs + PL080S_CH_CONFIG);
-
-        return 0;
-}
-
-static int s3c64xx_dma_stop(struct s3c2410_dma_chan *chan)
-{
-        u32 config;
-        int timeout;
-
-        pr_debug("%s: stopping channel\n", __func__);
-
-        dbg_showchan(chan);
-
-        config = readl(chan->regs + PL080S_CH_CONFIG);
-        config |= PL080_CONFIG_HALT;
-        writel(config, chan->regs + PL080S_CH_CONFIG);
-
-        timeout = 1000;
-        do {
-                config = readl(chan->regs + PL080S_CH_CONFIG);
-                pr_debug("%s: %d - config %08x\n", __func__, timeout, config);
-                if (config & PL080_CONFIG_ACTIVE)
-                        udelay(10);
-                else
-                        break;
-                } while (--timeout > 0);
-
-        if (config & PL080_CONFIG_ACTIVE) {
-                printk(KERN_ERR "%s: channel still active\n", __func__);
-                return -EFAULT;
-        }
-
-        config = readl(chan->regs + PL080S_CH_CONFIG);
-        config &= ~PL080_CONFIG_ENABLE;
-        writel(config, chan->regs + PL080S_CH_CONFIG);
-
-        return 0;
-}
-
-static inline void s3c64xx_dma_bufffdone(struct s3c2410_dma_chan *chan,
-                                         struct s3c64xx_dma_buff *buf,
-                                         enum s3c2410_dma_buffresult result)
-{
-        if (chan->callback_fn != NULL)
-                (chan->callback_fn)(chan, buf->pw, 0, result);
-}
-
-static void s3c64xx_dma_freebuff(struct s3c64xx_dma_buff *buff)
-{
-        dma_pool_free(dma_pool, buff->lli, buff->lli_dma);
-        kfree(buff);
-}
-
-static int s3c64xx_dma_flush(struct s3c2410_dma_chan *chan)
-{
-        struct s3c64xx_dma_buff *buff, *next;
-        u32 config;
-
-        dbg_showchan(chan);
-
-        pr_debug("%s: flushing channel\n", __func__);
-
-        config = readl(chan->regs + PL080S_CH_CONFIG);
-        config &= ~PL080_CONFIG_ENABLE;
-        writel(config, chan->regs + PL080S_CH_CONFIG);
-
-        /* dump all the buffers associated with this channel */
-
-        for (buff = chan->curr; buff != NULL; buff = next) {
-                next = buff->next;
-                pr_debug("%s: buff %p (next %p)\n", __func__, buff, buff->next);
-
-                s3c64xx_dma_bufffdone(chan, buff, S3C2410_RES_ABORT);
-                s3c64xx_dma_freebuff(buff);
-        }
-
-        chan->curr = chan->next = chan->end = NULL;
-
-        return 0;
-}
-
-int s3c2410_dma_ctrl(enum dma_ch channel, enum s3c2410_chan_op op)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-
-        WARN_ON(!chan);
-        if (!chan)
-                return -EINVAL;
-
-        switch (op) {
-        case S3C2410_DMAOP_START:
-                return s3c64xx_dma_start(chan);
-
-        case S3C2410_DMAOP_STOP:
-                return s3c64xx_dma_stop(chan);
-
-        case S3C2410_DMAOP_FLUSH:
-                return s3c64xx_dma_flush(chan);
-
-        /* believe PAUSE/RESUME are no-ops */
-        case S3C2410_DMAOP_PAUSE:
-        case S3C2410_DMAOP_RESUME:
-        case S3C2410_DMAOP_STARTED:
-        case S3C2410_DMAOP_TIMEOUT:
-                return 0;
-        }
-
-        return -ENOENT;
-}
-EXPORT_SYMBOL(s3c2410_dma_ctrl);
-
-/* s3c2410_dma_enque
- *
- */
-
-int s3c2410_dma_enqueue(enum dma_ch channel, void *id,
-                        dma_addr_t data, int size)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-        struct s3c64xx_dma_buff *next;
-        struct s3c64xx_dma_buff *buff;
-        struct pl080s_lli *lli;
-        unsigned long flags;
-        int ret;
-
-        WARN_ON(!chan);
-        if (!chan)
-                return -EINVAL;
-
-        buff = kzalloc(sizeof(struct s3c64xx_dma_buff), GFP_ATOMIC);
-        if (!buff) {
-                printk(KERN_ERR "%s: no memory for buffer\n", __func__);
-                return -ENOMEM;
-        }
-
-        lli = dma_pool_alloc(dma_pool, GFP_ATOMIC, &buff->lli_dma);
-        if (!lli) {
-                printk(KERN_ERR "%s: no memory for lli\n", __func__);
-                ret = -ENOMEM;
-                goto err_buff;
-        }
-
-        pr_debug("%s: buff %p, dp %08x lli (%p, %08x) %d\n",
-                 __func__, buff, data, lli, (u32)buff->lli_dma, size);
-
-        buff->lli = lli;
-        buff->pw = id;
-
-        s3c64xx_dma_fill_lli(chan, lli, data, size);
-
-        local_irq_save(flags);
-
-        if ((next = chan->next) != NULL) {
-                struct s3c64xx_dma_buff *end = chan->end;
-                struct pl080s_lli *endlli = end->lli;
-
-                pr_debug("enquing onto channel\n");
-
-                end->next = buff;
-                endlli->next_lli = buff->lli_dma;
-
-                if (chan->flags & S3C2410_DMAF_CIRCULAR) {
-                        struct s3c64xx_dma_buff *curr = chan->curr;
-                        lli->next_lli = curr->lli_dma;
-                }
-
-                if (next == chan->curr) {
-                        writel(buff->lli_dma, chan->regs + PL080_CH_LLI);
-                        chan->next = buff;
-                }
-
-                show_lli(endlli);
-                chan->end = buff;
-        } else {
-                pr_debug("enquing onto empty channel\n");
-
-                chan->curr = buff;
-                chan->next = buff;
-                chan->end = buff;
-
-                s3c64xx_lli_to_regs(chan, lli);
-        }
-
-        local_irq_restore(flags);
-
-        show_lli(lli);
-
-        dbg_showchan(chan);
-        dbg_showbuffs(chan);
-        return 0;
-
-err_buff:
-        kfree(buff);
-        return ret;
-}
-
-EXPORT_SYMBOL(s3c2410_dma_enqueue);
-
-
-int s3c2410_dma_devconfig(enum dma_ch channel,
-                          enum dma_data_direction source,
-                          unsigned long devaddr)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-        u32 peripheral;
-        u32 config = 0;
-
-        pr_debug("%s: channel %d, source %d, dev %08lx, chan %p\n",
-                 __func__, channel, source, devaddr, chan);
-
-        WARN_ON(!chan);
-        if (!chan)
-                return -EINVAL;
-
-        peripheral = (chan->peripheral & 0xf);
-        chan->source = source;
-        chan->dev_addr = devaddr;
-
-        pr_debug("%s: peripheral %d\n", __func__, peripheral);
-
-        switch (source) {
-        case DMA_FROM_DEVICE:
-                config = 2 << PL080_CONFIG_FLOW_CONTROL_SHIFT;
-                config |= peripheral << PL080_CONFIG_SRC_SEL_SHIFT;
-                break;
-        case DMA_TO_DEVICE:
-                config = 1 << PL080_CONFIG_FLOW_CONTROL_SHIFT;
-                config |= peripheral << PL080_CONFIG_DST_SEL_SHIFT;
-                break;
-        default:
-                printk(KERN_ERR "%s: bad source\n", __func__);
-                return -EINVAL;
-        }
-
-        /* allow TC and ERR interrupts */
-        config |= PL080_CONFIG_TC_IRQ_MASK;
-        config |= PL080_CONFIG_ERR_IRQ_MASK;
-
-        pr_debug("%s: config %08x\n", __func__, config);
-
-        writel(config, chan->regs + PL080S_CH_CONFIG);
-
-        return 0;
-}
-EXPORT_SYMBOL(s3c2410_dma_devconfig);
-
-
-int s3c2410_dma_getposition(enum dma_ch channel,
-                            dma_addr_t *src, dma_addr_t *dst)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-
-        WARN_ON(!chan);
-        if (!chan)
-                return -EINVAL;
-
-        if (src != NULL)
-                *src = readl(chan->regs + PL080_CH_SRC_ADDR);
-
-        if (dst != NULL)
-                *dst = readl(chan->regs + PL080_CH_DST_ADDR);
-
-        return 0;
-}
-EXPORT_SYMBOL(s3c2410_dma_getposition);
-
-/* s3c2410_request_dma
- *
- * get control of an dma channel
-*/
-
-int s3c2410_dma_request(enum dma_ch channel,
-                        struct s3c2410_dma_client *client,
-                        void *dev)
-{
-        struct s3c2410_dma_chan *chan;
-        unsigned long flags;
-
-        pr_debug("dma%d: s3c2410_request_dma: client=%s, dev=%p\n",
-                 channel, client->name, dev);
-
-        local_irq_save(flags);
-
-        chan = s3c64xx_dma_map_channel(channel);
-        if (chan == NULL) {
-                local_irq_restore(flags);
-                return -EBUSY;
-        }
-
-        dbg_showchan(chan);
-
-        chan->client = client;
-        chan->in_use = 1;
-        chan->peripheral = channel;
-        chan->flags = 0;
-
-        local_irq_restore(flags);
-
-        /* need to setup */
-
-        pr_debug("%s: channel initialised, %p\n", __func__, chan);
-
-        return chan->number | DMACH_LOW_LEVEL;
-}
-
-EXPORT_SYMBOL(s3c2410_dma_request);
-
-/* s3c2410_dma_free
- *
- * release the given channel back to the system, will stop and flush
- * any outstanding transfers, and ensure the channel is ready for the
- * next claimant.
- *
- * Note, although a warning is currently printed if the freeing client
- * info is not the same as the registrant's client info, the free is still
- * allowed to go through.
-*/
-
-int s3c2410_dma_free(enum dma_ch channel, struct s3c2410_dma_client *client)
-{
-        struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
-        unsigned long flags;
-
-        if (chan == NULL)
-                return -EINVAL;
-
-        local_irq_save(flags);
-
-        if (chan->client != client) {
-                printk(KERN_WARNING "dma%d: possible free from different client (channel %p, passed %p)\n",
-                       channel, chan->client, client);
-        }
-
-        /* sort out stopping and freeing the channel */
-
-
-        chan->client = NULL;
-        chan->in_use = 0;
-
-        if (!(channel & DMACH_LOW_LEVEL))
-                s3c_dma_chan_map[channel] = NULL;
-
-        local_irq_restore(flags);
-
-        return 0;
-}
-
-EXPORT_SYMBOL(s3c2410_dma_free);
-
-static irqreturn_t s3c64xx_dma_irq(int irq, void *pw)
-{
-        struct s3c64xx_dmac *dmac = pw;
-        struct s3c2410_dma_chan *chan;
-        enum s3c2410_dma_buffresult res;
-        u32 tcstat, errstat;
-        u32 bit;
-        int offs;
-
-        tcstat = readl(dmac->regs + PL080_TC_STATUS);
-        errstat = readl(dmac->regs + PL080_ERR_STATUS);
-
-        for (offs = 0, bit = 1; offs < 8; offs++, bit <<= 1) {
-                struct s3c64xx_dma_buff *buff;
-
-                if (!(errstat & bit) && !(tcstat & bit))
-                        continue;
-
-                chan = dmac->channels + offs;
-                res = S3C2410_RES_ERR;
-
-                if (tcstat & bit) {
-                        writel(bit, dmac->regs + PL080_TC_CLEAR);
-                        res = S3C2410_RES_OK;
-                }
-
-                if (errstat & bit)
-                        writel(bit, dmac->regs + PL080_ERR_CLEAR);
-
-                /* 'next' points to the buffer that is next to the
-                 * currently active buffer.
-                 * For CIRCULAR queues, 'next' will be same as 'curr'
-                 * when 'end' is the active buffer.
-                 */
-                buff = chan->curr;
-                while (buff && buff != chan->next
-                                && buff->next != chan->next)
-                        buff = buff->next;
-
-                if (!buff)
-                        BUG();
-
-                if (buff == chan->next)
-                        buff = chan->end;
-
-                s3c64xx_dma_bufffdone(chan, buff, res);
-
-                /* Free the node and update curr, if non-circular queue */
-                if (!(chan->flags & S3C2410_DMAF_CIRCULAR)) {
-                        chan->curr = buff->next;
-                        s3c64xx_dma_freebuff(buff);
-                }
-
-                /* Update 'next' */
-                buff = chan->next;
-                if (chan->next == chan->end) {
-                        chan->next = chan->curr;
-                        if (!(chan->flags & S3C2410_DMAF_CIRCULAR))
-                                chan->end = NULL;
-                } else {
-                        chan->next = buff->next;
-                }
-        }
-
-        return IRQ_HANDLED;
-}
-
-static struct bus_type dma_subsys = {
-        .name           = "s3c64xx-dma",
-        .dev_name       = "s3c64xx-dma",
-};
-
-static int s3c64xx_dma_init1(int chno, enum dma_ch chbase,
-                             int irq, unsigned int base)
-{
-        struct s3c2410_dma_chan *chptr = &s3c2410_chans[chno];
-        struct s3c64xx_dmac *dmac;
-        char clkname[16];
-        void __iomem *regs;
-        void __iomem *regptr;
-        int err, ch;
-
-        dmac = kzalloc(sizeof(struct s3c64xx_dmac), GFP_KERNEL);
-        if (!dmac) {
-                printk(KERN_ERR "%s: failed to alloc mem\n", __func__);
-                return -ENOMEM;
-        }
-
-        dmac->dev.id = chno / 8;
-        dmac->dev.bus = &dma_subsys;
-
-        err = device_register(&dmac->dev);
-        if (err) {
-                printk(KERN_ERR "%s: failed to register device\n", __func__);
-                goto err_alloc;
-        }
-
-        regs = ioremap(base, 0x200);
-        if (!regs) {
-                printk(KERN_ERR "%s: failed to ioremap()\n", __func__);
-                err = -ENXIO;
-                goto err_dev;
-        }
-
-        snprintf(clkname, sizeof(clkname), "dma%d", dmac->dev.id);
-
-        dmac->clk = clk_get(NULL, clkname);
-        if (IS_ERR(dmac->clk)) {
-                printk(KERN_ERR "%s: failed to get clock %s\n", __func__, clkname);
-                err = PTR_ERR(dmac->clk);
-                goto err_map;
-        }
-
-        clk_prepare_enable(dmac->clk);
-
-        dmac->regs = regs;
-        dmac->chanbase = chbase;
-        dmac->channels = chptr;
-
-        err = request_irq(irq, s3c64xx_dma_irq, 0, "DMA", dmac);
-        if (err < 0) {
-                printk(KERN_ERR "%s: failed to get irq\n", __func__);
-                goto err_clk;
-        }
-
-        regptr = regs + PL080_Cx_BASE(0);
-
-        for (ch = 0; ch < 8; ch++, chptr++) {
-                pr_debug("%s: registering DMA %d (%p)\n",
-                         __func__, chno + ch, regptr);
-
-                chptr->bit = 1 << ch;
-                chptr->number = chno + ch;
-                chptr->dmac = dmac;
-                chptr->regs = regptr;
-                regptr += PL080_Cx_STRIDE;
-        }
-
-        /* for the moment, permanently enable the controller */
-        writel(PL080_CONFIG_ENABLE, regs + PL080_CONFIG);
-
-        printk(KERN_INFO "PL080: IRQ %d, at %p, channels %d..%d\n",
-               irq, regs, chno, chno+8);
-
-        return 0;
-
-err_clk:
-        clk_disable_unprepare(dmac->clk);
-        clk_put(dmac->clk);
-err_map:
-        iounmap(regs);
-err_dev:
-        device_unregister(&dmac->dev);
-err_alloc:
-        kfree(dmac);
-        return err;
-}
-
-static int __init s3c64xx_dma_init(void)
-{
-        int ret;
-
-        /* This driver is not supported when booting with device tree. */
-        if (of_have_populated_dt())
-                return -ENODEV;
-
-        printk(KERN_INFO "%s: Registering DMA channels\n", __func__);
-
-        dma_pool = dma_pool_create("DMA-LLI", NULL, sizeof(struct pl080s_lli), 16, 0);
-        if (!dma_pool) {
-                printk(KERN_ERR "%s: failed to create pool\n", __func__);
-                return -ENOMEM;
-        }
-
-        ret = subsys_system_register(&dma_subsys, NULL);
-        if (ret) {
-                printk(KERN_ERR "%s: failed to create subsys\n", __func__);
-                return -ENOMEM;
-        }
-
-        /* Set all DMA configuration to be DMA, not SDMA */
-        writel(0xffffff, S3C64XX_SDMA_SEL);
-
-        /* Register standard DMA controllers */
-        s3c64xx_dma_init1(0, DMACH_UART0, IRQ_DMA0, 0x75000000);
-        s3c64xx_dma_init1(8, DMACH_PCM1_TX, IRQ_DMA1, 0x75100000);
-
-        return 0;
-}
-
-arch_initcall(s3c64xx_dma_init);
diff --git a/arch/arm/mach-s3c64xx/include/mach/dma.h b/arch/arm/mach-s3c64xx/include/mach/dma.h
index fe1a98cf0e4c..059b1fc85037 100644
--- a/arch/arm/mach-s3c64xx/include/mach/dma.h
+++ b/arch/arm/mach-s3c64xx/include/mach/dma.h
@@ -11,51 +11,48 @@
 #ifndef __ASM_ARCH_DMA_H
 #define __ASM_ARCH_DMA_H __FILE__
 
-#define S3C_DMA_CHANNELS        (16)
+#define S3C64XX_DMA_CHAN(name)          ((unsigned long)(name))
+
+/* DMA0/SDMA0 */
+#define DMACH_UART0             S3C64XX_DMA_CHAN("uart0_tx")
+#define DMACH_UART0_SRC2        S3C64XX_DMA_CHAN("uart0_rx")
+#define DMACH_UART1             S3C64XX_DMA_CHAN("uart1_tx")
+#define DMACH_UART1_SRC2        S3C64XX_DMA_CHAN("uart1_rx")
+#define DMACH_UART2             S3C64XX_DMA_CHAN("uart2_tx")
+#define DMACH_UART2_SRC2        S3C64XX_DMA_CHAN("uart2_rx")
+#define DMACH_UART3             S3C64XX_DMA_CHAN("uart3_tx")
+#define DMACH_UART3_SRC2        S3C64XX_DMA_CHAN("uart3_rx")
+#define DMACH_PCM0_TX           S3C64XX_DMA_CHAN("pcm0_tx")
+#define DMACH_PCM0_RX           S3C64XX_DMA_CHAN("pcm0_rx")
+#define DMACH_I2S0_OUT          S3C64XX_DMA_CHAN("i2s0_tx")
+#define DMACH_I2S0_IN           S3C64XX_DMA_CHAN("i2s0_rx")
+#define DMACH_SPI0_TX           S3C64XX_DMA_CHAN("spi0_tx")
+#define DMACH_SPI0_RX           S3C64XX_DMA_CHAN("spi0_rx")
+#define DMACH_HSI_I2SV40_TX     S3C64XX_DMA_CHAN("i2s2_tx")
+#define DMACH_HSI_I2SV40_RX     S3C64XX_DMA_CHAN("i2s2_rx")
+
+/* DMA1/SDMA1 */
+#define DMACH_PCM1_TX           S3C64XX_DMA_CHAN("pcm1_tx")
+#define DMACH_PCM1_RX           S3C64XX_DMA_CHAN("pcm1_rx")
+#define DMACH_I2S1_OUT          S3C64XX_DMA_CHAN("i2s1_tx")
+#define DMACH_I2S1_IN           S3C64XX_DMA_CHAN("i2s1_rx")
+#define DMACH_SPI1_TX           S3C64XX_DMA_CHAN("spi1_tx")
+#define DMACH_SPI1_RX           S3C64XX_DMA_CHAN("spi1_rx")
+#define DMACH_AC97_PCMOUT       S3C64XX_DMA_CHAN("ac97_out")
+#define DMACH_AC97_PCMIN        S3C64XX_DMA_CHAN("ac97_in")
+#define DMACH_AC97_MICIN        S3C64XX_DMA_CHAN("ac97_mic")
+#define DMACH_PWM               S3C64XX_DMA_CHAN("pwm")
+#define DMACH_IRDA              S3C64XX_DMA_CHAN("irda")
+#define DMACH_EXTERNAL          S3C64XX_DMA_CHAN("external")
+#define DMACH_SECURITY_RX       S3C64XX_DMA_CHAN("sec_rx")
+#define DMACH_SECURITY_TX       S3C64XX_DMA_CHAN("sec_tx")
 
-/* see mach-s3c2410/dma.h for notes on dma channel numbers */
-
-/* Note, for the S3C64XX architecture we keep the DMACH_
- * defines in the order they are allocated to [S]DMA0/[S]DMA1
- * so that is easy to do DHACH_ -> DMA controller conversion
- */
 enum dma_ch {
-        /* DMA0/SDMA0 */
-        DMACH_UART0 = 0,
-        DMACH_UART0_SRC2,
-        DMACH_UART1,
-        DMACH_UART1_SRC2,
-        DMACH_UART2,
-        DMACH_UART2_SRC2,
-        DMACH_UART3,
-        DMACH_UART3_SRC2,
-        DMACH_PCM0_TX,
-        DMACH_PCM0_RX,
-        DMACH_I2S0_OUT,
-        DMACH_I2S0_IN,
-        DMACH_SPI0_TX,
-        DMACH_SPI0_RX,
-        DMACH_HSI_I2SV40_TX,
-        DMACH_HSI_I2SV40_RX,
+        DMACH_MAX = 32
+};
 
-        /* DMA1/SDMA1 */
-        DMACH_PCM1_TX = 16,
-        DMACH_PCM1_RX,
-        DMACH_I2S1_OUT,
-        DMACH_I2S1_IN,
-        DMACH_SPI1_TX,
-        DMACH_SPI1_RX,
-        DMACH_AC97_PCMOUT,
-        DMACH_AC97_PCMIN,
-        DMACH_AC97_MICIN,
-        DMACH_PWM,
-        DMACH_IRDA,
-        DMACH_EXTERNAL,
-        DMACH_RES1,
-        DMACH_RES2,
-        DMACH_SECURITY_RX,      /* SDMA1 only */
-        DMACH_SECURITY_TX,      /* SDMA1 only */
-        DMACH_MAX               /* the end */
+struct s3c2410_dma_client {
+        char    *name;
 };
 
 static inline bool samsung_dma_has_circular(void)
@@ -65,67 +62,10 @@ static inline bool samsung_dma_has_circular(void)
 
 static inline bool samsung_dma_is_dmadev(void)
 {
-        return false;
+        return true;
 }
-#define S3C2410_DMAF_CIRCULAR           (1 << 0)
-
-#include <plat/dma.h>
-
-#define DMACH_LOW_LEVEL (1<<28) /* use this to specifiy hardware ch no */
-
-struct s3c64xx_dma_buff;
-
-/** s3c64xx_dma_buff - S3C64XX DMA buffer descriptor
- * @next: Pointer to next buffer in queue or ring.
- * @pw: Client provided identifier
- * @lli: Pointer to hardware descriptor this buffer is associated with.
- * @lli_dma: Hardare address of the descriptor.
- */
-struct s3c64xx_dma_buff {
-        struct s3c64xx_dma_buff *next;
-
-        void                    *pw;
-        struct pl080s_lli       *lli;
-        dma_addr_t               lli_dma;
-};
-
-struct s3c64xx_dmac;
-
-struct s3c2410_dma_chan {
-        unsigned char            number;      /* number of this dma channel */
-        unsigned char            in_use;      /* channel allocated */
-        unsigned char            bit;         /* bit for enable/disable/etc */
-        unsigned char            hw_width;
-        unsigned char            peripheral;
-
-        unsigned int             flags;
-        enum dma_data_direction  source;
-
-
-        dma_addr_t              dev_addr;
-
-        struct s3c2410_dma_client *client;
-        struct s3c64xx_dmac     *dmac;          /* pointer to controller */
-
-        void __iomem            *regs;
-
-        /* cdriver callbacks */
-        s3c2410_dma_cbfn_t       callback_fn;   /* buffer done callback */
-        s3c2410_dma_opfn_t       op_fn;         /* channel op callback */
-
-        /* buffer list and information */
-        struct s3c64xx_dma_buff *curr;          /* current dma buffer */
-        struct s3c64xx_dma_buff *next;          /* next buffer to load */
-        struct s3c64xx_dma_buff *end;           /* end of queue */
-
-        /* note, when channel is running in circular mode, curr is the
-         * first buffer enqueued, end is the last and curr is where the
-         * last buffer-done event is set-at. The buffers are not freed
-         * and the last buffer hardware descriptor points back to the
-         * first.
-         */
-};
 
-#include <plat/dma-core.h>
+#include <linux/amba/pl08x.h>
+#include <plat/dma-ops.h>
 
 #endif /* __ASM_ARCH_IRQ_H */
diff --git a/arch/arm/mach-s3c64xx/mach-s3c64xx-dt.c b/arch/arm/mach-s3c64xx/mach-s3c64xx-dt.c
index 7eb9a10fc1af..2fddf38192df 100644
--- a/arch/arm/mach-s3c64xx/mach-s3c64xx-dt.c
+++ b/arch/arm/mach-s3c64xx/mach-s3c64xx-dt.c
@@ -8,8 +8,6 @@
  * published by the Free Software Foundation.
 */
 
-#include <linux/clk-provider.h>
-#include <linux/irqchip.h>
 #include <linux/of_platform.h>
 
 #include <asm/mach/arch.h>
@@ -48,15 +46,9 @@ static void __init s3c64xx_dt_map_io(void)
                 panic("SoC is not S3C64xx!");
 }
 
-static void __init s3c64xx_dt_init_irq(void)
-{
-        of_clk_init(NULL);
-        samsung_wdt_reset_of_init();
-        irqchip_init();
-};
-
 static void __init s3c64xx_dt_init_machine(void)
 {
+        samsung_wdt_reset_of_init();
         of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
 }
 
@@ -79,7 +71,6 @@ DT_MACHINE_START(S3C6400_DT, "Samsung S3C64xx (Flattened Device Tree)")
         /* Maintainer: Tomasz Figa <tomasz.figa@gmail.com> */
         .dt_compat      = s3c64xx_dt_compat,
         .map_io         = s3c64xx_dt_map_io,
-        .init_irq       = s3c64xx_dt_init_irq,
         .init_machine   = s3c64xx_dt_init_machine,
         .restart        = s3c64xx_dt_restart,
 MACHINE_END
diff --git a/arch/arm/mach-s3c64xx/pl080.c b/arch/arm/mach-s3c64xx/pl080.c
new file mode 100644
index 000000000000..901a984bddc2
--- /dev/null
+++ b/arch/arm/mach-s3c64xx/pl080.c
@@ -0,0 +1,244 @@
+/*
+ * Samsung's S3C64XX generic DMA support using amba-pl08x driver.
+ *
+ * Copyright (c) 2013 Tomasz Figa <tomasz.figa@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/kernel.h>
+#include <linux/amba/bus.h>
+#include <linux/amba/pl080.h>
+#include <linux/amba/pl08x.h>
+#include <linux/of.h>
+
+#include <mach/irqs.h>
+#include <mach/map.h>
+
+#include "regs-sys.h"
+
+static int pl08x_get_xfer_signal(const struct pl08x_channel_data *cd)
+{
+        return cd->min_signal;
+}
+
+static void pl08x_put_xfer_signal(const struct pl08x_channel_data *cd, int ch)
+{
+}
+
+/*
+ * DMA0
+ */
+
+static struct pl08x_channel_data s3c64xx_dma0_info[] = {
+        {
+                .bus_id = "uart0_tx",
+                .min_signal = 0,
+                .max_signal = 0,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart0_rx",
+                .min_signal = 1,
+                .max_signal = 1,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart1_tx",
+                .min_signal = 2,
+                .max_signal = 2,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart1_rx",
+                .min_signal = 3,
+                .max_signal = 3,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart2_tx",
+                .min_signal = 4,
+                .max_signal = 4,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart2_rx",
+                .min_signal = 5,
+                .max_signal = 5,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart3_tx",
+                .min_signal = 6,
+                .max_signal = 6,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "uart3_rx",
+                .min_signal = 7,
+                .max_signal = 7,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "pcm0_tx",
+                .min_signal = 8,
+                .max_signal = 8,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "pcm0_rx",
+                .min_signal = 9,
+                .max_signal = 9,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s0_tx",
+                .min_signal = 10,
+                .max_signal = 10,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s0_rx",
+                .min_signal = 11,
+                .max_signal = 11,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "spi0_tx",
+                .min_signal = 12,
+                .max_signal = 12,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "spi0_rx",
+                .min_signal = 13,
+                .max_signal = 13,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s2_tx",
+                .min_signal = 14,
+                .max_signal = 14,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s2_rx",
+                .min_signal = 15,
+                .max_signal = 15,
+                .periph_buses = PL08X_AHB2,
+        }
+};
+
+struct pl08x_platform_data s3c64xx_dma0_plat_data = {
+        .memcpy_channel = {
+                .bus_id = "memcpy",
+                .cctl_memcpy =
+                        (PL080_BSIZE_4 << PL080_CONTROL_SB_SIZE_SHIFT |
+                        PL080_BSIZE_4 << PL080_CONTROL_DB_SIZE_SHIFT |
+                        PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT |
+                        PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT |
+                        PL080_CONTROL_PROT_BUFF | PL080_CONTROL_PROT_CACHE |
+                        PL080_CONTROL_PROT_SYS),
+        },
+        .lli_buses = PL08X_AHB1,
+        .mem_buses = PL08X_AHB1,
+        .get_xfer_signal = pl08x_get_xfer_signal,
+        .put_xfer_signal = pl08x_put_xfer_signal,
+        .slave_channels = s3c64xx_dma0_info,
+        .num_slave_channels = ARRAY_SIZE(s3c64xx_dma0_info),
+};
+
+static AMBA_AHB_DEVICE(s3c64xx_dma0, "dma-pl080s.0", 0,
+                        0x75000000, {IRQ_DMA0}, &s3c64xx_dma0_plat_data);
+
+/*
+ * DMA1
+ */
+
+static struct pl08x_channel_data s3c64xx_dma1_info[] = {
+        {
+                .bus_id = "pcm1_tx",
+                .min_signal = 0,
+                .max_signal = 0,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "pcm1_rx",
+                .min_signal = 1,
+                .max_signal = 1,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s1_tx",
+                .min_signal = 2,
+                .max_signal = 2,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "i2s1_rx",
+                .min_signal = 3,
+                .max_signal = 3,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "spi1_tx",
+                .min_signal = 4,
+                .max_signal = 4,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "spi1_rx",
+                .min_signal = 5,
+                .max_signal = 5,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "ac97_out",
+                .min_signal = 6,
+                .max_signal = 6,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "ac97_in",
+                .min_signal = 7,
+                .max_signal = 7,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "ac97_mic",
+                .min_signal = 8,
+                .max_signal = 8,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "pwm",
+                .min_signal = 9,
+                .max_signal = 9,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "irda",
+                .min_signal = 10,
+                .max_signal = 10,
+                .periph_buses = PL08X_AHB2,
+        }, {
+                .bus_id = "external",
+                .min_signal = 11,
+                .max_signal = 11,
+                .periph_buses = PL08X_AHB2,
+        },
+};
+
+struct pl08x_platform_data s3c64xx_dma1_plat_data = {
+        .memcpy_channel = {
+                .bus_id = "memcpy",
+                .cctl_memcpy =
+                        (PL080_BSIZE_4 << PL080_CONTROL_SB_SIZE_SHIFT |
+                        PL080_BSIZE_4 << PL080_CONTROL_DB_SIZE_SHIFT |
+                        PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT |
+                        PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT |
+                        PL080_CONTROL_PROT_BUFF | PL080_CONTROL_PROT_CACHE |
+                        PL080_CONTROL_PROT_SYS),
+        },
+        .lli_buses = PL08X_AHB1,
+        .mem_buses = PL08X_AHB1,
+        .get_xfer_signal = pl08x_get_xfer_signal,
+        .put_xfer_signal = pl08x_put_xfer_signal,
+        .slave_channels = s3c64xx_dma1_info,
+        .num_slave_channels = ARRAY_SIZE(s3c64xx_dma1_info),
+};
+
+static AMBA_AHB_DEVICE(s3c64xx_dma1, "dma-pl080s.1", 0,
+                        0x75100000, {IRQ_DMA1}, &s3c64xx_dma1_plat_data);
+
+static int __init s3c64xx_pl080_init(void)
+{
+        /* Set all DMA configuration to be DMA, not SDMA */
+        writel(0xffffff, S3C64XX_SDMA_SEL);
+
+        if (of_have_populated_dt())
+                return 0;
+
+        amba_device_register(&s3c64xx_dma0_device, &iomem_resource);
+        amba_device_register(&s3c64xx_dma1_device, &iomem_resource);
+
+        return 0;
+}
+arch_initcall(s3c64xx_pl080_init);
diff --git a/arch/arm/mach-shmobile/board-armadillo800eva.c b/arch/arm/mach-shmobile/board-armadillo800eva.c
index 958e3cbf0ac2..c18689123023 100644
--- a/arch/arm/mach-shmobile/board-armadillo800eva.c
+++ b/arch/arm/mach-shmobile/board-armadillo800eva.c
@@ -614,6 +614,11 @@ static struct regulator_consumer_supply fixed3v3_power_consumers[] = {
         REGULATOR_SUPPLY("vqmmc", "sh_mmcif"),
 };
 
+/* Fixed 3.3V regulator used by LCD backlight */
+static struct regulator_consumer_supply fixed5v0_power_consumers[] = {
+        REGULATOR_SUPPLY("power", "pwm-backlight.0"),
+};
+
 /* Fixed 3.3V regulator to be used by SDHI0 */
 static struct regulator_consumer_supply vcc_sdhi0_consumers[] = {
         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
@@ -1196,6 +1201,8 @@ static void __init eva_init(void)
 
         regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers,
                                      ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
+        regulator_register_always_on(3, "fixed-5.0V", fixed5v0_power_consumers,
+                                     ARRAY_SIZE(fixed5v0_power_consumers), 5000000);
 
         pinctrl_register_mappings(eva_pinctrl_map, ARRAY_SIZE(eva_pinctrl_map));
         pwm_add_table(pwm_lookup, ARRAY_SIZE(pwm_lookup));
diff --git a/arch/arm/mach-shmobile/board-bockw.c b/arch/arm/mach-shmobile/board-bockw.c
index 38611526fe9a..3c4995aebd22 100644
--- a/arch/arm/mach-shmobile/board-bockw.c
+++ b/arch/arm/mach-shmobile/board-bockw.c
@@ -679,7 +679,7 @@ static void __init bockw_init(void)
                         .id             = i,
                         .data           = &rsnd_card_info[i],
                         .size_data      = sizeof(struct asoc_simple_card_info),
-                        .dma_mask       = ~0,
+                        .dma_mask       = DMA_BIT_MASK(32),
                 };
 
                 platform_device_register_full(&cardinfo);
diff --git a/arch/arm/mach-shmobile/board-lager.c b/arch/arm/mach-shmobile/board-lager.c
index a8d3ce646fb9..e0406fd37390 100644
--- a/arch/arm/mach-shmobile/board-lager.c
+++ b/arch/arm/mach-shmobile/board-lager.c
@@ -245,7 +245,9 @@ static void __init lager_init(void)
 {
         lager_add_standard_devices();
 
-        phy_register_fixup_for_id("r8a7790-ether-ff:01", lager_ksz8041_fixup);
+        if (IS_ENABLED(CONFIG_PHYLIB))
+                phy_register_fixup_for_id("r8a7790-ether-ff:01",
+                                          lager_ksz8041_fixup);
 }
 
 static const char * const lager_boards_compat_dt[] __initconst = {
diff --git a/arch/arm/plat-samsung/devs.c b/arch/arm/plat-samsung/devs.c
index 99a3590f0349..ac07e871f6a7 100644
--- a/arch/arm/plat-samsung/devs.c
+++ b/arch/arm/plat-samsung/devs.c
@@ -1468,6 +1468,8 @@ void __init s3c64xx_spi0_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
         pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi0_cfg_gpio;
 #if defined(CONFIG_PL330_DMA)
         pd.filter = pl330_filter;
+#elif defined(CONFIG_S3C64XX_PL080)
+        pd.filter = pl08x_filter_id;
 #elif defined(CONFIG_S3C24XX_DMAC)
         pd.filter = s3c24xx_dma_filter;
 #endif
@@ -1509,8 +1511,10 @@ void __init s3c64xx_spi1_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
         pd.num_cs = num_cs;
         pd.src_clk_nr = src_clk_nr;
         pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi1_cfg_gpio;
-#ifdef CONFIG_PL330_DMA
+#if defined(CONFIG_PL330_DMA)
         pd.filter = pl330_filter;
+#elif defined(CONFIG_S3C64XX_PL080)
+        pd.filter = pl08x_filter_id;
 #endif
 
         s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi1);
@@ -1550,8 +1554,10 @@ void __init s3c64xx_spi2_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
         pd.num_cs = num_cs;
         pd.src_clk_nr = src_clk_nr;
         pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi2_cfg_gpio;
-#ifdef CONFIG_PL330_DMA
+#if defined(CONFIG_PL330_DMA)
         pd.filter = pl330_filter;
+#elif defined(CONFIG_S3C64XX_PL080)
+        pd.filter = pl08x_filter_id;
 #endif
 
         s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi2);
diff --git a/arch/arm/plat-samsung/dma-ops.c b/arch/arm/plat-samsung/dma-ops.c
index ec0d731b0e7b..886326ee6f6c 100644
--- a/arch/arm/plat-samsung/dma-ops.c
+++ b/arch/arm/plat-samsung/dma-ops.c
@@ -18,6 +18,12 @@
 
 #include <mach/dma.h>
 
+#if defined(CONFIG_PL330_DMA)
+#define dma_filter pl330_filter
+#elif defined(CONFIG_S3C64XX_PL080)
+#define dma_filter pl08x_filter_id
+#endif
+
 static unsigned samsung_dmadev_request(enum dma_ch dma_ch,
                                 struct samsung_dma_req *param,
                                 struct device *dev, char *ch_name)
@@ -30,7 +36,7 @@ static unsigned samsung_dmadev_request(enum dma_ch dma_ch,
         if (dev->of_node)
                 return (unsigned)dma_request_slave_channel(dev, ch_name);
         else
-                return (unsigned)dma_request_channel(mask, pl330_filter,
+                return (unsigned)dma_request_channel(mask, dma_filter,
                                                         (void *)dma_ch);
 }
 
diff --git a/arch/arm/xen/enlighten.c b/arch/arm/xen/enlighten.c
index 83e4f959ee47..85501238b425 100644
--- a/arch/arm/xen/enlighten.c
+++ b/arch/arm/xen/enlighten.c
@@ -96,7 +96,7 @@ static int remap_pte_fn(pte_t *ptep, pgtable_t token, unsigned long addr,
         struct remap_data *info = data;
         struct page *page = info->pages[info->index++];
         unsigned long pfn = page_to_pfn(page);
-        pte_t pte = pfn_pte(pfn, info->prot);
+        pte_t pte = pte_mkspecial(pfn_pte(pfn, info->prot));
 
         if (map_foreign_page(pfn, info->fgmfn, info->domid))
                 return -EFAULT;
@@ -224,10 +224,10 @@ static int __init xen_guest_init(void)
         }
         if (of_address_to_resource(node, GRANT_TABLE_PHYSADDR, &res))
                 return 0;
-        xen_hvm_resume_frames = res.start >> PAGE_SHIFT;
+        xen_hvm_resume_frames = res.start;
         xen_events_irq = irq_of_parse_and_map(node, 0);
         pr_info("Xen %s support found, events_irq=%d gnttab_frame_pfn=%lx\n",
-                        version, xen_events_irq, xen_hvm_resume_frames);
+                        version, xen_events_irq, (xen_hvm_resume_frames >> PAGE_SHIFT));
         xen_domain_type = XEN_HVM_DOMAIN;
 
         xen_setup_features();
diff --git a/arch/arm64/include/asm/xen/page-coherent.h b/arch/arm64/include/asm/xen/page-coherent.h
index 2820f1a6eebe..dde3fc9c49f0 100644
--- a/arch/arm64/include/asm/xen/page-coherent.h
+++ b/arch/arm64/include/asm/xen/page-coherent.h
@@ -23,25 +23,21 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page,
              unsigned long offset, size_t size, enum dma_data_direction dir,
              struct dma_attrs *attrs)
 {
-        __generic_dma_ops(hwdev)->map_page(hwdev, page, offset, size, dir, attrs);
 }
 
 static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,
                 size_t size, enum dma_data_direction dir,
                 struct dma_attrs *attrs)
 {
-        __generic_dma_ops(hwdev)->unmap_page(hwdev, handle, size, dir, attrs);
 }
 
 static inline void xen_dma_sync_single_for_cpu(struct device *hwdev,
                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
 {
-        __generic_dma_ops(hwdev)->sync_single_for_cpu(hwdev, handle, size, dir);
 }
 
 static inline void xen_dma_sync_single_for_device(struct device *hwdev,
                 dma_addr_t handle, size_t size, enum dma_data_direction dir)
 {
-        __generic_dma_ops(hwdev)->sync_single_for_device(hwdev, handle, size, dir);
 }
 #endif /* _ASM_ARM64_XEN_PAGE_COHERENT_H */
diff --git a/arch/arm64/kernel/ptrace.c b/arch/arm64/kernel/ptrace.c
index 6777a2192b83..6a8928bba03c 100644
--- a/arch/arm64/kernel/ptrace.c
+++ b/arch/arm64/kernel/ptrace.c
@@ -214,31 +214,29 @@ static int ptrace_hbp_fill_attr_ctrl(unsigned int note_type,
 {
         int err, len, type, disabled = !ctrl.enabled;
 
-        if (disabled) {
-                len = 0;
-                type = HW_BREAKPOINT_EMPTY;
-        } else {
-                err = arch_bp_generic_fields(ctrl, &len, &type);
-                if (err)
-                        return err;
-
-                switch (note_type) {
-                case NT_ARM_HW_BREAK:
-                        if ((type & HW_BREAKPOINT_X) != type)
-                                return -EINVAL;
-                        break;
-                case NT_ARM_HW_WATCH:
-                        if ((type & HW_BREAKPOINT_RW) != type)
-                                return -EINVAL;
-                        break;
-                default:
+        attr->disabled = disabled;
+        if (disabled)
+                return 0;
+
+        err = arch_bp_generic_fields(ctrl, &len, &type);
+        if (err)
+                return err;
+
+        switch (note_type) {
+        case NT_ARM_HW_BREAK:
+                if ((type & HW_BREAKPOINT_X) != type)
                         return -EINVAL;
-                }
+                break;
+        case NT_ARM_HW_WATCH:
+                if ((type & HW_BREAKPOINT_RW) != type)
+                        return -EINVAL;
+                break;
+        default:
+                return -EINVAL;
         }
 
         attr->bp_len    = len;
         attr->bp_type   = type;
-        attr->disabled  = disabled;
 
         return 0;
 }
diff --git a/arch/powerpc/include/asm/kvm_book3s.h b/arch/powerpc/include/asm/kvm_book3s.h
index 4a594b76674d..bc23b1ba7980 100644
--- a/arch/powerpc/include/asm/kvm_book3s.h
+++ b/arch/powerpc/include/asm/kvm_book3s.h
@@ -192,6 +192,10 @@ extern void kvmppc_load_up_vsx(void);
 extern u32 kvmppc_alignment_dsisr(struct kvm_vcpu *vcpu, unsigned int inst);
 extern ulong kvmppc_alignment_dar(struct kvm_vcpu *vcpu, unsigned int inst);
 extern int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd);
+extern void kvmppc_copy_to_svcpu(struct kvmppc_book3s_shadow_vcpu *svcpu,
+                                 struct kvm_vcpu *vcpu);
+extern void kvmppc_copy_from_svcpu(struct kvm_vcpu *vcpu,
+                                   struct kvmppc_book3s_shadow_vcpu *svcpu);
 
 static inline struct kvmppc_vcpu_book3s *to_book3s(struct kvm_vcpu *vcpu)
 {
diff --git a/arch/powerpc/include/asm/kvm_book3s_asm.h b/arch/powerpc/include/asm/kvm_book3s_asm.h
index 0bd9348a4db9..192917d2239c 100644
--- a/arch/powerpc/include/asm/kvm_book3s_asm.h
+++ b/arch/powerpc/include/asm/kvm_book3s_asm.h
@@ -79,6 +79,7 @@ struct kvmppc_host_state {
         ulong vmhandler;
         ulong scratch0;
         ulong scratch1;
+        ulong scratch2;
         u8 in_guest;
         u8 restore_hid5;
         u8 napping;
@@ -106,6 +107,7 @@ struct kvmppc_host_state {
 };
 
 struct kvmppc_book3s_shadow_vcpu {
+        bool in_use;
         ulong gpr[14];
         u32 cr;
         u32 xer;
diff --git a/arch/powerpc/include/asm/opal.h b/arch/powerpc/include/asm/opal.h
index 033c06be1d84..7bdcf340016c 100644
--- a/arch/powerpc/include/asm/opal.h
+++ b/arch/powerpc/include/asm/opal.h
@@ -720,13 +720,13 @@ int64_t opal_pci_next_error(uint64_t phb_id, uint64_t *first_frozen_pe,
 int64_t opal_pci_poll(uint64_t phb_id);
 int64_t opal_return_cpu(void);
 
-int64_t opal_xscom_read(uint32_t gcid, uint32_t pcb_addr, uint64_t *val);
+int64_t opal_xscom_read(uint32_t gcid, uint32_t pcb_addr, __be64 *val);
 int64_t opal_xscom_write(uint32_t gcid, uint32_t pcb_addr, uint64_t val);
 
 int64_t opal_lpc_write(uint32_t chip_id, enum OpalLPCAddressType addr_type,
                        uint32_t addr, uint32_t data, uint32_t sz);
 int64_t opal_lpc_read(uint32_t chip_id, enum OpalLPCAddressType addr_type,
-                      uint32_t addr, uint32_t *data, uint32_t sz);
+                      uint32_t addr, __be32 *data, uint32_t sz);
 int64_t opal_validate_flash(uint64_t buffer, uint32_t *size, uint32_t *result);
 int64_t opal_manage_flash(uint8_t op);
 int64_t opal_update_flash(uint64_t blk_list);
diff --git a/arch/powerpc/include/asm/switch_to.h b/arch/powerpc/include/asm/switch_to.h
index 9ee12610af02..aace90547614 100644
--- a/arch/powerpc/include/asm/switch_to.h
+++ b/arch/powerpc/include/asm/switch_to.h
@@ -35,7 +35,7 @@ extern void giveup_vsx(struct task_struct *);
 extern void enable_kernel_spe(void);
 extern void giveup_spe(struct task_struct *);
 extern void load_up_spe(struct task_struct *);
-extern void switch_booke_debug_regs(struct thread_struct *new_thread);
+extern void switch_booke_debug_regs(struct debug_reg *new_debug);
 
 #ifndef CONFIG_SMP
 extern void discard_lazy_cpu_state(void);
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 2ea5cc033ec8..d3de01066f7d 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -576,6 +576,7 @@ int main(void)
         HSTATE_FIELD(HSTATE_VMHANDLER, vmhandler);
         HSTATE_FIELD(HSTATE_SCRATCH0, scratch0);
         HSTATE_FIELD(HSTATE_SCRATCH1, scratch1);
+        HSTATE_FIELD(HSTATE_SCRATCH2, scratch2);
         HSTATE_FIELD(HSTATE_IN_GUEST, in_guest);
         HSTATE_FIELD(HSTATE_RESTORE_HID5, restore_hid5);
         HSTATE_FIELD(HSTATE_NAPPING, napping);
diff --git a/arch/powerpc/kernel/crash_dump.c b/arch/powerpc/kernel/crash_dump.c
index 779a78c26435..11c1d069d920 100644
--- a/arch/powerpc/kernel/crash_dump.c
+++ b/arch/powerpc/kernel/crash_dump.c
@@ -124,15 +124,15 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
 void crash_free_reserved_phys_range(unsigned long begin, unsigned long end)
 {
         unsigned long addr;
-        const u32 *basep, *sizep;
+        const __be32 *basep, *sizep;
         unsigned int rtas_start = 0, rtas_end = 0;
 
         basep = of_get_property(rtas.dev, "linux,rtas-base", NULL);
         sizep = of_get_property(rtas.dev, "rtas-size", NULL);
 
         if (basep && sizep) {
-                rtas_start = *basep;
-                rtas_end = *basep + *sizep;
+                rtas_start = be32_to_cpup(basep);
+                rtas_end = rtas_start + be32_to_cpup(sizep);
         }
 
         for (addr = begin; addr < end; addr += PAGE_SIZE) {
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 3386d8ab7eb0..4a96556fd2d4 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -339,7 +339,7 @@ static void set_debug_reg_defaults(struct thread_struct *thread)
 #endif
 }
 
-static void prime_debug_regs(struct thread_struct *thread)
+static void prime_debug_regs(struct debug_reg *debug)
 {
         /*
          * We could have inherited MSR_DE from userspace, since
@@ -348,22 +348,22 @@ static void prime_debug_regs(struct thread_struct *thread)
          */
         mtmsr(mfmsr() & ~MSR_DE);
 
-        mtspr(SPRN_IAC1, thread->debug.iac1);
-        mtspr(SPRN_IAC2, thread->debug.iac2);
+        mtspr(SPRN_IAC1, debug->iac1);
+        mtspr(SPRN_IAC2, debug->iac2);
 #if CONFIG_PPC_ADV_DEBUG_IACS > 2
-        mtspr(SPRN_IAC3, thread->debug.iac3);
-        mtspr(SPRN_IAC4, thread->debug.iac4);
+        mtspr(SPRN_IAC3, debug->iac3);
+        mtspr(SPRN_IAC4, debug->iac4);
 #endif
-        mtspr(SPRN_DAC1, thread->debug.dac1);
-        mtspr(SPRN_DAC2, thread->debug.dac2);
+        mtspr(SPRN_DAC1, debug->dac1);
+        mtspr(SPRN_DAC2, debug->dac2);
 #if CONFIG_PPC_ADV_DEBUG_DVCS > 0
-        mtspr(SPRN_DVC1, thread->debug.dvc1);
-        mtspr(SPRN_DVC2, thread->debug.dvc2);
+        mtspr(SPRN_DVC1, debug->dvc1);
+        mtspr(SPRN_DVC2, debug->dvc2);
 #endif
-        mtspr(SPRN_DBCR0, thread->debug.dbcr0);
-        mtspr(SPRN_DBCR1, thread->debug.dbcr1);
+        mtspr(SPRN_DBCR0, debug->dbcr0);
+        mtspr(SPRN_DBCR1, debug->dbcr1);
 #ifdef CONFIG_BOOKE
-        mtspr(SPRN_DBCR2, thread->debug.dbcr2);
+        mtspr(SPRN_DBCR2, debug->dbcr2);
 #endif
 }
 /*
@@ -371,11 +371,11 @@ static void prime_debug_regs(struct thread_struct *thread)
  * debug registers, set the debug registers from the values
  * stored in the new thread.
  */
-void switch_booke_debug_regs(struct thread_struct *new_thread)
+void switch_booke_debug_regs(struct debug_reg *new_debug)
 {
         if ((current->thread.debug.dbcr0 & DBCR0_IDM)
-                || (new_thread->debug.dbcr0 & DBCR0_IDM))
-                        prime_debug_regs(new_thread);
+                || (new_debug->dbcr0 & DBCR0_IDM))
+                        prime_debug_regs(new_debug);
 }
 EXPORT_SYMBOL_GPL(switch_booke_debug_regs);
 #else   /* !CONFIG_PPC_ADV_DEBUG_REGS */
@@ -683,7 +683,7 @@ struct task_struct *__switch_to(struct task_struct *prev,
 #endif /* CONFIG_SMP */
 
 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
-        switch_booke_debug_regs(&new->thread);
+        switch_booke_debug_regs(&new->thread.debug);
 #else
 /*
  * For PPC_BOOK3S_64, we use the hw-breakpoint interfaces that would
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 75fb40498b41..2e3d2bf536c5 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -1555,7 +1555,7 @@ long arch_ptrace(struct task_struct *child, long request,
 
                         flush_fp_to_thread(child);
                         if (fpidx < (PT_FPSCR - PT_FPR0))
-                                memcpy(&tmp, &child->thread.fp_state.fpr,
+                                memcpy(&tmp, &child->thread.TS_FPR(fpidx),
                                        sizeof(long));
                         else
                                 tmp = child->thread.fp_state.fpscr;
@@ -1588,7 +1588,7 @@ long arch_ptrace(struct task_struct *child, long request,
 
                         flush_fp_to_thread(child);
                         if (fpidx < (PT_FPSCR - PT_FPR0))
-                                memcpy(&child->thread.fp_state.fpr, &data,
+                                memcpy(&child->thread.TS_FPR(fpidx), &data,
                                        sizeof(long));
                         else
                                 child->thread.fp_state.fpscr = data;
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index febc80445d25..bc76cc6b419c 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -479,7 +479,7 @@ void __init smp_setup_cpu_maps(void)
         if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR) &&
             (dn = of_find_node_by_path("/rtas"))) {
                 int num_addr_cell, num_size_cell, maxcpus;
-                const unsigned int *ireg;
+                const __be32 *ireg;
 
                 num_addr_cell = of_n_addr_cells(dn);
                 num_size_cell = of_n_size_cells(dn);
@@ -489,7 +489,7 @@ void __init smp_setup_cpu_maps(void)
                 if (!ireg)
                         goto out;
 
-                maxcpus = ireg[num_addr_cell + num_size_cell];
+                maxcpus = be32_to_cpup(ireg + num_addr_cell + num_size_cell);
 
                 /* Double maxcpus for processors which have SMT capability */
                 if (cpu_has_feature(CPU_FTR_SMT))
diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
index a3b64f3bf9a2..c1cf4a1522d9 100644
--- a/arch/powerpc/kernel/smp.c
+++ b/arch/powerpc/kernel/smp.c
@@ -580,7 +580,7 @@ int __cpu_up(unsigned int cpu, struct task_struct *tidle)
 int cpu_to_core_id(int cpu)
 {
         struct device_node *np;
-        const int *reg;
+        const __be32 *reg;
         int id = -1;
 
         np = of_get_cpu_node(cpu, NULL);
@@ -591,7 +591,7 @@ int cpu_to_core_id(int cpu)
         if (!reg)
                 goto out;
 
-        id = *reg;
+        id = be32_to_cpup(reg);
 out:
         of_node_put(np);
         return id;
diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index f3ff587a8b7d..c5d148434c08 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
@@ -469,11 +469,14 @@ static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
                 slb_v = vcpu->kvm->arch.vrma_slb_v;
         }
 
+        preempt_disable();
         /* Find the HPTE in the hash table */
         index = kvmppc_hv_find_lock_hpte(kvm, eaddr, slb_v,
                                          HPTE_V_VALID | HPTE_V_ABSENT);
-        if (index < 0)
+        if (index < 0) {
+                preempt_enable();
                 return -ENOENT;
+        }
         hptep = (unsigned long *)(kvm->arch.hpt_virt + (index << 4));
         v = hptep[0] & ~HPTE_V_HVLOCK;
         gr = kvm->arch.revmap[index].guest_rpte;
@@ -481,6 +484,7 @@ static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
         /* Unlock the HPTE */
         asm volatile("lwsync" : : : "memory");
         hptep[0] = v;
+        preempt_enable();
 
         gpte->eaddr = eaddr;
         gpte->vpage = ((v & HPTE_V_AVPN) << 4) | ((eaddr >> 12) & 0xfff);
@@ -665,6 +669,7 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
                         return -EFAULT;
         } else {
                 page = pages[0];
+                pfn = page_to_pfn(page);
                 if (PageHuge(page)) {
                         page = compound_head(page);
                         pte_size <<= compound_order(page);
@@ -689,7 +694,6 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
                         }
                         rcu_read_unlock_sched();
                 }
-                pfn = page_to_pfn(page);
         }
 
         ret = -EFAULT;
@@ -707,8 +711,14 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
                 r = (r & ~(HPTE_R_W|HPTE_R_I|HPTE_R_G)) | HPTE_R_M;
         }
 
-        /* Set the HPTE to point to pfn */
-        r = (r & ~(HPTE_R_PP0 - pte_size)) | (pfn << PAGE_SHIFT);
+        /*
+         * Set the HPTE to point to pfn.
+         * Since the pfn is at PAGE_SIZE granularity, make sure we
+         * don't mask out lower-order bits if psize < PAGE_SIZE.
+         */
+        if (psize < PAGE_SIZE)
+                psize = PAGE_SIZE;
+        r = (r & ~(HPTE_R_PP0 - psize)) | ((pfn << PAGE_SHIFT) & ~(psize - 1));
         if (hpte_is_writable(r) && !write_ok)
                 r = hpte_make_readonly(r);
         ret = RESUME_GUEST;
diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c
index 072287f1c3bc..b51d5db78068 100644
--- a/arch/powerpc/kvm/book3s_hv.c
+++ b/arch/powerpc/kvm/book3s_hv.c
@@ -131,8 +131,9 @@ static void kvmppc_fast_vcpu_kick_hv(struct kvm_vcpu *vcpu)
 static void kvmppc_core_vcpu_load_hv(struct kvm_vcpu *vcpu, int cpu)
 {
         struct kvmppc_vcore *vc = vcpu->arch.vcore;
+        unsigned long flags;
 
-        spin_lock(&vcpu->arch.tbacct_lock);
+        spin_lock_irqsave(&vcpu->arch.tbacct_lock, flags);
         if (vc->runner == vcpu && vc->vcore_state != VCORE_INACTIVE &&
             vc->preempt_tb != TB_NIL) {
                 vc->stolen_tb += mftb() - vc->preempt_tb;
@@ -143,19 +144,20 @@ static void kvmppc_core_vcpu_load_hv(struct kvm_vcpu *vcpu, int cpu)
                 vcpu->arch.busy_stolen += mftb() - vcpu->arch.busy_preempt;
                 vcpu->arch.busy_preempt = TB_NIL;
         }
-        spin_unlock(&vcpu->arch.tbacct_lock);
+        spin_unlock_irqrestore(&vcpu->arch.tbacct_lock, flags);
 }
 
 static void kvmppc_core_vcpu_put_hv(struct kvm_vcpu *vcpu)
 {
         struct kvmppc_vcore *vc = vcpu->arch.vcore;
+        unsigned long flags;
 
-        spin_lock(&vcpu->arch.tbacct_lock);
+        spin_lock_irqsave(&vcpu->arch.tbacct_lock, flags);
         if (vc->runner == vcpu && vc->vcore_state != VCORE_INACTIVE)
                 vc->preempt_tb = mftb();
         if (vcpu->arch.state == KVMPPC_VCPU_BUSY_IN_HOST)
                 vcpu->arch.busy_preempt = mftb();
-        spin_unlock(&vcpu->arch.tbacct_lock);
+        spin_unlock_irqrestore(&vcpu->arch.tbacct_lock, flags);
 }
 
 static void kvmppc_set_msr_hv(struct kvm_vcpu *vcpu, u64 msr)
@@ -486,11 +488,11 @@ static u64 vcore_stolen_time(struct kvmppc_vcore *vc, u64 now)
          */
         if (vc->vcore_state != VCORE_INACTIVE &&
             vc->runner->arch.run_task != current) {
-                spin_lock(&vc->runner->arch.tbacct_lock);
+                spin_lock_irq(&vc->runner->arch.tbacct_lock);
                 p = vc->stolen_tb;
                 if (vc->preempt_tb != TB_NIL)
                         p += now - vc->preempt_tb;
-                spin_unlock(&vc->runner->arch.tbacct_lock);
+                spin_unlock_irq(&vc->runner->arch.tbacct_lock);
         } else {
                 p = vc->stolen_tb;
         }
@@ -512,10 +514,10 @@ static void kvmppc_create_dtl_entry(struct kvm_vcpu *vcpu,
         core_stolen = vcore_stolen_time(vc, now);
         stolen = core_stolen - vcpu->arch.stolen_logged;
         vcpu->arch.stolen_logged = core_stolen;
-        spin_lock(&vcpu->arch.tbacct_lock);
+        spin_lock_irq(&vcpu->arch.tbacct_lock);
         stolen += vcpu->arch.busy_stolen;
         vcpu->arch.busy_stolen = 0;
-        spin_unlock(&vcpu->arch.tbacct_lock);
+        spin_unlock_irq(&vcpu->arch.tbacct_lock);
         if (!dt || !vpa)
                 return;
         memset(dt, 0, sizeof(struct dtl_entry));
@@ -589,7 +591,9 @@ int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu)
                 if (list_empty(&vcpu->kvm->arch.rtas_tokens))
                         return RESUME_HOST;
 
+                idx = srcu_read_lock(&vcpu->kvm->srcu);
                 rc = kvmppc_rtas_hcall(vcpu);
+                srcu_read_unlock(&vcpu->kvm->srcu, idx);
 
                 if (rc == -ENOENT)
                         return RESUME_HOST;
@@ -1115,13 +1119,13 @@ static void kvmppc_remove_runnable(struct kvmppc_vcore *vc,
 
         if (vcpu->arch.state != KVMPPC_VCPU_RUNNABLE)
                 return;
-        spin_lock(&vcpu->arch.tbacct_lock);
+        spin_lock_irq(&vcpu->arch.tbacct_lock);
         now = mftb();
         vcpu->arch.busy_stolen += vcore_stolen_time(vc, now) -
                 vcpu->arch.stolen_logged;
         vcpu->arch.busy_preempt = now;
         vcpu->arch.state = KVMPPC_VCPU_BUSY_IN_HOST;
-        spin_unlock(&vcpu->arch.tbacct_lock);
+        spin_unlock_irq(&vcpu->arch.tbacct_lock);
         --vc->n_runnable;
         list_del(&vcpu->arch.run_list);
 }
diff --git a/arch/powerpc/kvm/book3s_hv_rm_mmu.c b/arch/powerpc/kvm/book3s_hv_rm_mmu.c
index 9c515440ad1a..8689e2e30857 100644
--- a/arch/powerpc/kvm/book3s_hv_rm_mmu.c
+++ b/arch/powerpc/kvm/book3s_hv_rm_mmu.c
@@ -225,6 +225,7 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,
                 is_io = pa & (HPTE_R_I | HPTE_R_W);
                 pte_size = PAGE_SIZE << (pa & KVMPPC_PAGE_ORDER_MASK);
                 pa &= PAGE_MASK;
+                pa |= gpa & ~PAGE_MASK;
         } else {
                 /* Translate to host virtual address */
                 hva = __gfn_to_hva_memslot(memslot, gfn);
@@ -238,13 +239,13 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,
                                 ptel = hpte_make_readonly(ptel);
                         is_io = hpte_cache_bits(pte_val(pte));
                         pa = pte_pfn(pte) << PAGE_SHIFT;
+                        pa |= hva & (pte_size - 1);
+                        pa |= gpa & ~PAGE_MASK;
                 }
         }
 
         if (pte_size < psize)
                 return H_PARAMETER;
-        if (pa && pte_size > psize)
-                pa |= gpa & (pte_size - 1);
 
         ptel &= ~(HPTE_R_PP0 - psize);
         ptel |= pa;
@@ -749,6 +750,10 @@ static int slb_base_page_shift[4] = {
         20,     /* 1M, unsupported */
 };
 
+/* When called from virtmode, this func should be protected by
+ * preempt_disable(), otherwise, the holding of HPTE_V_HVLOCK
+ * can trigger deadlock issue.
+ */
 long kvmppc_hv_find_lock_hpte(struct kvm *kvm, gva_t eaddr, unsigned long slb_v,
                               unsigned long valid)
 {
diff --git a/arch/powerpc/kvm/book3s_hv_rmhandlers.S b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
index bc8de75b1925..be4fa04a37c9 100644
--- a/arch/powerpc/kvm/book3s_hv_rmhandlers.S
+++ b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
@@ -153,7 +153,6 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206)
 
 13:     b       machine_check_fwnmi
 
-
 /*
  * We come in here when wakened from nap mode on a secondary hw thread.
  * Relocation is off and most register values are lost.
@@ -224,6 +223,11 @@ kvm_start_guest:
         /* Clear our vcpu pointer so we don't come back in early */
         li      r0, 0
         std     r0, HSTATE_KVM_VCPU(r13)
+        /*
+         * Make sure we clear HSTATE_KVM_VCPU(r13) before incrementing
+         * the nap_count, because once the increment to nap_count is
+         * visible we could be given another vcpu.
+         */
         lwsync
         /* Clear any pending IPI - we're an offline thread */
         ld      r5, HSTATE_XICS_PHYS(r13)
@@ -241,7 +245,6 @@ kvm_start_guest:
         /* increment the nap count and then go to nap mode */
         ld      r4, HSTATE_KVM_VCORE(r13)
         addi    r4, r4, VCORE_NAP_COUNT
-        lwsync                          /* make previous updates visible */
 51:     lwarx   r3, 0, r4
         addi    r3, r3, 1
         stwcx.  r3, 0, r4
@@ -751,15 +754,14 @@ kvmppc_interrupt_hv:
          * guest CR, R12 saved in shadow VCPU SCRATCH1/0
          * guest R13 saved in SPRN_SCRATCH0
          */
-        /* abuse host_r2 as third scratch area; we get r2 from PACATOC(r13) */
-        std     r9, HSTATE_HOST_R2(r13)
+        std     r9, HSTATE_SCRATCH2(r13)
 
         lbz     r9, HSTATE_IN_GUEST(r13)
         cmpwi   r9, KVM_GUEST_MODE_HOST_HV
         beq     kvmppc_bad_host_intr
 #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE
         cmpwi   r9, KVM_GUEST_MODE_GUEST
-        ld      r9, HSTATE_HOST_R2(r13)
+        ld      r9, HSTATE_SCRATCH2(r13)
         beq     kvmppc_interrupt_pr
 #endif
         /* We're now back in the host but in guest MMU context */
@@ -779,7 +781,7 @@ kvmppc_interrupt_hv:
         std     r6, VCPU_GPR(R6)(r9)
         std     r7, VCPU_GPR(R7)(r9)
         std     r8, VCPU_GPR(R8)(r9)
-        ld      r0, HSTATE_HOST_R2(r13)
+        ld      r0, HSTATE_SCRATCH2(r13)
         std     r0, VCPU_GPR(R9)(r9)
         std     r10, VCPU_GPR(R10)(r9)
         std     r11, VCPU_GPR(R11)(r9)
@@ -990,14 +992,13 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201)
          */
         /* Increment the threads-exiting-guest count in the 0xff00
            bits of vcore->entry_exit_count */
-        lwsync
         ld      r5,HSTATE_KVM_VCORE(r13)
         addi    r6,r5,VCORE_ENTRY_EXIT
 41:     lwarx   r3,0,r6
         addi    r0,r3,0x100
         stwcx.  r0,0,r6
         bne     41b
-        lwsync
+        isync           /* order stwcx. vs. reading napping_threads */
 
         /*
          * At this point we have an interrupt that we have to pass
@@ -1030,6 +1031,8 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201)
         sld     r0,r0,r4
         andc.   r3,r3,r0                /* no sense IPI'ing ourselves */
         beq     43f
+        /* Order entry/exit update vs. IPIs */
+        sync
         mulli   r4,r4,PACA_SIZE         /* get paca for thread 0 */
         subf    r6,r4,r13
 42:     andi.   r0,r3,1
@@ -1638,10 +1641,10 @@ END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_206)
         bge     kvm_cede_exit
         stwcx.  r4,0,r6
         bne     31b
+        /* order napping_threads update vs testing entry_exit_count */
+        isync
         li      r0,1
         stb     r0,HSTATE_NAPPING(r13)
-        /* order napping_threads update vs testing entry_exit_count */
-        lwsync
         mr      r4,r3
         lwz     r7,VCORE_ENTRY_EXIT(r5)
         cmpwi   r7,0x100
diff --git a/arch/powerpc/kvm/book3s_interrupts.S b/arch/powerpc/kvm/book3s_interrupts.S
index f4dd041c14ea..f779450cb07c 100644
--- a/arch/powerpc/kvm/book3s_interrupts.S
+++ b/arch/powerpc/kvm/book3s_interrupts.S
@@ -129,29 +129,32 @@ kvm_start_lightweight:
          * R12      = exit handler id
          * R13      = PACA
          * SVCPU.*  = guest *
+         * MSR.EE   = 1
          *
          */
 
+        PPC_LL  r3, GPR4(r1)            /* vcpu pointer */
+
+        /*
+         * kvmppc_copy_from_svcpu can clobber volatile registers, save
+         * the exit handler id to the vcpu and restore it from there later.
+         */
+        stw     r12, VCPU_TRAP(r3)
+
         /* Transfer reg values from shadow vcpu back to vcpu struct */
         /* On 64-bit, interrupts are still off at this point */
-        PPC_LL  r3, GPR4(r1)            /* vcpu pointer */
+
         GET_SHADOW_VCPU(r4)
         bl      FUNC(kvmppc_copy_from_svcpu)
         nop
 
 #ifdef CONFIG_PPC_BOOK3S_64
-        /* Re-enable interrupts */
-        ld      r3, HSTATE_HOST_MSR(r13)
-        ori     r3, r3, MSR_EE
-        MTMSR_EERI(r3)
-
         /*
          * Reload kernel SPRG3 value.
          * No need to save guest value as usermode can't modify SPRG3.
          */
         ld      r3, PACA_SPRG3(r13)
         mtspr   SPRN_SPRG3, r3
-
 #endif /* CONFIG_PPC_BOOK3S_64 */
 
         /* R7 = vcpu */
@@ -177,7 +180,7 @@ kvm_start_lightweight:
         PPC_STL r31, VCPU_GPR(R31)(r7)
 
         /* Pass the exit number as 3rd argument to kvmppc_handle_exit */
-        mr      r5, r12
+        lwz     r5, VCPU_TRAP(r7)
 
         /* Restore r3 (kvm_run) and r4 (vcpu) */
         REST_2GPRS(3, r1)
diff --git a/arch/powerpc/kvm/book3s_pr.c b/arch/powerpc/kvm/book3s_pr.c
index fe14ca3dd171..5b9e9063cfaf 100644
--- a/arch/powerpc/kvm/book3s_pr.c
+++ b/arch/powerpc/kvm/book3s_pr.c
@@ -66,6 +66,7 @@ static void kvmppc_core_vcpu_load_pr(struct kvm_vcpu *vcpu, int cpu)
         struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
         memcpy(svcpu->slb, to_book3s(vcpu)->slb_shadow, sizeof(svcpu->slb));
         svcpu->slb_max = to_book3s(vcpu)->slb_shadow_max;
+        svcpu->in_use = 0;
         svcpu_put(svcpu);
 #endif
         vcpu->cpu = smp_processor_id();
@@ -78,6 +79,9 @@ static void kvmppc_core_vcpu_put_pr(struct kvm_vcpu *vcpu)
 {
 #ifdef CONFIG_PPC_BOOK3S_64
         struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
+        if (svcpu->in_use) {
+                kvmppc_copy_from_svcpu(vcpu, svcpu);
+        }
         memcpy(to_book3s(vcpu)->slb_shadow, svcpu->slb, sizeof(svcpu->slb));
         to_book3s(vcpu)->slb_shadow_max = svcpu->slb_max;
         svcpu_put(svcpu);
@@ -110,12 +114,26 @@ void kvmppc_copy_to_svcpu(struct kvmppc_book3s_shadow_vcpu *svcpu,
         svcpu->ctr = vcpu->arch.ctr;
         svcpu->lr  = vcpu->arch.lr;
         svcpu->pc  = vcpu->arch.pc;
+        svcpu->in_use = true;
 }
 
 /* Copy data touched by real-mode code from shadow vcpu back to vcpu */
 void kvmppc_copy_from_svcpu(struct kvm_vcpu *vcpu,
                             struct kvmppc_book3s_shadow_vcpu *svcpu)
 {
+        /*
+         * vcpu_put would just call us again because in_use hasn't
+         * been updated yet.
+         */
+        preempt_disable();
+
+        /*
+         * Maybe we were already preempted and synced the svcpu from
+         * our preempt notifiers. Don't bother touching this svcpu then.
+         */
+        if (!svcpu->in_use)
+                goto out;
+
         vcpu->arch.gpr[0] = svcpu->gpr[0];
         vcpu->arch.gpr[1] = svcpu->gpr[1];
         vcpu->arch.gpr[2] = svcpu->gpr[2];
@@ -139,6 +157,10 @@ void kvmppc_copy_from_svcpu(struct kvm_vcpu *vcpu,
         vcpu->arch.fault_dar   = svcpu->fault_dar;
         vcpu->arch.fault_dsisr = svcpu->fault_dsisr;
         vcpu->arch.last_inst   = svcpu->last_inst;
+        svcpu->in_use = false;
+
+out:
+        preempt_enable();
 }
 
 static int kvmppc_core_check_requests_pr(struct kvm_vcpu *vcpu)
diff --git a/arch/powerpc/kvm/book3s_rmhandlers.S b/arch/powerpc/kvm/book3s_rmhandlers.S
index a38c4c9edab8..c3c5231adade 100644
--- a/arch/powerpc/kvm/book3s_rmhandlers.S
+++ b/arch/powerpc/kvm/book3s_rmhandlers.S
@@ -153,15 +153,11 @@ _GLOBAL(kvmppc_entry_trampoline)
 
         li      r6, MSR_IR | MSR_DR
         andc    r6, r5, r6      /* Clear DR and IR in MSR value */
-#ifdef CONFIG_PPC_BOOK3S_32
         /*
          * Set EE in HOST_MSR so that it's enabled when we get into our
-         * C exit handler function.  On 64-bit we delay enabling
-         * interrupts until we have finished transferring stuff
-         * to or from the PACA.
+         * C exit handler function.
          */
         ori     r5, r5, MSR_EE
-#endif
         mtsrr0  r7
         mtsrr1  r6
         RFI
diff --git a/arch/powerpc/kvm/booke.c b/arch/powerpc/kvm/booke.c
index 53e65a210b9a..0591e05db74b 100644
--- a/arch/powerpc/kvm/booke.c
+++ b/arch/powerpc/kvm/booke.c
@@ -681,7 +681,7 @@ int kvmppc_core_check_requests(struct kvm_vcpu *vcpu)
 int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 {
         int ret, s;
-        struct thread_struct thread;
+        struct debug_reg debug;
 #ifdef CONFIG_PPC_FPU
         struct thread_fp_state fp;
         int fpexc_mode;
@@ -723,9 +723,9 @@ int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 #endif
 
         /* Switch to guest debug context */
-        thread.debug = vcpu->arch.shadow_dbg_reg;
-        switch_booke_debug_regs(&thread);
-        thread.debug = current->thread.debug;
+        debug = vcpu->arch.shadow_dbg_reg;
+        switch_booke_debug_regs(&debug);
+        debug = current->thread.debug;
         current->thread.debug = vcpu->arch.shadow_dbg_reg;
 
         kvmppc_fix_ee_before_entry();
@@ -736,8 +736,8 @@ int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
            We also get here with interrupts enabled. */
 
         /* Switch back to user space debug context */
-        switch_booke_debug_regs(&thread);
-        current->thread.debug = thread.debug;
+        switch_booke_debug_regs(&debug);
+        current->thread.debug = debug;
 
 #ifdef CONFIG_PPC_FPU
         kvmppc_save_guest_fp(vcpu);
diff --git a/arch/powerpc/platforms/powernv/opal-lpc.c b/arch/powerpc/platforms/powernv/opal-lpc.c
index e7e59e4f9892..79d83cad3d67 100644
--- a/arch/powerpc/platforms/powernv/opal-lpc.c
+++ b/arch/powerpc/platforms/powernv/opal-lpc.c
@@ -24,25 +24,25 @@ static int opal_lpc_chip_id = -1;
 static u8 opal_lpc_inb(unsigned long port)
 {
         int64_t rc;
-        uint32_t data;
+        __be32 data;
 
         if (opal_lpc_chip_id < 0 || port > 0xffff)
                 return 0xff;
         rc = opal_lpc_read(opal_lpc_chip_id, OPAL_LPC_IO, port, &data, 1);
-        return rc ? 0xff : data;
+        return rc ? 0xff : be32_to_cpu(data);
 }
 
 static __le16 __opal_lpc_inw(unsigned long port)
 {
         int64_t rc;
-        uint32_t data;
+        __be32 data;
 
         if (opal_lpc_chip_id < 0 || port > 0xfffe)
                 return 0xffff;
         if (port & 1)
                 return (__le16)opal_lpc_inb(port) << 8 | opal_lpc_inb(port + 1);
         rc = opal_lpc_read(opal_lpc_chip_id, OPAL_LPC_IO, port, &data, 2);
-        return rc ? 0xffff : data;
+        return rc ? 0xffff : be32_to_cpu(data);
 }
 static u16 opal_lpc_inw(unsigned long port)
 {
@@ -52,7 +52,7 @@ static u16 opal_lpc_inw(unsigned long port)
 static __le32 __opal_lpc_inl(unsigned long port)
 {
         int64_t rc;
-        uint32_t data;
+        __be32 data;
 
         if (opal_lpc_chip_id < 0 || port > 0xfffc)
                 return 0xffffffff;
@@ -62,7 +62,7 @@ static __le32 __opal_lpc_inl(unsigned long port)
                        (__le32)opal_lpc_inb(port + 2) <<  8 |
                                opal_lpc_inb(port + 3);
         rc = opal_lpc_read(opal_lpc_chip_id, OPAL_LPC_IO, port, &data, 4);
-        return rc ? 0xffffffff : data;
+        return rc ? 0xffffffff : be32_to_cpu(data);
 }
 
 static u32 opal_lpc_inl(unsigned long port)
diff --git a/arch/powerpc/platforms/powernv/opal-xscom.c b/arch/powerpc/platforms/powernv/opal-xscom.c
index 4d99a8fd55ac..4fbf276ac99e 100644
--- a/arch/powerpc/platforms/powernv/opal-xscom.c
+++ b/arch/powerpc/platforms/powernv/opal-xscom.c
@@ -96,9 +96,11 @@ static int opal_scom_read(scom_map_t map, u64 reg, u64 *value)
 {
         struct opal_scom_map *m = map;
         int64_t rc;
+        __be64 v;
 
         reg = opal_scom_unmangle(reg);
-        rc = opal_xscom_read(m->chip, m->addr + reg, (uint64_t *)__pa(value));
+        rc = opal_xscom_read(m->chip, m->addr + reg, (__be64 *)__pa(&v));
+        *value = be64_to_cpu(v);
         return opal_xscom_err_xlate(rc);
 }
 
diff --git a/arch/powerpc/platforms/pseries/lparcfg.c b/arch/powerpc/platforms/pseries/lparcfg.c
index e738007eae64..c9fecf09b8fa 100644
--- a/arch/powerpc/platforms/pseries/lparcfg.c
+++ b/arch/powerpc/platforms/pseries/lparcfg.c
@@ -157,7 +157,7 @@ static void parse_ppp_data(struct seq_file *m)
 {
         struct hvcall_ppp_data ppp_data;
         struct device_node *root;
-        const int *perf_level;
+        const __be32 *perf_level;
         int rc;
 
         rc = h_get_ppp(&ppp_data);
@@ -201,7 +201,7 @@ static void parse_ppp_data(struct seq_file *m)
                 perf_level = of_get_property(root,
                                 "ibm,partition-performance-parameters-level",
                                              NULL);
-                if (perf_level && (*perf_level >= 1)) {
+                if (perf_level && (be32_to_cpup(perf_level) >= 1)) {
                         seq_printf(m,
                             "physical_procs_allocated_to_virtualization=%d\n",
                                    ppp_data.phys_platform_procs);
@@ -435,7 +435,7 @@ static int pseries_lparcfg_data(struct seq_file *m, void *v)
         int partition_potential_processors;
         int partition_active_processors;
         struct device_node *rtas_node;
-        const int *lrdrp = NULL;
+        const __be32 *lrdrp = NULL;
 
         rtas_node = of_find_node_by_path("/rtas");
         if (rtas_node)
@@ -444,7 +444,7 @@ static int pseries_lparcfg_data(struct seq_file *m, void *v)
         if (lrdrp == NULL) {
                 partition_potential_processors = vdso_data->processorCount;
         } else {
-                partition_potential_processors = *(lrdrp + 4);
+                partition_potential_processors = be32_to_cpup(lrdrp + 4);
         }
         of_node_put(rtas_node);
 
@@ -654,7 +654,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
         const char *model = "";
         const char *system_id = "";
         const char *tmp;
-        const unsigned int *lp_index_ptr;
+        const __be32 *lp_index_ptr;
         unsigned int lp_index = 0;
 
         seq_printf(m, "%s %s\n", MODULE_NAME, MODULE_VERS);
@@ -670,7 +670,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
                 lp_index_ptr = of_get_property(rootdn, "ibm,partition-no",
                                         NULL);
                 if (lp_index_ptr)
-                        lp_index = *lp_index_ptr;
+                        lp_index = be32_to_cpup(lp_index_ptr);
                 of_node_put(rootdn);
         }
         seq_printf(m, "serial_number=%s\n", system_id);
diff --git a/arch/powerpc/platforms/pseries/msi.c b/arch/powerpc/platforms/pseries/msi.c
index 6d2f0abce6fa..0c882e83c4ce 100644
--- a/arch/powerpc/platforms/pseries/msi.c
+++ b/arch/powerpc/platforms/pseries/msi.c
@@ -130,7 +130,8 @@ static int check_req(struct pci_dev *pdev, int nvec, char *prop_name)
 {
         struct device_node *dn;
         struct pci_dn *pdn;
-        const u32 *req_msi;
+        const __be32 *p;
+        u32 req_msi;
 
         pdn = pci_get_pdn(pdev);
         if (!pdn)
@@ -138,19 +139,20 @@ static int check_req(struct pci_dev *pdev, int nvec, char *prop_name)
 
         dn = pdn->node;
 
-        req_msi = of_get_property(dn, prop_name, NULL);
-        if (!req_msi) {
+        p = of_get_property(dn, prop_name, NULL);
+        if (!p) {
                 pr_debug("rtas_msi: No %s on %s\n", prop_name, dn->full_name);
                 return -ENOENT;
         }
 
-        if (*req_msi < nvec) {
+        req_msi = be32_to_cpup(p);
+        if (req_msi < nvec) {
                 pr_debug("rtas_msi: %s requests < %d MSIs\n", prop_name, nvec);
 
-                if (*req_msi == 0) /* Be paranoid */
+                if (req_msi == 0) /* Be paranoid */
                         return -ENOSPC;
 
-                return *req_msi;
+                return req_msi;
         }
 
         return 0;
@@ -171,7 +173,7 @@ static int check_req_msix(struct pci_dev *pdev, int nvec)
 static struct device_node *find_pe_total_msi(struct pci_dev *dev, int *total)
 {
         struct device_node *dn;
-        const u32 *p;
+        const __be32 *p;
 
         dn = of_node_get(pci_device_to_OF_node(dev));
         while (dn) {
@@ -179,7 +181,7 @@ static struct device_node *find_pe_total_msi(struct pci_dev *dev, int *total)
                 if (p) {
                         pr_debug("rtas_msi: found prop on dn %s\n",
                                 dn->full_name);
-                        *total = *p;
+                        *total = be32_to_cpup(p);
                         return dn;
                 }
 
@@ -232,13 +234,13 @@ struct msi_counts {
 static void *count_non_bridge_devices(struct device_node *dn, void *data)
 {
         struct msi_counts *counts = data;
-        const u32 *p;
+        const __be32 *p;
         u32 class;
 
         pr_debug("rtas_msi: counting %s\n", dn->full_name);
 
         p = of_get_property(dn, "class-code", NULL);
-        class = p ? *p : 0;
+        class = p ? be32_to_cpup(p) : 0;
 
         if ((class >> 8) != PCI_CLASS_BRIDGE_PCI)
                 counts->num_devices++;
@@ -249,7 +251,7 @@ static void *count_non_bridge_devices(struct device_node *dn, void *data)
 static void *count_spare_msis(struct device_node *dn, void *data)
 {
         struct msi_counts *counts = data;
-        const u32 *p;
+        const __be32 *p;
         int req;
 
         if (dn == counts->requestor)
@@ -260,11 +262,11 @@ static void *count_spare_msis(struct device_node *dn, void *data)
                 req = 0;
                 p = of_get_property(dn, "ibm,req#msi", NULL);
                 if (p)
-                        req = *p;
+                        req = be32_to_cpup(p);
 
                 p = of_get_property(dn, "ibm,req#msi-x", NULL);
                 if (p)
-                        req = max(req, (int)*p);
+                        req = max(req, (int)be32_to_cpup(p));
         }
 
         if (req < counts->quota)
diff --git a/arch/powerpc/platforms/pseries/nvram.c b/arch/powerpc/platforms/pseries/nvram.c
index 7bfaf58d4664..d7096f2f7751 100644
--- a/arch/powerpc/platforms/pseries/nvram.c
+++ b/arch/powerpc/platforms/pseries/nvram.c
@@ -43,8 +43,8 @@ static char nvram_buf[NVRW_CNT];	/* assume this is in the first 4GB */
 static DEFINE_SPINLOCK(nvram_lock);
 
 struct err_log_info {
-        int error_type;
-        unsigned int seq_num;
+        __be32 error_type;
+        __be32 seq_num;
 };
 
 struct nvram_os_partition {
@@ -79,9 +79,9 @@ static const char *pseries_nvram_os_partitions[] = {
 };
 
 struct oops_log_info {
-        u16 version;
-        u16 report_length;
-        u64 timestamp;
+        __be16 version;
+        __be16 report_length;
+        __be64 timestamp;
 } __attribute__((packed));
 
 static void oops_to_nvram(struct kmsg_dumper *dumper,
@@ -291,8 +291,8 @@ int nvram_write_os_partition(struct nvram_os_partition *part, char * buff,
                 length = part->size;
         }
 
-        info.error_type = err_type;
-        info.seq_num = error_log_cnt;
+        info.error_type = cpu_to_be32(err_type);
+        info.seq_num = cpu_to_be32(error_log_cnt);
 
         tmp_index = part->index;
 
@@ -364,8 +364,8 @@ int nvram_read_partition(struct nvram_os_partition *part, char *buff,
         }
 
         if (part->os_partition) {
-                *error_log_cnt = info.seq_num;
-                *err_type = info.error_type;
+                *error_log_cnt = be32_to_cpu(info.seq_num);
+                *err_type = be32_to_cpu(info.error_type);
         }
 
         return 0;
@@ -529,9 +529,9 @@ static int zip_oops(size_t text_len)
                 pr_err("nvram: logging uncompressed oops/panic report\n");
                 return -1;
         }
-        oops_hdr->version = OOPS_HDR_VERSION;
-        oops_hdr->report_length = (u16) zipped_len;
-        oops_hdr->timestamp = get_seconds();
+        oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION);
+        oops_hdr->report_length = cpu_to_be16(zipped_len);
+        oops_hdr->timestamp = cpu_to_be64(get_seconds());
         return 0;
 }
 
@@ -574,9 +574,9 @@ static int nvram_pstore_write(enum pstore_type_id type,
                                 clobbering_unread_rtas_event())
                 return -1;
 
-        oops_hdr->version = OOPS_HDR_VERSION;
-        oops_hdr->report_length = (u16) size;
-        oops_hdr->timestamp = get_seconds();
+        oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION);
+        oops_hdr->report_length = cpu_to_be16(size);
+        oops_hdr->timestamp = cpu_to_be64(get_seconds());
 
         if (compressed)
                 err_type = ERR_TYPE_KERNEL_PANIC_GZ;
@@ -670,16 +670,16 @@ static ssize_t nvram_pstore_read(u64 *id, enum pstore_type_id *type,
                 size_t length, hdr_size;
 
                 oops_hdr = (struct oops_log_info *)buff;
-                if (oops_hdr->version < OOPS_HDR_VERSION) {
+                if (be16_to_cpu(oops_hdr->version) < OOPS_HDR_VERSION) {
                         /* Old format oops header had 2-byte record size */
                         hdr_size = sizeof(u16);
-                        length = oops_hdr->version;
+                        length = be16_to_cpu(oops_hdr->version);
                         time->tv_sec = 0;
                         time->tv_nsec = 0;
                 } else {
                         hdr_size = sizeof(*oops_hdr);
-                        length = oops_hdr->report_length;
-                        time->tv_sec = oops_hdr->timestamp;
+                        length = be16_to_cpu(oops_hdr->report_length);
+                        time->tv_sec = be64_to_cpu(oops_hdr->timestamp);
                         time->tv_nsec = 0;
                 }
                 *buf = kmalloc(length, GFP_KERNEL);
@@ -889,13 +889,13 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
                 kmsg_dump_get_buffer(dumper, false,
                                      oops_data, oops_data_sz, &text_len);
                 err_type = ERR_TYPE_KERNEL_PANIC;
-                oops_hdr->version = OOPS_HDR_VERSION;
-                oops_hdr->report_length = (u16) text_len;
-                oops_hdr->timestamp = get_seconds();
+                oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION);
+                oops_hdr->report_length = cpu_to_be16(text_len);
+                oops_hdr->timestamp = cpu_to_be64(get_seconds());
         }
 
         (void) nvram_write_os_partition(&oops_log_partition, oops_buf,
-                (int) (sizeof(*oops_hdr) + oops_hdr->report_length), err_type,
+                (int) (sizeof(*oops_hdr) + text_len), err_type,
                 ++oops_count);
 
         spin_unlock_irqrestore(&lock, flags);
diff --git a/arch/powerpc/platforms/pseries/pci.c b/arch/powerpc/platforms/pseries/pci.c
index 5f93856cdf47..70670a2d9cf2 100644
--- a/arch/powerpc/platforms/pseries/pci.c
+++ b/arch/powerpc/platforms/pseries/pci.c
@@ -113,7 +113,7 @@ int pseries_root_bridge_prepare(struct pci_host_bridge *bridge)
 {
         struct device_node *dn, *pdn;
         struct pci_bus *bus;
-        const uint32_t *pcie_link_speed_stats;
+        const __be32 *pcie_link_speed_stats;
 
         bus = bridge->bus;
 
@@ -122,7 +122,7 @@ int pseries_root_bridge_prepare(struct pci_host_bridge *bridge)
                 return 0;
 
         for (pdn = dn; pdn != NULL; pdn = of_get_next_parent(pdn)) {
-                pcie_link_speed_stats = (const uint32_t *) of_get_property(pdn,
+                pcie_link_speed_stats = of_get_property(pdn,
                         "ibm,pcie-link-speed-stats", NULL);
                 if (pcie_link_speed_stats)
                         break;
@@ -135,7 +135,7 @@ int pseries_root_bridge_prepare(struct pci_host_bridge *bridge)
                 return 0;
         }
 
-        switch (pcie_link_speed_stats[0]) {
+        switch (be32_to_cpup(pcie_link_speed_stats)) {
         case 0x01:
                 bus->max_bus_speed = PCIE_SPEED_2_5GT;
                 break;
@@ -147,7 +147,7 @@ int pseries_root_bridge_prepare(struct pci_host_bridge *bridge)
                 break;
         }
 
-        switch (pcie_link_speed_stats[1]) {
+        switch (be32_to_cpup(pcie_link_speed_stats)) {
         case 0x01:
                 bus->cur_bus_speed = PCIE_SPEED_2_5GT;
                 break;
diff --git a/arch/sh/lib/Makefile b/arch/sh/lib/Makefile
index 7b95f29e3174..3baff31e58cf 100644
--- a/arch/sh/lib/Makefile
+++ b/arch/sh/lib/Makefile
@@ -6,7 +6,7 @@ lib-y  = delay.o memmove.o memchr.o \
          checksum.o strlen.o div64.o div64-generic.o
 
 # Extracted from libgcc
-lib-y += movmem.o ashldi3.o ashrdi3.o lshrdi3.o \
+obj-y += movmem.o ashldi3.o ashrdi3.o lshrdi3.o \
          ashlsi3.o ashrsi3.o ashiftrt.o lshrsi3.o \
          udiv_qrnnd.o
 
diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index 8358dc144959..0f9e94537eee 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -619,7 +619,7 @@ static inline unsigned long pte_present(pte_t pte)
 }
 
 #define pte_accessible pte_accessible
-static inline unsigned long pte_accessible(pte_t a)
+static inline unsigned long pte_accessible(struct mm_struct *mm, pte_t a)
 {
         return pte_val(a) & _PAGE_VALID;
 }
@@ -847,7 +847,7 @@ static inline void __set_pte_at(struct mm_struct *mm, unsigned long addr,
          * SUN4V NOTE: _PAGE_VALID is the same value in both the SUN4U
          *             and SUN4V pte layout, so this inline test is fine.
          */
-        if (likely(mm != &init_mm) && pte_accessible(orig))
+        if (likely(mm != &init_mm) && pte_accessible(mm, orig))
                 tlb_batch_add(mm, addr, ptep, orig, fullmm);
 }
 
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index e903c71f7e69..0952ecd60eca 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -26,6 +26,7 @@ config X86
         select HAVE_AOUT if X86_32
         select HAVE_UNSTABLE_SCHED_CLOCK
         select ARCH_SUPPORTS_NUMA_BALANCING
+        select ARCH_SUPPORTS_INT128 if X86_64
         select ARCH_WANTS_PROT_NUMA_PROT_NONE
         select HAVE_IDE
         select HAVE_OPROFILE
diff --git a/arch/x86/include/asm/pgtable.h b/arch/x86/include/asm/pgtable.h
index 3d1999458709..bbc8b12fa443 100644
--- a/arch/x86/include/asm/pgtable.h
+++ b/arch/x86/include/asm/pgtable.h
@@ -452,9 +452,16 @@ static inline int pte_present(pte_t a)
 }
 
 #define pte_accessible pte_accessible
-static inline int pte_accessible(pte_t a)
+static inline bool pte_accessible(struct mm_struct *mm, pte_t a)
 {
-        return pte_flags(a) & _PAGE_PRESENT;
+        if (pte_flags(a) & _PAGE_PRESENT)
+                return true;
+
+        if ((pte_flags(a) & (_PAGE_PROTNONE | _PAGE_NUMA)) &&
+                        mm_tlb_flush_pending(mm))
+                return true;
+
+        return false;
 }
 
 static inline int pte_hidden(pte_t pte)
diff --git a/arch/x86/include/asm/preempt.h b/arch/x86/include/asm/preempt.h
index 8729723636fd..c8b051933b1b 100644
--- a/arch/x86/include/asm/preempt.h
+++ b/arch/x86/include/asm/preempt.h
@@ -8,6 +8,12 @@
 DECLARE_PER_CPU(int, __preempt_count);
 
 /*
+ * We use the PREEMPT_NEED_RESCHED bit as an inverted NEED_RESCHED such
+ * that a decrement hitting 0 means we can and should reschedule.
+ */
+#define PREEMPT_ENABLED (0 + PREEMPT_NEED_RESCHED)
+
+/*
  * We mask the PREEMPT_NEED_RESCHED bit so as not to confuse all current users
  * that think a non-zero value indicates we cannot preempt.
  */
@@ -74,6 +80,11 @@ static __always_inline void __preempt_count_sub(int val)
         __this_cpu_add_4(__preempt_count, -val);
 }
 
+/*
+ * Because we keep PREEMPT_NEED_RESCHED set when we do _not_ need to reschedule
+ * a decrement which hits zero means we have no preempt_count and should
+ * reschedule.
+ */
 static __always_inline bool __preempt_count_dec_and_test(void)
 {
         GEN_UNARY_RMWcc("decl", __preempt_count, __percpu_arg(0), "e");
diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c
index dc1ec0dff939..ea04b342c026 100644
--- a/arch/x86/kernel/cpu/intel.c
+++ b/arch/x86/kernel/cpu/intel.c
@@ -387,7 +387,8 @@ static void init_intel(struct cpuinfo_x86 *c)
                         set_cpu_cap(c, X86_FEATURE_PEBS);
         }
 
-        if (c->x86 == 6 && c->x86_model == 29 && cpu_has_clflush)
+        if (c->x86 == 6 && cpu_has_clflush &&
+            (c->x86_model == 29 || c->x86_model == 46 || c->x86_model == 47))
                 set_cpu_cap(c, X86_FEATURE_CLFLUSH_MONITOR);
 
 #ifdef CONFIG_X86_64
diff --git a/arch/x86/kernel/cpu/perf_event.h b/arch/x86/kernel/cpu/perf_event.h
index fd00bb29425d..c1a861829d81 100644
--- a/arch/x86/kernel/cpu/perf_event.h
+++ b/arch/x86/kernel/cpu/perf_event.h
@@ -262,11 +262,20 @@ struct cpu_hw_events {
         __EVENT_CONSTRAINT(c, n, INTEL_ARCH_EVENT_MASK, \
                           HWEIGHT(n), 0, PERF_X86_EVENT_PEBS_ST_HSW)
 
-#define EVENT_CONSTRAINT_END            \
-        EVENT_CONSTRAINT(0, 0, 0)
+/*
+ * We define the end marker as having a weight of -1
+ * to enable blacklisting of events using a counter bitmask
+ * of zero and thus a weight of zero.
+ * The end marker has a weight that cannot possibly be
+ * obtained from counting the bits in the bitmask.
+ */
+#define EVENT_CONSTRAINT_END { .weight = -1 }
 
+/*
+ * Check for end marker with weight == -1
+ */
 #define for_each_event_constraint(e, c) \
-        for ((e) = (c); (e)->weight; (e)++)
+        for ((e) = (c); (e)->weight != -1; (e)++)
 
 /*
  * Extra registers for specific events.
diff --git a/arch/x86/mm/gup.c b/arch/x86/mm/gup.c
index dd74e46828c0..0596e8e0cc19 100644
--- a/arch/x86/mm/gup.c
+++ b/arch/x86/mm/gup.c
@@ -83,6 +83,12 @@ static noinline int gup_pte_range(pmd_t pmd, unsigned long addr,
                 pte_t pte = gup_get_pte(ptep);
                 struct page *page;
 
+                /* Similar to the PMD case, NUMA hinting must take slow path */
+                if (pte_numa(pte)) {
+                        pte_unmap(ptep);
+                        return 0;
+                }
+
                 if ((pte_flags(pte) & (mask | _PAGE_SPECIAL)) != mask) {
                         pte_unmap(ptep);
                         return 0;
@@ -167,6 +173,13 @@ static int gup_pmd_range(pud_t pud, unsigned long addr, unsigned long end,
                 if (pmd_none(pmd) || pmd_trans_splitting(pmd))
                         return 0;
                 if (unlikely(pmd_large(pmd))) {
+                        /*
+                         * NUMA hinting faults need to be handled in the GUP
+                         * slowpath for accounting purposes and so that they
+                         * can be serialised against THP migration.
+                         */
+                        if (pmd_numa(pmd))
+                                return 0;
                         if (!gup_huge_pmd(pmd, addr, next, write, pages, nr))
                                 return 0;
                 } else {
diff --git a/block/blk-mq-sysfs.c b/block/blk-mq-sysfs.c
index ba6cf8e9aa0a..b91ce75bd35d 100644
--- a/block/blk-mq-sysfs.c
+++ b/block/blk-mq-sysfs.c
@@ -335,9 +335,22 @@ static struct kobj_type blk_mq_hw_ktype = {
 void blk_mq_unregister_disk(struct gendisk *disk)
 {
         struct request_queue *q = disk->queue;
+        struct blk_mq_hw_ctx *hctx;
+        struct blk_mq_ctx *ctx;
+        int i, j;
+
+        queue_for_each_hw_ctx(q, hctx, i) {
+                hctx_for_each_ctx(hctx, ctx, j) {
+                        kobject_del(&ctx->kobj);
+                        kobject_put(&ctx->kobj);
+                }
+                kobject_del(&hctx->kobj);
+                kobject_put(&hctx->kobj);
+        }
 
         kobject_uevent(&q->mq_kobj, KOBJ_REMOVE);
         kobject_del(&q->mq_kobj);
+        kobject_put(&q->mq_kobj);
 
         kobject_put(&disk_to_dev(disk)->kobj);
 }
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 5d9248526d78..4770de5707b9 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -348,7 +348,6 @@ source "drivers/acpi/apei/Kconfig"
 config ACPI_EXTLOG
         tristate "Extended Error Log support"
         depends on X86_MCE && X86_LOCAL_APIC
-        select EFI
         select UEFI_CPER
         default n
         help
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 6745fe137b9e..e60390597372 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -162,6 +162,7 @@ static const struct acpi_device_id acpi_lpss_device_ids[] = {
         { "80860F14", (unsigned long)&byt_sdio_dev_desc },
         { "80860F41", (unsigned long)&byt_i2c_dev_desc },
         { "INT33B2", },
+        { "INT33FC", },
 
         { "INT3430", (unsigned long)&lpt_dev_desc },
         { "INT3431", (unsigned long)&lpt_dev_desc },
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
index 786294bb682c..3650b2183227 100644
--- a/drivers/acpi/apei/Kconfig
+++ b/drivers/acpi/apei/Kconfig
@@ -2,7 +2,6 @@ config ACPI_APEI
         bool "ACPI Platform Error Interface (APEI)"
         select MISC_FILESYSTEMS
         select PSTORE
-        select EFI
         select UEFI_CPER
         depends on X86
         help
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 26311f23c824..cb1d557fc22c 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -942,6 +942,7 @@ static int erst_clearer(enum pstore_type_id type, u64 id, int count,
 static struct pstore_info erst_info = {
         .owner          = THIS_MODULE,
         .name           = "erst",
+        .flags          = PSTORE_FLAGS_FRAGILE,
         .open           = erst_open_pstore,
         .close          = erst_close_pstore,
         .read           = erst_reader,
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 14f1e9506338..c0ed4f273cf2 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1238,15 +1238,6 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        /* AHCI controllers often implement SFF compatible interface.
-         * Grab all PCI BARs just in case.
-         */
-        rc = pcim_iomap_regions_request_all(pdev, 1 << ahci_pci_bar, DRV_NAME);
-        if (rc == -EBUSY)
-                pcim_pin_device(pdev);
-        if (rc)
-                return rc;
-
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
             (pdev->device == 0x2652 || pdev->device == 0x2653)) {
                 u8 map;
@@ -1263,6 +1254,15 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 }
         }
 
+        /* AHCI controllers often implement SFF compatible interface.
+         * Grab all PCI BARs just in case.
+         */
+        rc = pcim_iomap_regions_request_all(pdev, 1 << ahci_pci_bar, DRV_NAME);
+        if (rc == -EBUSY)
+                pcim_pin_device(pdev);
+        if (rc)
+                return rc;
+
         hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
         if (!hpriv)
                 return -ENOMEM;
diff --git a/drivers/ata/ahci_imx.c b/drivers/ata/ahci_imx.c
index ae2d73fe321e..3e23e9941dad 100644
--- a/drivers/ata/ahci_imx.c
+++ b/drivers/ata/ahci_imx.c
@@ -113,7 +113,7 @@ static int imx6q_sata_init(struct device *dev, void __iomem *mmio)
         /*
          * set PHY Paremeters, two steps to configure the GPR13,
          * one write for rest of parameters, mask of first write
-         * is 0x07fffffd, and the other one write for setting
+         * is 0x07ffffff, and the other one write for setting
          * the mpll_clk_en.
          */
         regmap_update_bits(imxpriv->gpr, 0x34, IMX6Q_GPR13_SATA_RX_EQ_VAL_MASK
@@ -124,6 +124,7 @@ static int imx6q_sata_init(struct device *dev, void __iomem *mmio)
                         | IMX6Q_GPR13_SATA_TX_ATTEN_MASK
                         | IMX6Q_GPR13_SATA_TX_BOOST_MASK
                         | IMX6Q_GPR13_SATA_TX_LVL_MASK
+                        | IMX6Q_GPR13_SATA_MPLL_CLK_EN
                         | IMX6Q_GPR13_SATA_TX_EDGE_RATE
                         , IMX6Q_GPR13_SATA_RX_EQ_VAL_3_0_DB
                         | IMX6Q_GPR13_SATA_RX_LOS_LVL_SATA2M
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 75b93678bbcd..1393a5890ed5 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -2149,9 +2149,16 @@ static int ata_dev_config_ncq(struct ata_device *dev,
                                     "failed to get NCQ Send/Recv Log Emask 0x%x\n",
                                     err_mask);
                 } else {
+                        u8 *cmds = dev->ncq_send_recv_cmds;
+
                         dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
-                        memcpy(dev->ncq_send_recv_cmds, ap->sector_buf,
-                                ATA_LOG_NCQ_SEND_RECV_SIZE);
+                        memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
+
+                        if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
+                                ata_dev_dbg(dev, "disabling queued TRIM support\n");
+                                cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
+                                        ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
+                        }
                 }
         }
 
@@ -4156,6 +4163,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "ST3320[68]13AS",     "SD1[5-9]",     ATA_HORKAGE_NONCQ |
                                                 ATA_HORKAGE_FIRMWARE_WARN },
 
+        /* Seagate Momentus SpinPoint M8 seem to have FPMDA_AA issues */
+        { "ST1000LM024 HN-M101MBB", "2AR10001", ATA_HORKAGE_BROKEN_FPDMA_AA },
+
         /* Blacklist entries taken from Silicon Image 3124/3132
            Windows driver .inf file - also several Linux problem reports */
         { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
@@ -4202,6 +4212,10 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
         { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
 
+        /* devices that don't properly handle queued TRIM commands */
+        { "Micron_M500*",               NULL,   ATA_HORKAGE_NO_NCQ_TRIM, },
+        { "Crucial_CT???M500SSD1",      NULL,   ATA_HORKAGE_NO_NCQ_TRIM, },
+
         /* End Marker */
         { }
 };
@@ -6519,6 +6533,7 @@ static int __init ata_parse_force_one(char **cur,
                 { "norst",      .lflags         = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST },
                 { "rstonce",    .lflags         = ATA_LFLAG_RST_ONCE },
                 { "atapi_dmadir", .horkage_on   = ATA_HORKAGE_ATAPI_DMADIR },
+                { "disable",    .horkage_on     = ATA_HORKAGE_DISABLE },
         };
         char *start = *cur, *p = *cur;
         char *id, *val, *endp;
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index ab58556d347c..377eb889f555 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -3872,6 +3872,27 @@ void ata_scsi_hotplug(struct work_struct *work)
                 return;
         }
 
+        /*
+         * XXX - UGLY HACK
+         *
+         * The block layer suspend/resume path is fundamentally broken due
+         * to freezable kthreads and workqueue and may deadlock if a block
+         * device gets removed while resume is in progress.  I don't know
+         * what the solution is short of removing freezable kthreads and
+         * workqueues altogether.
+         *
+         * The following is an ugly hack to avoid kicking off device
+         * removal while freezer is active.  This is a joke but does avoid
+         * this particular deadlock scenario.
+         *
+         * https://bugzilla.kernel.org/show_bug.cgi?id=62801
+         * http://marc.info/?l=linux-kernel&m=138695698516487
+         */
+#ifdef CONFIG_FREEZER
+        while (pm_freezing)
+                msleep(10);
+#endif
+
         DPRINTK("ENTER\n");
         mutex_lock(&ap->scsi_scan_mutex);
 
diff --git a/drivers/block/null_blk.c b/drivers/block/null_blk.c
index f370fc13aea5..a2e69d26266d 100644
--- a/drivers/block/null_blk.c
+++ b/drivers/block/null_blk.c
@@ -1,4 +1,5 @@
 #include <linux/module.h>
+
 #include <linux/moduleparam.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
@@ -65,7 +66,7 @@ enum {
         NULL_Q_MQ               = 2,
 };
 
-static int submit_queues = 1;
+static int submit_queues;
 module_param(submit_queues, int, S_IRUGO);
 MODULE_PARM_DESC(submit_queues, "Number of submission queues");
 
@@ -101,9 +102,9 @@ static int hw_queue_depth = 64;
 module_param(hw_queue_depth, int, S_IRUGO);
 MODULE_PARM_DESC(hw_queue_depth, "Queue depth for each hardware queue. Default: 64");
 
-static bool use_per_node_hctx = true;
+static bool use_per_node_hctx = false;
 module_param(use_per_node_hctx, bool, S_IRUGO);
-MODULE_PARM_DESC(use_per_node_hctx, "Use per-node allocation for hardware context queues. Default: true");
+MODULE_PARM_DESC(use_per_node_hctx, "Use per-node allocation for hardware context queues. Default: false");
 
 static void put_tag(struct nullb_queue *nq, unsigned int tag)
 {
@@ -346,8 +347,37 @@ static int null_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *rq)
 
 static struct blk_mq_hw_ctx *null_alloc_hctx(struct blk_mq_reg *reg, unsigned int hctx_index)
 {
-        return kzalloc_node(sizeof(struct blk_mq_hw_ctx), GFP_KERNEL,
-                                hctx_index);
+        int b_size = DIV_ROUND_UP(reg->nr_hw_queues, nr_online_nodes);
+        int tip = (reg->nr_hw_queues % nr_online_nodes);
+        int node = 0, i, n;
+
+        /*
+         * Split submit queues evenly wrt to the number of nodes. If uneven,
+         * fill the first buckets with one extra, until the rest is filled with
+         * no extra.
+         */
+        for (i = 0, n = 1; i < hctx_index; i++, n++) {
+                if (n % b_size == 0) {
+                        n = 0;
+                        node++;
+
+                        tip--;
+                        if (!tip)
+                                b_size = reg->nr_hw_queues / nr_online_nodes;
+                }
+        }
+
+        /*
+         * A node might not be online, therefore map the relative node id to the
+         * real node id.
+         */
+        for_each_online_node(n) {
+                if (!node)
+                        break;
+                node--;
+        }
+
+        return kzalloc_node(sizeof(struct blk_mq_hw_ctx), GFP_KERNEL, n);
 }
 
 static void null_free_hctx(struct blk_mq_hw_ctx *hctx, unsigned int hctx_index)
@@ -355,16 +385,24 @@ static void null_free_hctx(struct blk_mq_hw_ctx *hctx, unsigned int hctx_index)
         kfree(hctx);
 }
 
+static void null_init_queue(struct nullb *nullb, struct nullb_queue *nq)
+{
+        BUG_ON(!nullb);
+        BUG_ON(!nq);
+
+        init_waitqueue_head(&nq->wait);
+        nq->queue_depth = nullb->queue_depth;
+}
+
 static int null_init_hctx(struct blk_mq_hw_ctx *hctx, void *data,
                           unsigned int index)
 {
         struct nullb *nullb = data;
         struct nullb_queue *nq = &nullb->queues[index];
 
-        init_waitqueue_head(&nq->wait);
-        nq->queue_depth = nullb->queue_depth;
-        nullb->nr_queues++;
         hctx->driver_data = nq;
+        null_init_queue(nullb, nq);
+        nullb->nr_queues++;
 
         return 0;
 }
@@ -417,13 +455,13 @@ static int setup_commands(struct nullb_queue *nq)
 
         nq->cmds = kzalloc(nq->queue_depth * sizeof(*cmd), GFP_KERNEL);
         if (!nq->cmds)
-                return 1;
+                return -ENOMEM;
 
         tag_size = ALIGN(nq->queue_depth, BITS_PER_LONG) / BITS_PER_LONG;
         nq->tag_map = kzalloc(tag_size * sizeof(unsigned long), GFP_KERNEL);
         if (!nq->tag_map) {
                 kfree(nq->cmds);
-                return 1;
+                return -ENOMEM;
         }
 
         for (i = 0; i < nq->queue_depth; i++) {
@@ -454,33 +492,37 @@ static void cleanup_queues(struct nullb *nullb)
 
 static int setup_queues(struct nullb *nullb)
 {
-        struct nullb_queue *nq;
-        int i;
-
-        nullb->queues = kzalloc(submit_queues * sizeof(*nq), GFP_KERNEL);
+        nullb->queues = kzalloc(submit_queues * sizeof(struct nullb_queue),
+                                                                GFP_KERNEL);
         if (!nullb->queues)
-                return 1;
+                return -ENOMEM;
 
         nullb->nr_queues = 0;
         nullb->queue_depth = hw_queue_depth;
 
-        if (queue_mode == NULL_Q_MQ)
-                return 0;
+        return 0;
+}
+
+static int init_driver_queues(struct nullb *nullb)
+{
+        struct nullb_queue *nq;
+        int i, ret = 0;
 
         for (i = 0; i < submit_queues; i++) {
                 nq = &nullb->queues[i];
-                init_waitqueue_head(&nq->wait);
-                nq->queue_depth = hw_queue_depth;
-                if (setup_commands(nq))
-                        break;
+
+                null_init_queue(nullb, nq);
+
+                ret = setup_commands(nq);
+                if (ret)
+                        goto err_queue;
                 nullb->nr_queues++;
         }
 
-        if (i == submit_queues)
-                return 0;
-
+        return 0;
+err_queue:
         cleanup_queues(nullb);
-        return 1;
+        return ret;
 }
 
 static int null_add_dev(void)
@@ -518,11 +560,13 @@ static int null_add_dev(void)
         } else if (queue_mode == NULL_Q_BIO) {
                 nullb->q = blk_alloc_queue_node(GFP_KERNEL, home_node);
                 blk_queue_make_request(nullb->q, null_queue_bio);
+                init_driver_queues(nullb);
         } else {
                 nullb->q = blk_init_queue_node(null_request_fn, &nullb->lock, home_node);
                 blk_queue_prep_rq(nullb->q, null_rq_prep_fn);
                 if (nullb->q)
                         blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
+                init_driver_queues(nullb);
         }
 
         if (!nullb->q)
@@ -579,7 +623,13 @@ static int __init null_init(void)
         }
 #endif
 
-        if (submit_queues > nr_cpu_ids)
+        if (queue_mode == NULL_Q_MQ && use_per_node_hctx) {
+                if (submit_queues < nr_online_nodes) {
+                        pr_warn("null_blk: submit_queues param is set to %u.",
+                                                        nr_online_nodes);
+                        submit_queues = nr_online_nodes;
+                }
+        } else if (submit_queues > nr_cpu_ids)
                 submit_queues = nr_cpu_ids;
         else if (!submit_queues)
                 submit_queues = 1;
diff --git a/drivers/block/skd_main.c b/drivers/block/skd_main.c
index 9199c93be926..eb6e1e0e8db2 100644
--- a/drivers/block/skd_main.c
+++ b/drivers/block/skd_main.c
@@ -5269,7 +5269,7 @@ const char *skd_skdev_state_to_str(enum skd_drvr_state state)
         }
 }
 
-const char *skd_skmsg_state_to_str(enum skd_fit_msg_state state)
+static const char *skd_skmsg_state_to_str(enum skd_fit_msg_state state)
 {
         switch (state) {
         case SKD_MSG_STATE_IDLE:
@@ -5281,7 +5281,7 @@ const char *skd_skmsg_state_to_str(enum skd_fit_msg_state state)
         }
 }
 
-const char *skd_skreq_state_to_str(enum skd_req_state state)
+static const char *skd_skreq_state_to_str(enum skd_req_state state)
 {
         switch (state) {
         case SKD_REQ_STATE_IDLE:
diff --git a/drivers/clk/clk-s2mps11.c b/drivers/clk/clk-s2mps11.c
index 7be41e676a64..00a3abe103a5 100644
--- a/drivers/clk/clk-s2mps11.c
+++ b/drivers/clk/clk-s2mps11.c
@@ -60,7 +60,7 @@ static int s2mps11_clk_prepare(struct clk_hw *hw)
         struct s2mps11_clk *s2mps11 = to_s2mps11_clk(hw);
         int ret;
 
-        ret = regmap_update_bits(s2mps11->iodev->regmap,
+        ret = regmap_update_bits(s2mps11->iodev->regmap_pmic,
                                 S2MPS11_REG_RTC_CTRL,
                                  s2mps11->mask, s2mps11->mask);
         if (!ret)
@@ -74,7 +74,7 @@ static void s2mps11_clk_unprepare(struct clk_hw *hw)
         struct s2mps11_clk *s2mps11 = to_s2mps11_clk(hw);
         int ret;
 
-        ret = regmap_update_bits(s2mps11->iodev->regmap, S2MPS11_REG_RTC_CTRL,
+        ret = regmap_update_bits(s2mps11->iodev->regmap_pmic, S2MPS11_REG_RTC_CTRL,
                            s2mps11->mask, ~s2mps11->mask);
 
         if (!ret)
@@ -174,7 +174,7 @@ static int s2mps11_clk_probe(struct platform_device *pdev)
                 s2mps11_clk->hw.init = &s2mps11_clks_init[i];
                 s2mps11_clk->mask = 1 << i;
 
-                ret = regmap_read(s2mps11_clk->iodev->regmap,
+                ret = regmap_read(s2mps11_clk->iodev->regmap_pmic,
                                   S2MPS11_REG_RTC_CTRL, &val);
                 if (ret < 0)
                         goto err_reg;
diff --git a/drivers/clk/samsung/clk-s3c64xx.c b/drivers/clk/samsung/clk-s3c64xx.c
index 7d2c84265947..8e27aee6887e 100644
--- a/drivers/clk/samsung/clk-s3c64xx.c
+++ b/drivers/clk/samsung/clk-s3c64xx.c
@@ -331,8 +331,8 @@ static struct samsung_clock_alias s3c64xx_clock_aliases[] = {
         ALIAS(HCLK_HSMMC1, "s3c-sdhci.1", "mmc_busclk.0"),
         ALIAS(HCLK_HSMMC0, "s3c-sdhci.0", "hsmmc"),
         ALIAS(HCLK_HSMMC0, "s3c-sdhci.0", "mmc_busclk.0"),
-        ALIAS(HCLK_DMA1, NULL, "dma1"),
-        ALIAS(HCLK_DMA0, NULL, "dma0"),
+        ALIAS(HCLK_DMA1, "dma-pl080s.1", "apb_pclk"),
+        ALIAS(HCLK_DMA0, "dma-pl080s.0", "apb_pclk"),
         ALIAS(HCLK_CAMIF, "s3c-camif", "camif"),
         ALIAS(HCLK_LCD, "s3c-fb", "lcd"),
         ALIAS(PCLK_SPI1, "s3c6410-spi.1", "spi"),
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index 5c07a56962db..634c4d6dd45a 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -75,6 +75,7 @@ config CLKSRC_DBX500_PRCMU_SCHED_CLOCK
 config CLKSRC_EFM32
         bool "Clocksource for Energy Micro's EFM32 SoCs" if !ARCH_EFM32
         depends on OF && ARM && (ARCH_EFM32 || COMPILE_TEST)
+        select CLKSRC_MMIO
         default ARCH_EFM32
         help
           Support to use the timers of EFM32 SoCs as clock source and clock
diff --git a/drivers/clocksource/clksrc-of.c b/drivers/clocksource/clksrc-of.c
index 35639cf4e5a2..b9ddd9e3a2f5 100644
--- a/drivers/clocksource/clksrc-of.c
+++ b/drivers/clocksource/clksrc-of.c
@@ -35,6 +35,5 @@ void __init clocksource_of_init(void)
 
                 init_func = match->data;
                 init_func(np);
-                of_node_put(np);
         }
 }
diff --git a/drivers/clocksource/dw_apb_timer_of.c b/drivers/clocksource/dw_apb_timer_of.c
index 45ba8aecc729..2a2ea2717f3a 100644
--- a/drivers/clocksource/dw_apb_timer_of.c
+++ b/drivers/clocksource/dw_apb_timer_of.c
@@ -108,12 +108,11 @@ static void __init add_clocksource(struct device_node *source_timer)
 
 static u64 read_sched_clock(void)
 {
-        return __raw_readl(sched_io_base);
+        return ~__raw_readl(sched_io_base);
 }
 
 static const struct of_device_id sptimer_ids[] __initconst = {
         { .compatible = "picochip,pc3x2-rtc" },
-        { .compatible = "snps,dw-apb-timer-sp" },
         { /* Sentinel */ },
 };
 
@@ -151,4 +150,6 @@ static void __init dw_apb_timer_init(struct device_node *timer)
         num_called++;
 }
 CLOCKSOURCE_OF_DECLARE(pc3x2_timer, "picochip,pc3x2-timer", dw_apb_timer_init);
-CLOCKSOURCE_OF_DECLARE(apb_timer, "snps,dw-apb-timer-osc", dw_apb_timer_init);
+CLOCKSOURCE_OF_DECLARE(apb_timer_osc, "snps,dw-apb-timer-osc", dw_apb_timer_init);
+CLOCKSOURCE_OF_DECLARE(apb_timer_sp, "snps,dw-apb-timer-sp", dw_apb_timer_init);
+CLOCKSOURCE_OF_DECLARE(apb_timer, "snps,dw-apb-timer", dw_apb_timer_init);
diff --git a/drivers/clocksource/sun4i_timer.c b/drivers/clocksource/sun4i_timer.c
index 2fb4695a28d8..a4f6119aafd8 100644
--- a/drivers/clocksource/sun4i_timer.c
+++ b/drivers/clocksource/sun4i_timer.c
@@ -179,6 +179,9 @@ static void __init sun4i_timer_init(struct device_node *node)
         writel(TIMER_CTL_CLK_SRC(TIMER_CTL_CLK_SRC_OSC24M),
                timer_base + TIMER_CTL_REG(0));
 
+        /* Make sure timer is stopped before playing with interrupts */
+        sun4i_clkevt_time_stop(0);
+
         ret = setup_irq(irq, &sun4i_timer_irq);
         if (ret)
                 pr_warn("failed to setup irq %d\n", irq);
diff --git a/drivers/clocksource/time-armada-370-xp.c b/drivers/clocksource/time-armada-370-xp.c
index d8e47e502785..4e7f6802e840 100644
--- a/drivers/clocksource/time-armada-370-xp.c
+++ b/drivers/clocksource/time-armada-370-xp.c
@@ -256,11 +256,6 @@ static void __init armada_370_xp_timer_common_init(struct device_node *np)
         ticks_per_jiffy = (timer_clk + HZ / 2) / HZ;
 
         /*
-         * Set scale and timer for sched_clock.
-         */
-        sched_clock_register(armada_370_xp_read_sched_clock, 32, timer_clk);
-
-        /*
          * Setup free-running clocksource timer (interrupts
          * disabled).
          */
@@ -270,6 +265,11 @@ static void __init armada_370_xp_timer_common_init(struct device_node *np)
         timer_ctrl_clrset(0, TIMER0_EN | TIMER0_RELOAD_EN |
                              TIMER0_DIV(TIMER_DIVIDER_SHIFT));
 
+        /*
+         * Set scale and timer for sched_clock.
+         */
+        sched_clock_register(armada_370_xp_read_sched_clock, 32, timer_clk);
+
         clocksource_mmio_init(timer_base + TIMER0_VAL_OFF,
                               "armada_370_xp_clocksource",
                               timer_clk, 300, 32, clocksource_mmio_readl_down);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 02d534da22dd..16d7b4ac94be 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -828,6 +828,12 @@ static void cpufreq_init_policy(struct cpufreq_policy *policy)
         int ret = 0;
 
         memcpy(&new_policy, policy, sizeof(*policy));
+
+        /* Use the default policy if its valid. */
+        if (cpufreq_driver->setpolicy)
+                cpufreq_parse_governor(policy->governor->name,
+                                        &new_policy.policy, NULL);
+
         /* assure that the starting sequence is run in cpufreq_set_policy */
         policy->governor = NULL;
 
@@ -845,8 +851,7 @@ static void cpufreq_init_policy(struct cpufreq_policy *policy)
 
 #ifdef CONFIG_HOTPLUG_CPU
 static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
-                                  unsigned int cpu, struct device *dev,
-                                  bool frozen)
+                                  unsigned int cpu, struct device *dev)
 {
         int ret = 0;
         unsigned long flags;
@@ -877,11 +882,7 @@ static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
                 }
         }
 
-        /* Don't touch sysfs links during light-weight init */
-        if (!frozen)
-                ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
-
-        return ret;
+        return sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
 }
 #endif
 
@@ -926,6 +927,27 @@ err_free_policy:
         return NULL;
 }
 
+static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy)
+{
+        struct kobject *kobj;
+        struct completion *cmp;
+
+        down_read(&policy->rwsem);
+        kobj = &policy->kobj;
+        cmp = &policy->kobj_unregister;
+        up_read(&policy->rwsem);
+        kobject_put(kobj);
+
+        /*
+         * We need to make sure that the underlying kobj is
+         * actually not referenced anymore by anybody before we
+         * proceed with unloading.
+         */
+        pr_debug("waiting for dropping of refcount\n");
+        wait_for_completion(cmp);
+        pr_debug("wait complete\n");
+}
+
 static void cpufreq_policy_free(struct cpufreq_policy *policy)
 {
         free_cpumask_var(policy->related_cpus);
@@ -986,7 +1008,7 @@ static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
         list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
                 if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
                         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                        ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev, frozen);
+                        ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev);
                         up_read(&cpufreq_rwsem);
                         return ret;
                 }
@@ -1096,7 +1118,10 @@ err_get_freq:
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(policy);
 err_set_policy_cpu:
+        if (frozen)
+                cpufreq_policy_put_kobj(policy);
         cpufreq_policy_free(policy);
+
 nomem_out:
         up_read(&cpufreq_rwsem);
 
@@ -1118,7 +1143,7 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
 }
 
 static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
-                                           unsigned int old_cpu, bool frozen)
+                                           unsigned int old_cpu)
 {
         struct device *cpu_dev;
         int ret;
@@ -1126,10 +1151,6 @@ static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
         /* first sibling now owns the new sysfs dir */
         cpu_dev = get_cpu_device(cpumask_any_but(policy->cpus, old_cpu));
 
-        /* Don't touch sysfs files during light-weight tear-down */
-        if (frozen)
-                return cpu_dev->id;
-
         sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
         ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
         if (ret) {
@@ -1196,7 +1217,7 @@ static int __cpufreq_remove_dev_prepare(struct device *dev,
                 if (!frozen)
                         sysfs_remove_link(&dev->kobj, "cpufreq");
         } else if (cpus > 1) {
-                new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
+                new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu);
                 if (new_cpu >= 0) {
                         update_policy_cpu(policy, new_cpu);
 
@@ -1218,8 +1239,6 @@ static int __cpufreq_remove_dev_finish(struct device *dev,
         int ret;
         unsigned long flags;
         struct cpufreq_policy *policy;
-        struct kobject *kobj;
-        struct completion *cmp;
 
         read_lock_irqsave(&cpufreq_driver_lock, flags);
         policy = per_cpu(cpufreq_cpu_data, cpu);
@@ -1249,22 +1268,8 @@ static int __cpufreq_remove_dev_finish(struct device *dev,
                         }
                 }
 
-                if (!frozen) {
-                        down_read(&policy->rwsem);
-                        kobj = &policy->kobj;
-                        cmp = &policy->kobj_unregister;
-                        up_read(&policy->rwsem);
-                        kobject_put(kobj);
-
-                        /*
-                         * We need to make sure that the underlying kobj is
-                         * actually not referenced anymore by anybody before we
-                         * proceed with unloading.
-                         */
-                        pr_debug("waiting for dropping of refcount\n");
-                        wait_for_completion(cmp);
-                        pr_debug("wait complete\n");
-                }
+                if (!frozen)
+                        cpufreq_policy_put_kobj(policy);
 
                 /*
                  * Perform the ->exit() even during light-weight tear-down,
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index 446687cc2334..c823daaf9043 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -62,6 +62,7 @@ config INTEL_IOATDMA
         tristate "Intel I/OAT DMA support"
         depends on PCI && X86
         select DMA_ENGINE
+        select DMA_ENGINE_RAID
         select DCA
         help
           Enable support for the Intel(R) I/OAT DMA engine present
@@ -112,6 +113,7 @@ config MV_XOR
         bool "Marvell XOR engine support"
         depends on PLAT_ORION
         select DMA_ENGINE
+        select DMA_ENGINE_RAID
         select ASYNC_TX_ENABLE_CHANNEL_SWITCH
         ---help---
           Enable support for the Marvell XOR engine.
@@ -187,6 +189,7 @@ config AMCC_PPC440SPE_ADMA
         tristate "AMCC PPC440SPe ADMA support"
         depends on 440SPe || 440SP
         select DMA_ENGINE
+        select DMA_ENGINE_RAID
         select ARCH_HAS_ASYNC_TX_FIND_CHANNEL
         select ASYNC_TX_ENABLE_CHANNEL_SWITCH
         help
@@ -352,6 +355,7 @@ config NET_DMA
         bool "Network: TCP receive copy offload"
         depends on DMA_ENGINE && NET
         default (INTEL_IOATDMA || FSL_DMA)
+        depends on BROKEN
         help
           This enables the use of DMA engines in the network stack to
           offload receive copy-to-user operations, freeing CPU cycles.
@@ -377,4 +381,7 @@ config DMATEST
           Simple DMA test client. Say N unless you're debugging a
           DMA Device driver.
 
+config DMA_ENGINE_RAID
+        bool
+
 endif
diff --git a/drivers/dma/at_hdmac_regs.h b/drivers/dma/at_hdmac_regs.h
index f31d647acdfa..2787aba60c6b 100644
--- a/drivers/dma/at_hdmac_regs.h
+++ b/drivers/dma/at_hdmac_regs.h
@@ -347,10 +347,6 @@ static struct device *chan2dev(struct dma_chan *chan)
 {
         return &chan->dev->device;
 }
-static struct device *chan2parent(struct dma_chan *chan)
-{
-        return chan->dev->device.parent;
-}
 
 #if defined(VERBOSE_DEBUG)
 static void vdbg_dump_regs(struct at_dma_chan *atchan)
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index ea806bdc12ef..92caad629d99 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -540,6 +540,8 @@ EXPORT_SYMBOL_GPL(dma_get_slave_channel);
  * @mask: capabilities that the channel must satisfy
  * @fn: optional callback to disposition available channels
  * @fn_param: opaque parameter to pass to dma_filter_fn
+ *
+ * Returns pointer to appropriate DMA channel on success or NULL.
  */
 struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
                                        dma_filter_fn fn, void *fn_param)
@@ -591,18 +593,43 @@ EXPORT_SYMBOL_GPL(__dma_request_channel);
  * dma_request_slave_channel - try to allocate an exclusive slave channel
  * @dev:        pointer to client device structure
  * @name:       slave channel name
+ *
+ * Returns pointer to appropriate DMA channel on success or an error pointer.
  */
-struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name)
+struct dma_chan *dma_request_slave_channel_reason(struct device *dev,
+                                                  const char *name)
 {
+        struct dma_chan *chan;
+
         /* If device-tree is present get slave info from here */
         if (dev->of_node)
                 return of_dma_request_slave_channel(dev->of_node, name);
 
         /* If device was enumerated by ACPI get slave info from here */
-        if (ACPI_HANDLE(dev))
-                return acpi_dma_request_slave_chan_by_name(dev, name);
+        if (ACPI_HANDLE(dev)) {
+                chan = acpi_dma_request_slave_chan_by_name(dev, name);
+                if (chan)
+                        return chan;
+        }
 
-        return NULL;
+        return ERR_PTR(-ENODEV);
+}
+EXPORT_SYMBOL_GPL(dma_request_slave_channel_reason);
+
+/**
+ * dma_request_slave_channel - try to allocate an exclusive slave channel
+ * @dev:        pointer to client device structure
+ * @name:       slave channel name
+ *
+ * Returns pointer to appropriate DMA channel on success or NULL.
+ */
+struct dma_chan *dma_request_slave_channel(struct device *dev,
+                                           const char *name)
+{
+        struct dma_chan *ch = dma_request_slave_channel_reason(dev, name);
+        if (IS_ERR(ch))
+                return NULL;
+        return ch;
 }
 EXPORT_SYMBOL_GPL(dma_request_slave_channel);
 
@@ -912,7 +939,7 @@ struct dmaengine_unmap_pool {
 #define __UNMAP_POOL(x) { .size = x, .name = "dmaengine-unmap-" __stringify(x) }
 static struct dmaengine_unmap_pool unmap_pool[] = {
         __UNMAP_POOL(2),
-        #if IS_ENABLED(CONFIG_ASYNC_TX_DMA)
+        #if IS_ENABLED(CONFIG_DMA_ENGINE_RAID)
         __UNMAP_POOL(16),
         __UNMAP_POOL(128),
         __UNMAP_POOL(256),
@@ -1054,7 +1081,7 @@ dma_async_memcpy_pg_to_pg(struct dma_chan *chan, struct page *dest_pg,
         dma_cookie_t cookie;
         unsigned long flags;
 
-        unmap = dmaengine_get_unmap_data(dev->dev, 2, GFP_NOIO);
+        unmap = dmaengine_get_unmap_data(dev->dev, 2, GFP_NOWAIT);
         if (!unmap)
                 return -ENOMEM;
 
diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
index 20f9a3aaf926..9dfcaf5c1288 100644
--- a/drivers/dma/dmatest.c
+++ b/drivers/dma/dmatest.c
@@ -539,9 +539,9 @@ static int dmatest_func(void *data)
 
                 um->len = params->buf_size;
                 for (i = 0; i < src_cnt; i++) {
-                        unsigned long buf = (unsigned long) thread->srcs[i];
+                        void *buf = thread->srcs[i];
                         struct page *pg = virt_to_page(buf);
-                        unsigned pg_off = buf & ~PAGE_MASK;
+                        unsigned pg_off = (unsigned long) buf & ~PAGE_MASK;
 
                         um->addr[i] = dma_map_page(dev->dev, pg, pg_off,
                                                    um->len, DMA_TO_DEVICE);
@@ -559,9 +559,9 @@ static int dmatest_func(void *data)
                 /* map with DMA_BIDIRECTIONAL to force writeback/invalidate */
                 dsts = &um->addr[src_cnt];
                 for (i = 0; i < dst_cnt; i++) {
-                        unsigned long buf = (unsigned long) thread->dsts[i];
+                        void *buf = thread->dsts[i];
                         struct page *pg = virt_to_page(buf);
-                        unsigned pg_off = buf & ~PAGE_MASK;
+                        unsigned pg_off = (unsigned long) buf & ~PAGE_MASK;
 
                         dsts[i] = dma_map_page(dev->dev, pg, pg_off, um->len,
                                                DMA_BIDIRECTIONAL);
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index 7086a16a55f2..f157c6f76b32 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -86,11 +86,6 @@ static void set_desc_cnt(struct fsldma_chan *chan,
         hw->count = CPU_TO_DMA(chan, count, 32);
 }
 
-static u32 get_desc_cnt(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
-{
-        return DMA_TO_CPU(chan, desc->hw.count, 32);
-}
-
 static void set_desc_src(struct fsldma_chan *chan,
                          struct fsl_dma_ld_hw *hw, dma_addr_t src)
 {
@@ -101,16 +96,6 @@ static void set_desc_src(struct fsldma_chan *chan,
         hw->src_addr = CPU_TO_DMA(chan, snoop_bits | src, 64);
 }
 
-static dma_addr_t get_desc_src(struct fsldma_chan *chan,
-                               struct fsl_desc_sw *desc)
-{
-        u64 snoop_bits;
-
-        snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
-                ? ((u64)FSL_DMA_SATR_SREADTYPE_SNOOP_READ << 32) : 0;
-        return DMA_TO_CPU(chan, desc->hw.src_addr, 64) & ~snoop_bits;
-}
-
 static void set_desc_dst(struct fsldma_chan *chan,
                          struct fsl_dma_ld_hw *hw, dma_addr_t dst)
 {
@@ -121,16 +106,6 @@ static void set_desc_dst(struct fsldma_chan *chan,
         hw->dst_addr = CPU_TO_DMA(chan, snoop_bits | dst, 64);
 }
 
-static dma_addr_t get_desc_dst(struct fsldma_chan *chan,
-                               struct fsl_desc_sw *desc)
-{
-        u64 snoop_bits;
-
-        snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
-                ? ((u64)FSL_DMA_DATR_DWRITETYPE_SNOOP_WRITE << 32) : 0;
-        return DMA_TO_CPU(chan, desc->hw.dst_addr, 64) & ~snoop_bits;
-}
-
 static void set_desc_next(struct fsldma_chan *chan,
                           struct fsl_dma_ld_hw *hw, dma_addr_t next)
 {
@@ -408,7 +383,7 @@ static dma_cookie_t fsl_dma_tx_submit(struct dma_async_tx_descriptor *tx)
         struct fsl_desc_sw *desc = tx_to_fsl_desc(tx);
         struct fsl_desc_sw *child;
         unsigned long flags;
-        dma_cookie_t cookie;
+        dma_cookie_t cookie = -EINVAL;
 
         spin_lock_irqsave(&chan->desc_lock, flags);
 
@@ -854,10 +829,6 @@ static void fsldma_cleanup_descriptor(struct fsldma_chan *chan,
                                       struct fsl_desc_sw *desc)
 {
         struct dma_async_tx_descriptor *txd = &desc->async_tx;
-        struct device *dev = chan->common.device->dev;
-        dma_addr_t src = get_desc_src(chan, desc);
-        dma_addr_t dst = get_desc_dst(chan, desc);
-        u32 len = get_desc_cnt(chan, desc);
 
         /* Run the link descriptor callback function */
         if (txd->callback) {
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index 7807f0ef4e20..53fb0c8365b0 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -54,12 +54,6 @@ static void mv_desc_init(struct mv_xor_desc_slot *desc, unsigned long flags)
         hw_desc->desc_command = (1 << 31);
 }
 
-static u32 mv_desc_get_dest_addr(struct mv_xor_desc_slot *desc)
-{
-        struct mv_xor_desc *hw_desc = desc->hw_desc;
-        return hw_desc->phy_dest_addr;
-}
-
 static void mv_desc_set_byte_count(struct mv_xor_desc_slot *desc,
                                    u32 byte_count)
 {
@@ -787,7 +781,6 @@ static void mv_xor_issue_pending(struct dma_chan *chan)
 /*
  * Perform a transaction to verify the HW works.
  */
-#define MV_XOR_TEST_SIZE 2000
 
 static int mv_xor_memcpy_self_test(struct mv_xor_chan *mv_chan)
 {
@@ -797,20 +790,21 @@ static int mv_xor_memcpy_self_test(struct mv_xor_chan *mv_chan)
         struct dma_chan *dma_chan;
         dma_cookie_t cookie;
         struct dma_async_tx_descriptor *tx;
+        struct dmaengine_unmap_data *unmap;
         int err = 0;
 
-        src = kmalloc(sizeof(u8) * MV_XOR_TEST_SIZE, GFP_KERNEL);
+        src = kmalloc(sizeof(u8) * PAGE_SIZE, GFP_KERNEL);
         if (!src)
                 return -ENOMEM;
 
-        dest = kzalloc(sizeof(u8) * MV_XOR_TEST_SIZE, GFP_KERNEL);
+        dest = kzalloc(sizeof(u8) * PAGE_SIZE, GFP_KERNEL);
         if (!dest) {
                 kfree(src);
                 return -ENOMEM;
         }
 
         /* Fill in src buffer */
-        for (i = 0; i < MV_XOR_TEST_SIZE; i++)
+        for (i = 0; i < PAGE_SIZE; i++)
                 ((u8 *) src)[i] = (u8)i;
 
         dma_chan = &mv_chan->dmachan;
@@ -819,14 +813,26 @@ static int mv_xor_memcpy_self_test(struct mv_xor_chan *mv_chan)
                 goto out;
         }
 
-        dest_dma = dma_map_single(dma_chan->device->dev, dest,
-                                  MV_XOR_TEST_SIZE, DMA_FROM_DEVICE);
+        unmap = dmaengine_get_unmap_data(dma_chan->device->dev, 2, GFP_KERNEL);
+        if (!unmap) {
+                err = -ENOMEM;
+                goto free_resources;
+        }
+
+        src_dma = dma_map_page(dma_chan->device->dev, virt_to_page(src), 0,
+                                 PAGE_SIZE, DMA_TO_DEVICE);
+        unmap->to_cnt = 1;
+        unmap->addr[0] = src_dma;
 
-        src_dma = dma_map_single(dma_chan->device->dev, src,
-                                 MV_XOR_TEST_SIZE, DMA_TO_DEVICE);
+        dest_dma = dma_map_page(dma_chan->device->dev, virt_to_page(dest), 0,
+                                  PAGE_SIZE, DMA_FROM_DEVICE);
+        unmap->from_cnt = 1;
+        unmap->addr[1] = dest_dma;
+
+        unmap->len = PAGE_SIZE;
 
         tx = mv_xor_prep_dma_memcpy(dma_chan, dest_dma, src_dma,
-                                    MV_XOR_TEST_SIZE, 0);
+                                    PAGE_SIZE, 0);
         cookie = mv_xor_tx_submit(tx);
         mv_xor_issue_pending(dma_chan);
         async_tx_ack(tx);
@@ -841,8 +847,8 @@ static int mv_xor_memcpy_self_test(struct mv_xor_chan *mv_chan)
         }
 
         dma_sync_single_for_cpu(dma_chan->device->dev, dest_dma,
-                                MV_XOR_TEST_SIZE, DMA_FROM_DEVICE);
-        if (memcmp(src, dest, MV_XOR_TEST_SIZE)) {
+                                PAGE_SIZE, DMA_FROM_DEVICE);
+        if (memcmp(src, dest, PAGE_SIZE)) {
                 dev_err(dma_chan->device->dev,
                         "Self-test copy failed compare, disabling\n");
                 err = -ENODEV;
@@ -850,6 +856,7 @@ static int mv_xor_memcpy_self_test(struct mv_xor_chan *mv_chan)
         }
 
 free_resources:
+        dmaengine_unmap_put(unmap);
         mv_xor_free_chan_resources(dma_chan);
 out:
         kfree(src);
@@ -867,13 +874,15 @@ mv_xor_xor_self_test(struct mv_xor_chan *mv_chan)
         dma_addr_t dma_srcs[MV_XOR_NUM_SRC_TEST];
         dma_addr_t dest_dma;
         struct dma_async_tx_descriptor *tx;
+        struct dmaengine_unmap_data *unmap;
         struct dma_chan *dma_chan;
         dma_cookie_t cookie;
         u8 cmp_byte = 0;
         u32 cmp_word;
         int err = 0;
+        int src_count = MV_XOR_NUM_SRC_TEST;
 
-        for (src_idx = 0; src_idx < MV_XOR_NUM_SRC_TEST; src_idx++) {
+        for (src_idx = 0; src_idx < src_count; src_idx++) {
                 xor_srcs[src_idx] = alloc_page(GFP_KERNEL);
                 if (!xor_srcs[src_idx]) {
                         while (src_idx--)
@@ -890,13 +899,13 @@ mv_xor_xor_self_test(struct mv_xor_chan *mv_chan)
         }
 
         /* Fill in src buffers */
-        for (src_idx = 0; src_idx < MV_XOR_NUM_SRC_TEST; src_idx++) {
+        for (src_idx = 0; src_idx < src_count; src_idx++) {
                 u8 *ptr = page_address(xor_srcs[src_idx]);
                 for (i = 0; i < PAGE_SIZE; i++)
                         ptr[i] = (1 << src_idx);
         }
 
-        for (src_idx = 0; src_idx < MV_XOR_NUM_SRC_TEST; src_idx++)
+        for (src_idx = 0; src_idx < src_count; src_idx++)
                 cmp_byte ^= (u8) (1 << src_idx);
 
         cmp_word = (cmp_byte << 24) | (cmp_byte << 16) |
@@ -910,16 +919,29 @@ mv_xor_xor_self_test(struct mv_xor_chan *mv_chan)
                 goto out;
         }
 
+        unmap = dmaengine_get_unmap_data(dma_chan->device->dev, src_count + 1,
+                                         GFP_KERNEL);
+        if (!unmap) {
+                err = -ENOMEM;
+                goto free_resources;
+        }
+
         /* test xor */
-        dest_dma = dma_map_page(dma_chan->device->dev, dest, 0, PAGE_SIZE,
-                                DMA_FROM_DEVICE);
+        for (i = 0; i < src_count; i++) {
+                unmap->addr[i] = dma_map_page(dma_chan->device->dev, xor_srcs[i],
+                                              0, PAGE_SIZE, DMA_TO_DEVICE);
+                dma_srcs[i] = unmap->addr[i];
+                unmap->to_cnt++;
+        }
 
-        for (i = 0; i < MV_XOR_NUM_SRC_TEST; i++)
-                dma_srcs[i] = dma_map_page(dma_chan->device->dev, xor_srcs[i],
-                                           0, PAGE_SIZE, DMA_TO_DEVICE);
+        unmap->addr[src_count] = dma_map_page(dma_chan->device->dev, dest, 0, PAGE_SIZE,
+                                      DMA_FROM_DEVICE);
+        dest_dma = unmap->addr[src_count];
+        unmap->from_cnt = 1;
+        unmap->len = PAGE_SIZE;
 
         tx = mv_xor_prep_dma_xor(dma_chan, dest_dma, dma_srcs,
-                                 MV_XOR_NUM_SRC_TEST, PAGE_SIZE, 0);
+                                 src_count, PAGE_SIZE, 0);
 
         cookie = mv_xor_tx_submit(tx);
         mv_xor_issue_pending(dma_chan);
@@ -948,9 +970,10 @@ mv_xor_xor_self_test(struct mv_xor_chan *mv_chan)
         }
 
 free_resources:
+        dmaengine_unmap_put(unmap);
         mv_xor_free_chan_resources(dma_chan);
 out:
-        src_idx = MV_XOR_NUM_SRC_TEST;
+        src_idx = src_count;
         while (src_idx--)
                 __free_page(xor_srcs[src_idx]);
         __free_page(dest);
@@ -1176,6 +1199,7 @@ static int mv_xor_probe(struct platform_device *pdev)
                 int i = 0;
 
                 for_each_child_of_node(pdev->dev.of_node, np) {
+                        struct mv_xor_chan *chan;
                         dma_cap_mask_t cap_mask;
                         int irq;
 
@@ -1193,21 +1217,21 @@ static int mv_xor_probe(struct platform_device *pdev)
                                 goto err_channel_add;
                         }
 
-                        xordev->channels[i] =
-                                mv_xor_channel_add(xordev, pdev, i,
-                                                   cap_mask, irq);
-                        if (IS_ERR(xordev->channels[i])) {
-                                ret = PTR_ERR(xordev->channels[i]);
-                                xordev->channels[i] = NULL;
+                        chan = mv_xor_channel_add(xordev, pdev, i,
+                                                  cap_mask, irq);
+                        if (IS_ERR(chan)) {
+                                ret = PTR_ERR(chan);
                                 irq_dispose_mapping(irq);
                                 goto err_channel_add;
                         }
 
+                        xordev->channels[i] = chan;
                         i++;
                 }
         } else if (pdata && pdata->channels) {
                 for (i = 0; i < MV_XOR_MAX_CHANNELS; i++) {
                         struct mv_xor_channel_data *cd;
+                        struct mv_xor_chan *chan;
                         int irq;
 
                         cd = &pdata->channels[i];
@@ -1222,13 +1246,14 @@ static int mv_xor_probe(struct platform_device *pdev)
                                 goto err_channel_add;
                         }
 
-                        xordev->channels[i] =
-                                mv_xor_channel_add(xordev, pdev, i,
-                                                   cd->cap_mask, irq);
-                        if (IS_ERR(xordev->channels[i])) {
-                                ret = PTR_ERR(xordev->channels[i]);
+                        chan = mv_xor_channel_add(xordev, pdev, i,
+                                                  cd->cap_mask, irq);
+                        if (IS_ERR(chan)) {
+                                ret = PTR_ERR(chan);
                                 goto err_channel_add;
                         }
+
+                        xordev->channels[i] = chan;
                 }
         }
 
diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c
index 0b88dd3d05f4..e8fe9dc455f4 100644
--- a/drivers/dma/of-dma.c
+++ b/drivers/dma/of-dma.c
@@ -143,7 +143,7 @@ static int of_dma_match_channel(struct device_node *np, const char *name,
  * @np:         device node to get DMA request from
  * @name:       name of desired channel
  *
- * Returns pointer to appropriate dma channel on success or NULL on error.
+ * Returns pointer to appropriate DMA channel on success or an error pointer.
  */
 struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                                               const char *name)
@@ -152,17 +152,18 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
         struct of_dma           *ofdma;
         struct dma_chan         *chan;
         int                     count, i;
+        int                     ret_no_channel = -ENODEV;
 
         if (!np || !name) {
                 pr_err("%s: not enough information provided\n", __func__);
-                return NULL;
+                return ERR_PTR(-ENODEV);
         }
 
         count = of_property_count_strings(np, "dma-names");
         if (count < 0) {
                 pr_err("%s: dma-names property of node '%s' missing or empty\n",
                         __func__, np->full_name);
-                return NULL;
+                return ERR_PTR(-ENODEV);
         }
 
         for (i = 0; i < count; i++) {
@@ -172,10 +173,12 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                 mutex_lock(&of_dma_lock);
                 ofdma = of_dma_find_controller(&dma_spec);
 
-                if (ofdma)
+                if (ofdma) {
                         chan = ofdma->of_dma_xlate(&dma_spec, ofdma);
-                else
+                } else {
+                        ret_no_channel = -EPROBE_DEFER;
                         chan = NULL;
+                }
 
                 mutex_unlock(&of_dma_lock);
 
@@ -185,7 +188,7 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                         return chan;
         }
 
-        return NULL;
+        return ERR_PTR(ret_no_channel);
 }
 
 /**
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index cdf0483b8f2d..536632f6479c 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -2492,12 +2492,9 @@ static dma_cookie_t pl330_tx_submit(struct dma_async_tx_descriptor *tx)
 
 static inline void _init_desc(struct dma_pl330_desc *desc)
 {
-        desc->pchan = NULL;
         desc->req.x = &desc->px;
         desc->req.token = desc;
         desc->rqcfg.swap = SWAP_NO;
-        desc->rqcfg.privileged = 0;
-        desc->rqcfg.insnaccess = 0;
         desc->rqcfg.scctl = SCCTRL0;
         desc->rqcfg.dcctl = DCCTRL0;
         desc->req.cfg = &desc->rqcfg;
@@ -2517,7 +2514,7 @@ static int add_desc(struct dma_pl330_dmac *pdmac, gfp_t flg, int count)
         if (!pdmac)
                 return 0;
 
-        desc = kmalloc(count * sizeof(*desc), flg);
+        desc = kcalloc(count, sizeof(*desc), flg);
         if (!desc)
                 return 0;
 
diff --git a/drivers/dma/ppc4xx/adma.c b/drivers/dma/ppc4xx/adma.c
index 8da48c6b2a38..8bba298535b0 100644
--- a/drivers/dma/ppc4xx/adma.c
+++ b/drivers/dma/ppc4xx/adma.c
@@ -533,29 +533,6 @@ static void ppc440spe_desc_init_memcpy(struct ppc440spe_adma_desc_slot *desc,
 }
 
 /**
- * ppc440spe_desc_init_memset - initialize the descriptor for MEMSET operation
- */
-static void ppc440spe_desc_init_memset(struct ppc440spe_adma_desc_slot *desc,
-                                        int value, unsigned long flags)
-{
-        struct dma_cdb *hw_desc = desc->hw_desc;
-
-        memset(desc->hw_desc, 0, sizeof(struct dma_cdb));
-        desc->hw_next = NULL;
-        desc->src_cnt = 1;
-        desc->dst_cnt = 1;
-
-        if (flags & DMA_PREP_INTERRUPT)
-                set_bit(PPC440SPE_DESC_INT, &desc->flags);
-        else
-                clear_bit(PPC440SPE_DESC_INT, &desc->flags);
-
-        hw_desc->sg1u = hw_desc->sg1l = cpu_to_le32((u32)value);
-        hw_desc->sg3u = hw_desc->sg3l = cpu_to_le32((u32)value);
-        hw_desc->opc = DMA_CDB_OPC_DFILL128;
-}
-
-/**
  * ppc440spe_desc_set_src_addr - set source address into the descriptor
  */
 static void ppc440spe_desc_set_src_addr(struct ppc440spe_adma_desc_slot *desc,
@@ -1504,8 +1481,6 @@ static dma_cookie_t ppc440spe_adma_run_tx_complete_actions(
                 struct ppc440spe_adma_chan *chan,
                 dma_cookie_t cookie)
 {
-        int i;
-
         BUG_ON(desc->async_tx.cookie < 0);
         if (desc->async_tx.cookie > 0) {
                 cookie = desc->async_tx.cookie;
@@ -3898,7 +3873,7 @@ static void ppc440spe_adma_init_capabilities(struct ppc440spe_adma_device *adev)
                         ppc440spe_adma_prep_dma_interrupt;
         }
         pr_info("%s: AMCC(R) PPC440SP(E) ADMA Engine: "
-          "( %s%s%s%s%s%s%s)\n",
+          "( %s%s%s%s%s%s)\n",
           dev_name(adev->dev),
           dma_has_cap(DMA_PQ, adev->common.cap_mask) ? "pq " : "",
           dma_has_cap(DMA_PQ_VAL, adev->common.cap_mask) ? "pq_val " : "",
diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c
index bae6c29f5502..17686caf64d5 100644
--- a/drivers/dma/txx9dmac.c
+++ b/drivers/dma/txx9dmac.c
@@ -406,7 +406,6 @@ txx9dmac_descriptor_complete(struct txx9dmac_chan *dc,
         dma_async_tx_callback callback;
         void *param;
         struct dma_async_tx_descriptor *txd = &desc->txd;
-        struct txx9dmac_slave *ds = dc->chan.private;
 
         dev_vdbg(chan2dev(&dc->chan), "descriptor %u %p complete\n",
                  txd->cookie, desc);
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index b0bb056458a3..281029daf98c 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1623,7 +1623,6 @@ static struct scsi_host_template scsi_driver_template = {
         .cmd_per_lun            = 1,
         .can_queue              = 1,
         .sdev_attrs             = sbp2_scsi_sysfs_attrs,
-        .no_write_same          = 1,
 };
 
 MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 299fad6b5867..5373dc5b6011 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -14,3 +14,4 @@ obj-$(CONFIG_FIRMWARE_MEMMAP)	+= memmap.o
 
 obj-$(CONFIG_GOOGLE_FIRMWARE)   += google/
 obj-$(CONFIG_EFI)               += efi/
+obj-$(CONFIG_UEFI_CPER)         += efi/
diff --git a/drivers/firmware/efi/Kconfig b/drivers/firmware/efi/Kconfig
index 3150aa4874e8..6aecbc86ec94 100644
--- a/drivers/firmware/efi/Kconfig
+++ b/drivers/firmware/efi/Kconfig
@@ -36,7 +36,7 @@ config EFI_VARS_PSTORE_DEFAULT_DISABLE
           backend for pstore by default. This setting can be overridden
           using the efivars module's pstore_disable parameter.
 
-config UEFI_CPER
-        def_bool n
-
 endmenu
+
+config UEFI_CPER
+        bool
diff --git a/drivers/firmware/efi/Makefile b/drivers/firmware/efi/Makefile
index 9ba156d3c775..6c2a41ec21ba 100644
--- a/drivers/firmware/efi/Makefile
+++ b/drivers/firmware/efi/Makefile
@@ -1,7 +1,7 @@
 #
 # Makefile for linux kernel
 #
-obj-y                                   += efi.o vars.o
+obj-$(CONFIG_EFI)                       += efi.o vars.o
 obj-$(CONFIG_EFI_VARS)                  += efivars.o
 obj-$(CONFIG_EFI_VARS_PSTORE)           += efi-pstore.o
 obj-$(CONFIG_UEFI_CPER)                 += cper.o
diff --git a/drivers/firmware/efi/efi-pstore.c b/drivers/firmware/efi/efi-pstore.c
index 743fd426f21b..4b9dc836dcf9 100644
--- a/drivers/firmware/efi/efi-pstore.c
+++ b/drivers/firmware/efi/efi-pstore.c
@@ -356,6 +356,7 @@ static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count,
 static struct pstore_info efi_pstore_info = {
         .owner          = THIS_MODULE,
         .name           = "efi",
+        .flags          = PSTORE_FLAGS_FRAGILE,
         .open           = efi_pstore_open,
         .close          = efi_pstore_close,
         .read           = efi_pstore_read,
diff --git a/drivers/gpio/gpio-msm-v2.c b/drivers/gpio/gpio-msm-v2.c
index 7b37300973db..2baf0ddf7e02 100644
--- a/drivers/gpio/gpio-msm-v2.c
+++ b/drivers/gpio/gpio-msm-v2.c
@@ -252,7 +252,7 @@ static void msm_gpio_irq_mask(struct irq_data *d)
 
         spin_lock_irqsave(&tlmm_lock, irq_flags);
         writel(TARGET_PROC_NONE, GPIO_INTR_CFG_SU(gpio));
-        clear_gpio_bits(INTR_RAW_STATUS_EN | INTR_ENABLE, GPIO_INTR_CFG(gpio));
+        clear_gpio_bits(BIT(INTR_RAW_STATUS_EN) | BIT(INTR_ENABLE), GPIO_INTR_CFG(gpio));
         __clear_bit(gpio, msm_gpio.enabled_irqs);
         spin_unlock_irqrestore(&tlmm_lock, irq_flags);
 }
@@ -264,7 +264,7 @@ static void msm_gpio_irq_unmask(struct irq_data *d)
 
         spin_lock_irqsave(&tlmm_lock, irq_flags);
         __set_bit(gpio, msm_gpio.enabled_irqs);
-        set_gpio_bits(INTR_RAW_STATUS_EN | INTR_ENABLE, GPIO_INTR_CFG(gpio));
+        set_gpio_bits(BIT(INTR_RAW_STATUS_EN) | BIT(INTR_ENABLE), GPIO_INTR_CFG(gpio));
         writel(TARGET_PROC_SCORPION, GPIO_INTR_CFG_SU(gpio));
         spin_unlock_irqrestore(&tlmm_lock, irq_flags);
 }
diff --git a/drivers/gpio/gpio-rcar.c b/drivers/gpio/gpio-rcar.c
index fe088a30567a..8b7e719a68c3 100644
--- a/drivers/gpio/gpio-rcar.c
+++ b/drivers/gpio/gpio-rcar.c
@@ -169,7 +169,8 @@ static irqreturn_t gpio_rcar_irq_handler(int irq, void *dev_id)
         u32 pending;
         unsigned int offset, irqs_handled = 0;
 
-        while ((pending = gpio_rcar_read(p, INTDT))) {
+        while ((pending = gpio_rcar_read(p, INTDT) &
+                          gpio_rcar_read(p, INTMSK))) {
                 offset = __ffs(pending);
                 gpio_rcar_write(p, INTCLR, BIT(offset));
                 generic_handle_irq(irq_find_mapping(p->irq_domain, offset));
diff --git a/drivers/gpio/gpio-twl4030.c b/drivers/gpio/gpio-twl4030.c
index b97d6a6577b9..f9996899c1f2 100644
--- a/drivers/gpio/gpio-twl4030.c
+++ b/drivers/gpio/gpio-twl4030.c
@@ -300,7 +300,7 @@ static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
         if (offset < TWL4030_GPIO_MAX)
                 ret = twl4030_set_gpio_direction(offset, 1);
         else
-                ret = -EINVAL;
+                ret = -EINVAL;  /* LED outputs can't be set as input */
 
         if (!ret)
                 priv->direction &= ~BIT(offset);
@@ -354,11 +354,20 @@ static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
 static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
 {
         struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip);
-        int ret = -EINVAL;
+        int ret = 0;
 
         mutex_lock(&priv->mutex);
-        if (offset < TWL4030_GPIO_MAX)
+        if (offset < TWL4030_GPIO_MAX) {
                 ret = twl4030_set_gpio_direction(offset, 0);
+                if (ret) {
+                        mutex_unlock(&priv->mutex);
+                        return ret;
+                }
+        }
+
+        /*
+         *  LED gpios i.e. offset >= TWL4030_GPIO_MAX are always output
+         */
 
         priv->direction |= BIT(offset);
         mutex_unlock(&priv->mutex);
diff --git a/drivers/gpu/drm/armada/armada_drm.h b/drivers/gpu/drm/armada/armada_drm.h
index eef09ec9a5ff..a72cae03b99b 100644
--- a/drivers/gpu/drm/armada/armada_drm.h
+++ b/drivers/gpu/drm/armada/armada_drm.h
@@ -103,6 +103,7 @@ void armada_drm_queue_unref_work(struct drm_device *,
 extern const struct drm_mode_config_funcs armada_drm_mode_config_funcs;
 
 int armada_fbdev_init(struct drm_device *);
+void armada_fbdev_lastclose(struct drm_device *);
 void armada_fbdev_fini(struct drm_device *);
 
 int armada_overlay_plane_create(struct drm_device *, unsigned long);
diff --git a/drivers/gpu/drm/armada/armada_drv.c b/drivers/gpu/drm/armada/armada_drv.c
index 4f2b28354915..62d0ff3efddf 100644
--- a/drivers/gpu/drm/armada/armada_drv.c
+++ b/drivers/gpu/drm/armada/armada_drv.c
@@ -321,6 +321,11 @@ static struct drm_ioctl_desc armada_ioctls[] = {
                 DRM_UNLOCKED),
 };
 
+static void armada_drm_lastclose(struct drm_device *dev)
+{
+        armada_fbdev_lastclose(dev);
+}
+
 static const struct file_operations armada_drm_fops = {
         .owner                  = THIS_MODULE,
         .llseek                 = no_llseek,
@@ -337,7 +342,7 @@ static struct drm_driver armada_drm_driver = {
         .open                   = NULL,
         .preclose               = NULL,
         .postclose              = NULL,
-        .lastclose              = NULL,
+        .lastclose              = armada_drm_lastclose,
         .unload                 = armada_drm_unload,
         .get_vblank_counter     = drm_vblank_count,
         .enable_vblank          = armada_drm_enable_vblank,
diff --git a/drivers/gpu/drm/armada/armada_fbdev.c b/drivers/gpu/drm/armada/armada_fbdev.c
index dd5ea77dac96..948cb14c561e 100644
--- a/drivers/gpu/drm/armada/armada_fbdev.c
+++ b/drivers/gpu/drm/armada/armada_fbdev.c
@@ -105,9 +105,9 @@ static int armada_fb_create(struct drm_fb_helper *fbh,
         drm_fb_helper_fill_fix(info, dfb->fb.pitches[0], dfb->fb.depth);
         drm_fb_helper_fill_var(info, fbh, sizes->fb_width, sizes->fb_height);
 
-        DRM_DEBUG_KMS("allocated %dx%d %dbpp fb: 0x%08x\n",
-                dfb->fb.width, dfb->fb.height,
-                dfb->fb.bits_per_pixel, obj->phys_addr);
+        DRM_DEBUG_KMS("allocated %dx%d %dbpp fb: 0x%08llx\n",
+                dfb->fb.width, dfb->fb.height, dfb->fb.bits_per_pixel,
+                (unsigned long long)obj->phys_addr);
 
         return 0;
 
@@ -177,6 +177,16 @@ int armada_fbdev_init(struct drm_device *dev)
         return ret;
 }
 
+void armada_fbdev_lastclose(struct drm_device *dev)
+{
+        struct armada_private *priv = dev->dev_private;
+
+        drm_modeset_lock_all(dev);
+        if (priv->fbdev)
+                drm_fb_helper_restore_fbdev_mode(priv->fbdev);
+        drm_modeset_unlock_all(dev);
+}
+
 void armada_fbdev_fini(struct drm_device *dev)
 {
         struct armada_private *priv = dev->dev_private;
@@ -192,11 +202,11 @@ void armada_fbdev_fini(struct drm_device *dev)
                         framebuffer_release(info);
                 }
 
+                drm_fb_helper_fini(fbh);
+
                 if (fbh->fb)
                         fbh->fb->funcs->destroy(fbh->fb);
 
-                drm_fb_helper_fini(fbh);
-
                 priv->fbdev = NULL;
         }
 }
diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c
index 9f2356bae7fd..887816f43476 100644
--- a/drivers/gpu/drm/armada/armada_gem.c
+++ b/drivers/gpu/drm/armada/armada_gem.c
@@ -172,8 +172,9 @@ armada_gem_linear_back(struct drm_device *dev, struct armada_gem_object *obj)
                 obj->dev_addr = obj->linear->start;
         }
 
-        DRM_DEBUG_DRIVER("obj %p phys %#x dev %#x\n",
-                         obj, obj->phys_addr, obj->dev_addr);
+        DRM_DEBUG_DRIVER("obj %p phys %#llx dev %#llx\n", obj,
+                         (unsigned long long)obj->phys_addr,
+                         (unsigned long long)obj->dev_addr);
 
         return 0;
 }
@@ -557,7 +558,6 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf)
                          * refcount on the gem object itself.
                          */
                         drm_gem_object_reference(obj);
-                        dma_buf_put(buf);
                         return obj;
                 }
         }
@@ -573,6 +573,7 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf)
         }
 
         dobj->obj.import_attach = attach;
+        get_dma_buf(buf);
 
         /*
          * Don't call dma_buf_map_attachment() here - it maps the
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 0a1e4a5f4234..8835dcddfac3 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -68,6 +68,8 @@
 #define EDID_QUIRK_DETAILED_SYNC_PP             (1 << 6)
 /* Force reduced-blanking timings for detailed modes */
 #define EDID_QUIRK_FORCE_REDUCED_BLANKING       (1 << 7)
+/* Force 8bpc */
+#define EDID_QUIRK_FORCE_8BPC                   (1 << 8)
 
 struct detailed_mode_closure {
         struct drm_connector *connector;
@@ -128,6 +130,9 @@ static struct edid_quirk {
 
         /* Medion MD 30217 PG */
         { "MED", 0x7b8, EDID_QUIRK_PREFER_LARGE_75 },
+
+        /* Panel in Samsung NP700G7A-S01PL notebook reports 6bpc */
+        { "SEC", 0xd033, EDID_QUIRK_FORCE_8BPC },
 };
 
 /*
@@ -3435,6 +3440,9 @@ int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
 
         drm_add_display_info(edid, &connector->display_info);
 
+        if (quirks & EDID_QUIRK_FORCE_8BPC)
+                connector->display_info.bpc = 8;
+
         return num_modes;
 }
 EXPORT_SYMBOL(drm_add_edid_modes);
diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index f53d5246979c..66dd3a001cf1 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -566,11 +566,11 @@ err_unload:
         if (dev->driver->unload)
                 dev->driver->unload(dev);
 err_primary_node:
-        drm_put_minor(dev->primary);
+        drm_unplug_minor(dev->primary);
 err_render_node:
-        drm_put_minor(dev->render);
+        drm_unplug_minor(dev->render);
 err_control_node:
-        drm_put_minor(dev->control);
+        drm_unplug_minor(dev->control);
 err_agp:
         if (dev->driver->bus->agp_destroy)
                 dev->driver->bus->agp_destroy(dev);
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 0cab2d045135..5c648425c1e0 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -83,6 +83,14 @@ void i915_update_dri1_breadcrumb(struct drm_device *dev)
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_master_private *master_priv;
 
+        /*
+         * The dri breadcrumb update races against the drm master disappearing.
+         * Instead of trying to fix this (this is by far not the only ums issue)
+         * just don't do the update in kms mode.
+         */
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                return;
+
         if (dev->primary->master) {
                 master_priv = dev->primary->master->driver_priv;
                 if (master_priv->sarea_priv)
@@ -1490,16 +1498,9 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         spin_lock_init(&dev_priv->uncore.lock);
         spin_lock_init(&dev_priv->mm.object_stat_lock);
         mutex_init(&dev_priv->dpio_lock);
-        mutex_init(&dev_priv->rps.hw_lock);
         mutex_init(&dev_priv->modeset_restore_lock);
 
-        mutex_init(&dev_priv->pc8.lock);
-        dev_priv->pc8.requirements_met = false;
-        dev_priv->pc8.gpu_idle = false;
-        dev_priv->pc8.irqs_disabled = false;
-        dev_priv->pc8.enabled = false;
-        dev_priv->pc8.disable_count = 2; /* requirements_met + gpu_idle */
-        INIT_DELAYED_WORK(&dev_priv->pc8.enable_work, hsw_enable_pc8_work);
+        intel_pm_setup(dev);
 
         intel_display_crc_init(dev);
 
@@ -1603,7 +1604,6 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         }
 
         intel_irq_init(dev);
-        intel_pm_init(dev);
         intel_uncore_sanitize(dev);
 
         /* Try to make sure MCHBAR is enabled before poking at it */
@@ -1848,8 +1848,10 @@ void i915_driver_lastclose(struct drm_device * dev)
 
 void i915_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
 {
+        mutex_lock(&dev->struct_mutex);
         i915_gem_context_close(dev, file_priv);
         i915_gem_release(dev, file_priv);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 void i915_driver_postclose(struct drm_device *dev, struct drm_file *file)
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 2e367a1c6a64..5b7b7e06cb3a 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -651,6 +651,7 @@ static int __i915_drm_thaw(struct drm_device *dev, bool restore_gtt_mappings)
                 intel_modeset_init_hw(dev);
 
                 drm_modeset_lock_all(dev);
+                drm_mode_config_reset(dev);
                 intel_modeset_setup_hw_state(dev, true);
                 drm_modeset_unlock_all(dev);
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index ccdbecca070d..90fcccba17b0 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -1755,8 +1755,13 @@ struct drm_i915_file_private {
 #define IS_MOBILE(dev)          (INTEL_INFO(dev)->is_mobile)
 #define IS_HSW_EARLY_SDV(dev)   (IS_HASWELL(dev) && \
                                  ((dev)->pdev->device & 0xFF00) == 0x0C00)
-#define IS_ULT(dev)             (IS_HASWELL(dev) && \
+#define IS_BDW_ULT(dev)         (IS_BROADWELL(dev) && \
+                                 (((dev)->pdev->device & 0xf) == 0x2  || \
+                                 ((dev)->pdev->device & 0xf) == 0x6 || \
+                                 ((dev)->pdev->device & 0xf) == 0xe))
+#define IS_HSW_ULT(dev)         (IS_HASWELL(dev) && \
                                  ((dev)->pdev->device & 0xFF00) == 0x0A00)
+#define IS_ULT(dev)             (IS_HSW_ULT(dev) || IS_BDW_ULT(dev))
 #define IS_HSW_GT3(dev)         (IS_HASWELL(dev) && \
                                  ((dev)->pdev->device & 0x00F0) == 0x0020)
 #define IS_PRELIMINARY_HW(intel_info) ((intel_info)->is_preliminary)
@@ -1901,9 +1906,7 @@ void i915_queue_hangcheck(struct drm_device *dev);
 void i915_handle_error(struct drm_device *dev, bool wedged);
 
 extern void intel_irq_init(struct drm_device *dev);
-extern void intel_pm_init(struct drm_device *dev);
 extern void intel_hpd_init(struct drm_device *dev);
-extern void intel_pm_init(struct drm_device *dev);
 
 extern void intel_uncore_sanitize(struct drm_device *dev);
 extern void intel_uncore_early_sanitize(struct drm_device *dev);
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 621c7c67a643..76d3d1ab73c6 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -2343,15 +2343,24 @@ static void i915_gem_free_request(struct drm_i915_gem_request *request)
         kfree(request);
 }
 
-static void i915_gem_reset_ring_lists(struct drm_i915_private *dev_priv,
-                                      struct intel_ring_buffer *ring)
+static void i915_gem_reset_ring_status(struct drm_i915_private *dev_priv,
+                                       struct intel_ring_buffer *ring)
 {
-        u32 completed_seqno;
-        u32 acthd;
+        u32 completed_seqno = ring->get_seqno(ring, false);
+        u32 acthd = intel_ring_get_active_head(ring);
+        struct drm_i915_gem_request *request;
+
+        list_for_each_entry(request, &ring->request_list, list) {
+                if (i915_seqno_passed(completed_seqno, request->seqno))
+                        continue;
 
-        acthd = intel_ring_get_active_head(ring);
-        completed_seqno = ring->get_seqno(ring, false);
+                i915_set_reset_status(ring, request, acthd);
+        }
+}
 
+static void i915_gem_reset_ring_cleanup(struct drm_i915_private *dev_priv,
+                                        struct intel_ring_buffer *ring)
+{
         while (!list_empty(&ring->request_list)) {
                 struct drm_i915_gem_request *request;
 
@@ -2359,9 +2368,6 @@ static void i915_gem_reset_ring_lists(struct drm_i915_private *dev_priv,
                                            struct drm_i915_gem_request,
                                            list);
 
-                if (request->seqno > completed_seqno)
-                        i915_set_reset_status(ring, request, acthd);
-
                 i915_gem_free_request(request);
         }
 
@@ -2403,8 +2409,16 @@ void i915_gem_reset(struct drm_device *dev)
         struct intel_ring_buffer *ring;
         int i;
 
+        /*
+         * Before we free the objects from the requests, we need to inspect
+         * them for finding the guilty party. As the requests only borrow
+         * their reference to the objects, the inspection must be done first.
+         */
+        for_each_ring(ring, dev_priv, i)
+                i915_gem_reset_ring_status(dev_priv, ring);
+
         for_each_ring(ring, dev_priv, i)
-                i915_gem_reset_ring_lists(dev_priv, ring);
+                i915_gem_reset_ring_cleanup(dev_priv, ring);
 
         i915_gem_cleanup_ringbuffer(dev);
 
diff --git a/drivers/gpu/drm/i915/i915_gem_context.c b/drivers/gpu/drm/i915/i915_gem_context.c
index 72a3df32292f..b0f42b9ca037 100644
--- a/drivers/gpu/drm/i915/i915_gem_context.c
+++ b/drivers/gpu/drm/i915/i915_gem_context.c
@@ -347,10 +347,8 @@ void i915_gem_context_close(struct drm_device *dev, struct drm_file *file)
 {
         struct drm_i915_file_private *file_priv = file->driver_priv;
 
-        mutex_lock(&dev->struct_mutex);
         idr_for_each(&file_priv->context_idr, context_idr_cleanup, NULL);
         idr_destroy(&file_priv->context_idr);
-        mutex_unlock(&dev->struct_mutex);
 }
 
 static struct i915_hw_context *
@@ -423,11 +421,21 @@ static int do_switch(struct i915_hw_context *to)
         if (ret)
                 return ret;
 
-        /* Clear this page out of any CPU caches for coherent swap-in/out. Note
+        /*
+         * Pin can switch back to the default context if we end up calling into
+         * evict_everything - as a last ditch gtt defrag effort that also
+         * switches to the default context. Hence we need to reload from here.
+         */
+        from = ring->last_context;
+
+        /*
+         * Clear this page out of any CPU caches for coherent swap-in/out. Note
          * that thanks to write = false in this call and us not setting any gpu
          * write domains when putting a context object onto the active list
          * (when switching away from it), this won't block.
-         * XXX: We need a real interface to do this instead of trickery. */
+         *
+         * XXX: We need a real interface to do this instead of trickery.
+         */
         ret = i915_gem_object_set_to_gtt_domain(to->obj, false);
         if (ret) {
                 i915_gem_object_unpin(to->obj);
diff --git a/drivers/gpu/drm/i915/i915_gem_evict.c b/drivers/gpu/drm/i915/i915_gem_evict.c
index b7376533633d..8f3adc7d0dc8 100644
--- a/drivers/gpu/drm/i915/i915_gem_evict.c
+++ b/drivers/gpu/drm/i915/i915_gem_evict.c
@@ -88,6 +88,7 @@ i915_gem_evict_something(struct drm_device *dev, struct i915_address_space *vm,
         } else
                 drm_mm_init_scan(&vm->mm, min_size, alignment, cache_level);
 
+search_again:
         /* First see if there is a large enough contiguous idle region... */
         list_for_each_entry(vma, &vm->inactive_list, mm_list) {
                 if (mark_free(vma, &unwind_list))
@@ -115,10 +116,17 @@ none:
                 list_del_init(&vma->exec_list);
         }
 
-        /* We expect the caller to unpin, evict all and try again, or give up.
-         * So calling i915_gem_evict_vm() is unnecessary.
+        /* Can we unpin some objects such as idle hw contents,
+         * or pending flips?
          */
-        return -ENOSPC;
+        ret = nonblocking ? -ENOSPC : i915_gpu_idle(dev);
+        if (ret)
+                return ret;
+
+        /* Only idle the GPU and repeat the search once */
+        i915_gem_retire_requests(dev);
+        nonblocking = true;
+        goto search_again;
 
 found:
         /* drm_mm doesn't allow any other other operations while
diff --git a/drivers/gpu/drm/i915/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
index b7e787fb4649..a3ba9a8cd687 100644
--- a/drivers/gpu/drm/i915/i915_gem_execbuffer.c
+++ b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
@@ -93,7 +93,7 @@ eb_lookup_vmas(struct eb_vmas *eb,
 {
         struct drm_i915_gem_object *obj;
         struct list_head objects;
-        int i, ret = 0;
+        int i, ret;
 
         INIT_LIST_HEAD(&objects);
         spin_lock(&file->table_lock);
@@ -106,7 +106,7 @@ eb_lookup_vmas(struct eb_vmas *eb,
                         DRM_DEBUG("Invalid object handle %d at index %d\n",
                                    exec[i].handle, i);
                         ret = -ENOENT;
-                        goto out;
+                        goto err;
                 }
 
                 if (!list_empty(&obj->obj_exec_link)) {
@@ -114,7 +114,7 @@ eb_lookup_vmas(struct eb_vmas *eb,
                         DRM_DEBUG("Object %p [handle %d, index %d] appears more than once in object list\n",
                                    obj, exec[i].handle, i);
                         ret = -EINVAL;
-                        goto out;
+                        goto err;
                 }
 
                 drm_gem_object_reference(&obj->base);
@@ -123,9 +123,13 @@ eb_lookup_vmas(struct eb_vmas *eb,
         spin_unlock(&file->table_lock);
 
         i = 0;
-        list_for_each_entry(obj, &objects, obj_exec_link) {
+        while (!list_empty(&objects)) {
                 struct i915_vma *vma;
 
+                obj = list_first_entry(&objects,
+                                       struct drm_i915_gem_object,
+                                       obj_exec_link);
+
                 /*
                  * NOTE: We can leak any vmas created here when something fails
                  * later on. But that's no issue since vma_unbind can deal with
@@ -138,10 +142,12 @@ eb_lookup_vmas(struct eb_vmas *eb,
                 if (IS_ERR(vma)) {
                         DRM_DEBUG("Failed to lookup VMA\n");
                         ret = PTR_ERR(vma);
-                        goto out;
+                        goto err;
                 }
 
+                /* Transfer ownership from the objects list to the vmas list. */
                 list_add_tail(&vma->exec_list, &eb->vmas);
+                list_del_init(&obj->obj_exec_link);
 
                 vma->exec_entry = &exec[i];
                 if (eb->and < 0) {
@@ -155,16 +161,22 @@ eb_lookup_vmas(struct eb_vmas *eb,
                 ++i;
         }
 
+        return 0;
+
 
-out:
+err:
         while (!list_empty(&objects)) {
                 obj = list_first_entry(&objects,
                                        struct drm_i915_gem_object,
                                        obj_exec_link);
                 list_del_init(&obj->obj_exec_link);
-                if (ret)
-                        drm_gem_object_unreference(&obj->base);
+                drm_gem_object_unreference(&obj->base);
         }
+        /*
+         * Objects already transfered to the vmas list will be unreferenced by
+         * eb_destroy.
+         */
+
         return ret;
 }
 
diff --git a/drivers/gpu/drm/i915/i915_gem_gtt.c b/drivers/gpu/drm/i915/i915_gem_gtt.c
index 38cb8d44a013..c79dd2b1f70e 100644
--- a/drivers/gpu/drm/i915/i915_gem_gtt.c
+++ b/drivers/gpu/drm/i915/i915_gem_gtt.c
@@ -337,8 +337,8 @@ static void gen8_ppgtt_cleanup(struct i915_address_space *vm)
                 kfree(ppgtt->gen8_pt_dma_addr[i]);
         }
 
-        __free_pages(ppgtt->gen8_pt_pages, ppgtt->num_pt_pages << PAGE_SHIFT);
-        __free_pages(ppgtt->pd_pages, ppgtt->num_pd_pages << PAGE_SHIFT);
+        __free_pages(ppgtt->gen8_pt_pages, get_order(ppgtt->num_pt_pages << PAGE_SHIFT));
+        __free_pages(ppgtt->pd_pages, get_order(ppgtt->num_pd_pages << PAGE_SHIFT));
 }
 
 /**
@@ -1241,6 +1241,11 @@ static inline unsigned int gen8_get_total_gtt_size(u16 bdw_gmch_ctl)
         bdw_gmch_ctl &= BDW_GMCH_GGMS_MASK;
         if (bdw_gmch_ctl)
                 bdw_gmch_ctl = 1 << bdw_gmch_ctl;
+        if (bdw_gmch_ctl > 4) {
+                WARN_ON(!i915_preliminary_hw_support);
+                return 4<<20;
+        }
+
         return bdw_gmch_ctl << 20;
 }
 
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 080f6fd4e839..54e82a80cf50 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -6303,7 +6303,7 @@ static void assert_can_disable_lcpll(struct drm_i915_private *dev_priv)
         uint32_t val;
 
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, base.head)
-                WARN(crtc->base.enabled, "CRTC for pipe %c enabled\n",
+                WARN(crtc->active, "CRTC for pipe %c enabled\n",
                      pipe_name(crtc->pipe));
 
         WARN(I915_READ(HSW_PWR_WELL_DRIVER), "Power well on\n");
@@ -9135,7 +9135,7 @@ intel_pipe_config_compare(struct drm_device *dev,
         if (IS_G4X(dev) || INTEL_INFO(dev)->gen >= 5)
                 PIPE_CONF_CHECK_I(pipe_bpp);
 
-        if (!IS_HASWELL(dev)) {
+        if (!HAS_DDI(dev)) {
                 PIPE_CONF_CHECK_CLOCK_FUZZY(adjusted_mode.crtc_clock);
                 PIPE_CONF_CHECK_CLOCK_FUZZY(port_clock);
         }
@@ -11036,8 +11036,6 @@ void intel_modeset_setup_hw_state(struct drm_device *dev,
         }
 
         intel_modeset_check_state(dev);
-
-        drm_mode_config_reset(dev);
 }
 
 void intel_modeset_gem_init(struct drm_device *dev)
@@ -11046,7 +11044,10 @@ void intel_modeset_gem_init(struct drm_device *dev)
 
         intel_setup_overlay(dev);
 
+        drm_modeset_lock_all(dev);
+        drm_mode_config_reset(dev);
         intel_modeset_setup_hw_state(dev, false);
+        drm_modeset_unlock_all(dev);
 }
 
 void intel_modeset_cleanup(struct drm_device *dev)
@@ -11125,14 +11126,15 @@ void intel_connector_attach_encoder(struct intel_connector *connector,
 int intel_modeset_vga_set_state(struct drm_device *dev, bool state)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
+        unsigned reg = INTEL_INFO(dev)->gen >= 6 ? SNB_GMCH_CTRL : INTEL_GMCH_CTRL;
         u16 gmch_ctrl;
 
-        pci_read_config_word(dev_priv->bridge_dev, INTEL_GMCH_CTRL, &gmch_ctrl);
+        pci_read_config_word(dev_priv->bridge_dev, reg, &gmch_ctrl);
         if (state)
                 gmch_ctrl &= ~INTEL_GMCH_VGA_DISABLE;
         else
                 gmch_ctrl |= INTEL_GMCH_VGA_DISABLE;
-        pci_write_config_word(dev_priv->bridge_dev, INTEL_GMCH_CTRL, gmch_ctrl);
+        pci_write_config_word(dev_priv->bridge_dev, reg, gmch_ctrl);
         return 0;
 }
 
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index a18e88b3e425..79f91f26e288 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -821,6 +821,7 @@ void intel_update_sprite_watermarks(struct drm_plane *plane,
                                     uint32_t sprite_width, int pixel_size,
                                     bool enabled, bool scaled);
 void intel_init_pm(struct drm_device *dev);
+void intel_pm_setup(struct drm_device *dev);
 bool intel_fbc_enabled(struct drm_device *dev);
 void intel_update_fbc(struct drm_device *dev);
 void intel_gpu_ips_init(struct drm_i915_private *dev_priv);
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index f161ac02c4f6..e6f782d1c669 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -451,7 +451,9 @@ static u32 intel_panel_get_backlight(struct drm_device *dev,
 
         spin_lock_irqsave(&dev_priv->backlight.lock, flags);
 
-        if (HAS_PCH_SPLIT(dev)) {
+        if (IS_BROADWELL(dev)) {
+                val = I915_READ(BLC_PWM_PCH_CTL2) & BACKLIGHT_DUTY_CYCLE_MASK;
+        } else if (HAS_PCH_SPLIT(dev)) {
                 val = I915_READ(BLC_PWM_CPU_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
         } else {
                 if (IS_VALLEYVIEW(dev))
@@ -479,6 +481,13 @@ static u32 intel_panel_get_backlight(struct drm_device *dev,
         return val;
 }
 
+static void intel_bdw_panel_set_backlight(struct drm_device *dev, u32 level)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 val = I915_READ(BLC_PWM_PCH_CTL2) & ~BACKLIGHT_DUTY_CYCLE_MASK;
+        I915_WRITE(BLC_PWM_PCH_CTL2, val | level);
+}
+
 static void intel_pch_panel_set_backlight(struct drm_device *dev, u32 level)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -496,7 +505,9 @@ static void intel_panel_actually_set_backlight(struct drm_device *dev,
         DRM_DEBUG_DRIVER("set backlight PWM = %d\n", level);
         level = intel_panel_compute_brightness(dev, pipe, level);
 
-        if (HAS_PCH_SPLIT(dev))
+        if (IS_BROADWELL(dev))
+                return intel_bdw_panel_set_backlight(dev, level);
+        else if (HAS_PCH_SPLIT(dev))
                 return intel_pch_panel_set_backlight(dev, level);
 
         if (is_backlight_combination_mode(dev)) {
@@ -666,7 +677,16 @@ void intel_panel_enable_backlight(struct intel_connector *connector)
                 POSTING_READ(reg);
                 I915_WRITE(reg, tmp | BLM_PWM_ENABLE);
 
-                if (HAS_PCH_SPLIT(dev) &&
+                if (IS_BROADWELL(dev)) {
+                        /*
+                         * Broadwell requires PCH override to drive the PCH
+                         * backlight pin. The above will configure the CPU
+                         * backlight pin, which we don't plan to use.
+                         */
+                        tmp = I915_READ(BLC_PWM_PCH_CTL1);
+                        tmp |= BLM_PCH_OVERRIDE_ENABLE | BLM_PCH_PWM_ENABLE;
+                        I915_WRITE(BLC_PWM_PCH_CTL1, tmp);
+                } else if (HAS_PCH_SPLIT(dev) &&
                     !(dev_priv->quirks & QUIRK_NO_PCH_PWM_ENABLE)) {
                         tmp = I915_READ(BLC_PWM_PCH_CTL1);
                         tmp |= BLM_PCH_PWM_ENABLE;
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index 6e0d5e075b15..26c29c173221 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -5685,8 +5685,11 @@ static void __intel_set_power_well(struct drm_device *dev, bool enable)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         bool is_enabled, enable_requested;
+        unsigned long irqflags;
         uint32_t tmp;
 
+        WARN_ON(dev_priv->pc8.enabled);
+
         tmp = I915_READ(HSW_PWR_WELL_DRIVER);
         is_enabled = tmp & HSW_PWR_WELL_STATE_ENABLED;
         enable_requested = tmp & HSW_PWR_WELL_ENABLE_REQUEST;
@@ -5702,9 +5705,24 @@ static void __intel_set_power_well(struct drm_device *dev, bool enable)
                                       HSW_PWR_WELL_STATE_ENABLED), 20))
                                 DRM_ERROR("Timeout enabling power well\n");
                 }
+
+                if (IS_BROADWELL(dev)) {
+                        spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
+                        I915_WRITE(GEN8_DE_PIPE_IMR(PIPE_B),
+                                   dev_priv->de_irq_mask[PIPE_B]);
+                        I915_WRITE(GEN8_DE_PIPE_IER(PIPE_B),
+                                   ~dev_priv->de_irq_mask[PIPE_B] |
+                                   GEN8_PIPE_VBLANK);
+                        I915_WRITE(GEN8_DE_PIPE_IMR(PIPE_C),
+                                   dev_priv->de_irq_mask[PIPE_C]);
+                        I915_WRITE(GEN8_DE_PIPE_IER(PIPE_C),
+                                   ~dev_priv->de_irq_mask[PIPE_C] |
+                                   GEN8_PIPE_VBLANK);
+                        POSTING_READ(GEN8_DE_PIPE_IER(PIPE_C));
+                        spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
+                }
         } else {
                 if (enable_requested) {
-                        unsigned long irqflags;
                         enum pipe p;
 
                         I915_WRITE(HSW_PWR_WELL_DRIVER, 0);
@@ -5731,16 +5749,24 @@ static void __intel_set_power_well(struct drm_device *dev, bool enable)
 static void __intel_power_well_get(struct drm_device *dev,
                                    struct i915_power_well *power_well)
 {
-        if (!power_well->count++)
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        if (!power_well->count++) {
+                hsw_disable_package_c8(dev_priv);
                 __intel_set_power_well(dev, true);
+        }
 }
 
 static void __intel_power_well_put(struct drm_device *dev,
                                    struct i915_power_well *power_well)
 {
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
         WARN_ON(!power_well->count);
-        if (!--power_well->count && i915_disable_power_well)
+        if (!--power_well->count && i915_disable_power_well) {
                 __intel_set_power_well(dev, false);
+                hsw_enable_package_c8(dev_priv);
+        }
 }
 
 void intel_display_power_get(struct drm_device *dev,
@@ -6130,10 +6156,19 @@ int vlv_freq_opcode(int ddr_freq, int val)
         return val;
 }
 
-void intel_pm_init(struct drm_device *dev)
+void intel_pm_setup(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
 
+        mutex_init(&dev_priv->rps.hw_lock);
+
+        mutex_init(&dev_priv->pc8.lock);
+        dev_priv->pc8.requirements_met = false;
+        dev_priv->pc8.gpu_idle = false;
+        dev_priv->pc8.irqs_disabled = false;
+        dev_priv->pc8.enabled = false;
+        dev_priv->pc8.disable_count = 2; /* requirements_met + gpu_idle */
+        INIT_DELAYED_WORK(&dev_priv->pc8.enable_work, hsw_enable_pc8_work);
         INIT_DELAYED_WORK(&dev_priv->rps.delayed_resume_work,
                           intel_gen6_powersave_work);
 }
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index b620337e6d67..c2f09d456300 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -965,6 +965,7 @@ void intel_ring_setup_status_page(struct intel_ring_buffer *ring)
         } else if (IS_GEN6(ring->dev)) {
                 mmio = RING_HWS_PGA_GEN6(ring->mmio_base);
         } else {
+                /* XXX: gen8 returns to sanity */
                 mmio = RING_HWS_PGA(ring->mmio_base);
         }
 
diff --git a/drivers/gpu/drm/i915/intel_uncore.c b/drivers/gpu/drm/i915/intel_uncore.c
index 0b02078a0b84..25cbe073c388 100644
--- a/drivers/gpu/drm/i915/intel_uncore.c
+++ b/drivers/gpu/drm/i915/intel_uncore.c
@@ -784,6 +784,7 @@ static int gen6_do_reset(struct drm_device *dev)
 int intel_gpu_reset(struct drm_device *dev)
 {
         switch (INTEL_INFO(dev)->gen) {
+        case 8:
         case 7:
         case 6: return gen6_do_reset(dev);
         case 5: return ironlake_do_reset(dev);
diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c
index 7a3759f1c41a..98a22e6e27a1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.c
@@ -858,6 +858,12 @@ static int nouveau_pmops_runtime_suspend(struct device *dev)
         if (nouveau_runtime_pm == 0)
                 return -EINVAL;
 
+        /* are we optimus enabled? */
+        if (nouveau_runtime_pm == -1 && !nouveau_is_optimus() && !nouveau_is_v1_dsm()) {
+                DRM_DEBUG_DRIVER("failing to power off - not optimus\n");
+                return -EINVAL;
+        }
+
         nv_debug_level(SILENT);
         drm_kms_helper_poll_disable(drm_dev);
         vga_switcheroo_set_dynamic_switch(pdev, VGA_SWITCHEROO_OFF);
diff --git a/drivers/gpu/drm/qxl/Kconfig b/drivers/gpu/drm/qxl/Kconfig
index 037d324bf58f..66ac0ff95f5a 100644
--- a/drivers/gpu/drm/qxl/Kconfig
+++ b/drivers/gpu/drm/qxl/Kconfig
@@ -8,5 +8,6 @@ config DRM_QXL
         select DRM_KMS_HELPER
         select DRM_KMS_FB_HELPER
         select DRM_TTM
+        select CRC32
         help
                 QXL virtual GPU for Spice virtualization desktop integration. Do not enable this driver unless your distro ships a corresponding X.org QXL driver that can handle kernel modesetting.
diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c
index 5e827c29d194..d70aafb83307 100644
--- a/drivers/gpu/drm/qxl/qxl_display.c
+++ b/drivers/gpu/drm/qxl/qxl_display.c
@@ -24,7 +24,7 @@
  */
 
 
-#include "linux/crc32.h"
+#include <linux/crc32.h>
 
 #include "qxl_drv.h"
 #include "qxl_object.h"
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 80a20120e625..b1970596a782 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -1196,7 +1196,9 @@ static int dce4_crtc_do_set_base(struct drm_crtc *crtc,
         } else if ((rdev->family == CHIP_TAHITI) ||
                    (rdev->family == CHIP_PITCAIRN))
                 fb_format |= SI_GRPH_PIPE_CONFIG(SI_ADDR_SURF_P8_32x32_8x16);
-        else if (rdev->family == CHIP_VERDE)
+        else if ((rdev->family == CHIP_VERDE) ||
+                 (rdev->family == CHIP_OLAND) ||
+                 (rdev->family == CHIP_HAINAN)) /* for completeness.  HAINAN has no display hw */
                 fb_format |= SI_GRPH_PIPE_CONFIG(SI_ADDR_SURF_P4_8x16);
 
         switch (radeon_crtc->crtc_id) {
diff --git a/drivers/gpu/drm/radeon/cik_sdma.c b/drivers/gpu/drm/radeon/cik_sdma.c
index 0300727a4f70..d08b83c6267b 100644
--- a/drivers/gpu/drm/radeon/cik_sdma.c
+++ b/drivers/gpu/drm/radeon/cik_sdma.c
@@ -458,7 +458,7 @@ int cik_copy_dma(struct radeon_device *rdev,
                 radeon_ring_write(ring, 0); /* src/dst endian swap */
                 radeon_ring_write(ring, src_offset & 0xffffffff);
                 radeon_ring_write(ring, upper_32_bits(src_offset) & 0xffffffff);
-                radeon_ring_write(ring, dst_offset & 0xfffffffc);
+                radeon_ring_write(ring, dst_offset & 0xffffffff);
                 radeon_ring_write(ring, upper_32_bits(dst_offset) & 0xffffffff);
                 src_offset += cur_size_in_bytes;
                 dst_offset += cur_size_in_bytes;
diff --git a/drivers/gpu/drm/radeon/dce6_afmt.c b/drivers/gpu/drm/radeon/dce6_afmt.c
index de86493cbc44..713a5d359901 100644
--- a/drivers/gpu/drm/radeon/dce6_afmt.c
+++ b/drivers/gpu/drm/radeon/dce6_afmt.c
@@ -174,7 +174,7 @@ void dce6_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_speaker_allocation(radeon_connector->edid, &sadb);
-        if (sad_count < 0) {
+        if (sad_count <= 0) {
                 DRM_ERROR("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
                 return;
         }
@@ -235,7 +235,7 @@ void dce6_afmt_write_sad_regs(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_sad(radeon_connector->edid, &sads);
-        if (sad_count < 0) {
+        if (sad_count <= 0) {
                 DRM_ERROR("Couldn't read SADs: %d\n", sad_count);
                 return;
         }
@@ -308,7 +308,9 @@ int dce6_audio_init(struct radeon_device *rdev)
         rdev->audio.enabled = true;
 
         if (ASIC_IS_DCE8(rdev))
-                rdev->audio.num_pins = 7;
+                rdev->audio.num_pins = 6;
+        else if (ASIC_IS_DCE61(rdev))
+                rdev->audio.num_pins = 4;
         else
                 rdev->audio.num_pins = 6;
 
diff --git a/drivers/gpu/drm/radeon/evergreen_hdmi.c b/drivers/gpu/drm/radeon/evergreen_hdmi.c
index aa695c4feb3d..0c6d5cef4cf1 100644
--- a/drivers/gpu/drm/radeon/evergreen_hdmi.c
+++ b/drivers/gpu/drm/radeon/evergreen_hdmi.c
@@ -118,7 +118,7 @@ static void dce4_afmt_write_speaker_allocation(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_speaker_allocation(radeon_connector->edid, &sadb);
-        if (sad_count < 0) {
+        if (sad_count <= 0) {
                 DRM_ERROR("Couldn't read Speaker Allocation Data Block: %d\n", sad_count);
                 return;
         }
@@ -173,7 +173,7 @@ static void evergreen_hdmi_write_sad_regs(struct drm_encoder *encoder)
         }
 
         sad_count = drm_edid_to_sad(radeon_connector->edid, &sads);
-        if (sad_count < 0) {
+        if (sad_count <= 0) {
                 DRM_ERROR("Couldn't read SADs: %d\n", sad_count);
                 return;
         }
diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index 11aab2ab54ce..f59a9e9fccf8 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
@@ -895,6 +895,10 @@ static void cayman_gpu_init(struct radeon_device *rdev)
                     (rdev->pdev->device == 0x999C)) {
                         rdev->config.cayman.max_simds_per_se = 6;
                         rdev->config.cayman.max_backends_per_se = 2;
+                        rdev->config.cayman.max_hw_contexts = 8;
+                        rdev->config.cayman.sx_max_export_size = 256;
+                        rdev->config.cayman.sx_max_export_pos_size = 64;
+                        rdev->config.cayman.sx_max_export_smx_size = 192;
                 } else if ((rdev->pdev->device == 0x9903) ||
                            (rdev->pdev->device == 0x9904) ||
                            (rdev->pdev->device == 0x990A) ||
@@ -905,6 +909,10 @@ static void cayman_gpu_init(struct radeon_device *rdev)
                            (rdev->pdev->device == 0x999D)) {
                         rdev->config.cayman.max_simds_per_se = 4;
                         rdev->config.cayman.max_backends_per_se = 2;
+                        rdev->config.cayman.max_hw_contexts = 8;
+                        rdev->config.cayman.sx_max_export_size = 256;
+                        rdev->config.cayman.sx_max_export_pos_size = 64;
+                        rdev->config.cayman.sx_max_export_smx_size = 192;
                 } else if ((rdev->pdev->device == 0x9919) ||
                            (rdev->pdev->device == 0x9990) ||
                            (rdev->pdev->device == 0x9991) ||
@@ -915,9 +923,17 @@ static void cayman_gpu_init(struct radeon_device *rdev)
                            (rdev->pdev->device == 0x99A0)) {
                         rdev->config.cayman.max_simds_per_se = 3;
                         rdev->config.cayman.max_backends_per_se = 1;
+                        rdev->config.cayman.max_hw_contexts = 4;
+                        rdev->config.cayman.sx_max_export_size = 128;
+                        rdev->config.cayman.sx_max_export_pos_size = 32;
+                        rdev->config.cayman.sx_max_export_smx_size = 96;
                 } else {
                         rdev->config.cayman.max_simds_per_se = 2;
                         rdev->config.cayman.max_backends_per_se = 1;
+                        rdev->config.cayman.max_hw_contexts = 4;
+                        rdev->config.cayman.sx_max_export_size = 128;
+                        rdev->config.cayman.sx_max_export_pos_size = 32;
+                        rdev->config.cayman.sx_max_export_smx_size = 96;
                 }
                 rdev->config.cayman.max_texture_channel_caches = 2;
                 rdev->config.cayman.max_gprs = 256;
@@ -925,10 +941,6 @@ static void cayman_gpu_init(struct radeon_device *rdev)
                 rdev->config.cayman.max_gs_threads = 32;
                 rdev->config.cayman.max_stack_entries = 512;
                 rdev->config.cayman.sx_num_of_sets = 8;
-                rdev->config.cayman.sx_max_export_size = 256;
-                rdev->config.cayman.sx_max_export_pos_size = 64;
-                rdev->config.cayman.sx_max_export_smx_size = 192;
-                rdev->config.cayman.max_hw_contexts = 8;
                 rdev->config.cayman.sq_num_cf_insts = 2;
 
                 rdev->config.cayman.sc_prim_fifo_size = 0x40;
diff --git a/drivers/gpu/drm/radeon/radeon_asic.c b/drivers/gpu/drm/radeon/radeon_asic.c
index e354ce94cdd1..c0425bb6223a 100644
--- a/drivers/gpu/drm/radeon/radeon_asic.c
+++ b/drivers/gpu/drm/radeon/radeon_asic.c
@@ -2021,7 +2021,7 @@ static struct radeon_asic ci_asic = {
                 .hdmi_setmode = &evergreen_hdmi_setmode,
         },
         .copy = {
-                .blit = NULL,
+                .blit = &cik_copy_cpdma,
                 .blit_ring_index = RADEON_RING_TYPE_GFX_INDEX,
                 .dma = &cik_copy_dma,
                 .dma_ring_index = R600_RING_TYPE_DMA_INDEX,
@@ -2122,7 +2122,7 @@ static struct radeon_asic kv_asic = {
                 .hdmi_setmode = &evergreen_hdmi_setmode,
         },
         .copy = {
-                .blit = NULL,
+                .blit = &cik_copy_cpdma,
                 .blit_ring_index = RADEON_RING_TYPE_GFX_INDEX,
                 .dma = &cik_copy_dma,
                 .dma_ring_index = R600_RING_TYPE_DMA_INDEX,
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 9f5ff28864f6..1958b36ad0e5 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -508,15 +508,6 @@ static const struct file_operations radeon_driver_kms_fops = {
 #endif
 };
 
-
-static void
-radeon_pci_shutdown(struct pci_dev *pdev)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-
-        radeon_driver_unload_kms(dev);
-}
-
 static struct drm_driver kms_driver = {
         .driver_features =
             DRIVER_USE_AGP |
@@ -586,7 +577,6 @@ static struct pci_driver radeon_kms_pci_driver = {
         .probe = radeon_pci_probe,
         .remove = radeon_pci_remove,
         .driver.pm = &radeon_pm_ops,
-        .shutdown = radeon_pci_shutdown,
 };
 
 static int __init radeon_init(void)
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c
index 1c560629575a..e7dab069cccf 100644
--- a/drivers/gpu/drm/radeon/rs690.c
+++ b/drivers/gpu/drm/radeon/rs690.c
@@ -162,6 +162,16 @@ static void rs690_mc_init(struct radeon_device *rdev)
         base = RREG32_MC(R_000100_MCCFG_FB_LOCATION);
         base = G_000100_MC_FB_START(base) << 16;
         rdev->mc.igp_sideport_enabled = radeon_atombios_sideport_present(rdev);
+        /* Some boards seem to be configured for 128MB of sideport memory,
+         * but really only have 64MB.  Just skip the sideport and use
+         * UMA memory.
+         */
+        if (rdev->mc.igp_sideport_enabled &&
+            (rdev->mc.real_vram_size == (384 * 1024 * 1024))) {
+                base += 128 * 1024 * 1024;
+                rdev->mc.real_vram_size -= 128 * 1024 * 1024;
+                rdev->mc.mc_vram_size = rdev->mc.real_vram_size;
+        }
 
         /* Use K8 direct mapping for fast fb access. */ 
         rdev->fastfb_working = false;
diff --git a/drivers/gpu/drm/radeon/rv770_dpm.c b/drivers/gpu/drm/radeon/rv770_dpm.c
index 913b025ae9b3..374499db20c7 100644
--- a/drivers/gpu/drm/radeon/rv770_dpm.c
+++ b/drivers/gpu/drm/radeon/rv770_dpm.c
@@ -2328,6 +2328,12 @@ void rv770_get_engine_memory_ss(struct radeon_device *rdev)
         pi->mclk_ss = radeon_atombios_get_asic_ss_info(rdev, &ss,
                                                        ASIC_INTERNAL_MEMORY_SS, 0);
 
+        /* disable ss, causes hangs on some cayman boards */
+        if (rdev->family == CHIP_CAYMAN) {
+                pi->sclk_ss = false;
+                pi->mclk_ss = false;
+        }
+
         if (pi->sclk_ss || pi->mclk_ss)
                 pi->dynamic_ss = true;
         else
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 15b86a94949d..406152152315 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -353,7 +353,8 @@ int ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
          * Don't move nonexistent data. Clear destination instead.
          */
         if (old_iomap == NULL &&
-            (ttm == NULL || ttm->state == tt_unpopulated)) {
+            (ttm == NULL || (ttm->state == tt_unpopulated &&
+                             !(ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)))) {
                 memset_io(new_iomap, 0, new_mem->num_pages*PAGE_SIZE);
                 goto out2;
         }
diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c
index b249ab9b1eb2..6440eeac22d2 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_vm.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c
@@ -169,9 +169,9 @@ static int ttm_bo_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
         }
 
         page_offset = ((address - vma->vm_start) >> PAGE_SHIFT) +
-            drm_vma_node_start(&bo->vma_node) - vma->vm_pgoff;
-        page_last = vma_pages(vma) +
-            drm_vma_node_start(&bo->vma_node) - vma->vm_pgoff;
+                vma->vm_pgoff - drm_vma_node_start(&bo->vma_node);
+        page_last = vma_pages(vma) + vma->vm_pgoff -
+                drm_vma_node_start(&bo->vma_node);
 
         if (unlikely(page_offset >= bo->num_pages)) {
                 retval = VM_FAULT_SIGBUS;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
index a51f48e3e917..45d5b5ab6ca9 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
@@ -68,6 +68,9 @@ int vmw_getparam_ioctl(struct drm_device *dev, void *data,
                                   SVGA_FIFO_3D_HWVERSION));
                 break;
         }
+        case DRM_VMW_PARAM_MAX_SURF_MEMORY:
+                param->value = dev_priv->memory_size;
+                break;
         default:
                 DRM_ERROR("Illegal vmwgfx get param request: %d\n",
                           param->param);
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 92d1206482a6..f80b700f821c 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -377,6 +377,9 @@ static int intel_idle(struct cpuidle_device *dev,
 
         if (!current_set_polling_and_test()) {
 
+                if (this_cpu_has(X86_FEATURE_CLFLUSH_MONITOR))
+                        clflush((void *)&current_thread_info()->flags);
+
                 __monitor((void *)&current_thread_info()->flags, 0, 0);
                 smp_mb();
                 if (!need_resched())
diff --git a/drivers/iio/adc/ad7887.c b/drivers/iio/adc/ad7887.c
index acb7f90359a3..749a6cadab8b 100644
--- a/drivers/iio/adc/ad7887.c
+++ b/drivers/iio/adc/ad7887.c
@@ -200,7 +200,13 @@ static const struct ad7887_chip_info ad7887_chip_info_tbl[] = {
                         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
                         .address = 1,
                         .scan_index = 1,
-                        .scan_type = IIO_ST('u', 12, 16, 0),
+                        .scan_type = {
+                                .sign = 'u',
+                                .realbits = 12,
+                                .storagebits = 16,
+                                .shift = 0,
+                                .endianness = IIO_BE,
+                        },
                 },
                 .channel[1] = {
                         .type = IIO_VOLTAGE,
@@ -210,7 +216,13 @@ static const struct ad7887_chip_info ad7887_chip_info_tbl[] = {
                         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
                         .address = 0,
                         .scan_index = 0,
-                        .scan_type = IIO_ST('u', 12, 16, 0),
+                        .scan_type = {
+                                .sign = 'u',
+                                .realbits = 12,
+                                .storagebits = 16,
+                                .shift = 0,
+                                .endianness = IIO_BE,
+                        },
                 },
                 .channel[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
                 .int_vref_mv = 2500,
diff --git a/drivers/iio/imu/adis16400_core.c b/drivers/iio/imu/adis16400_core.c
index 3fb7757a1028..368660dfe135 100644
--- a/drivers/iio/imu/adis16400_core.c
+++ b/drivers/iio/imu/adis16400_core.c
@@ -651,7 +651,12 @@ static const struct iio_chan_spec adis16448_channels[] = {
                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
                 .address = ADIS16448_BARO_OUT,
                 .scan_index = ADIS16400_SCAN_BARO,
-                .scan_type = IIO_ST('s', 16, 16, 0),
+                .scan_type = {
+                        .sign = 's',
+                        .realbits = 16,
+                        .storagebits = 16,
+                        .endianness = IIO_BE,
+                },
         },
         ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT, 12),
         IIO_CHAN_SOFT_TIMESTAMP(11)
diff --git a/drivers/iio/light/cm36651.c b/drivers/iio/light/cm36651.c
index 21df57130018..0922e39b0ea9 100644
--- a/drivers/iio/light/cm36651.c
+++ b/drivers/iio/light/cm36651.c
@@ -387,7 +387,7 @@ static int cm36651_read_int_time(struct cm36651_data *cm36651,
                 return -EINVAL;
         }
 
-        return IIO_VAL_INT_PLUS_MICRO;
+        return IIO_VAL_INT;
 }
 
 static int cm36651_write_int_time(struct cm36651_data *cm36651,
diff --git a/drivers/infiniband/core/iwcm.c b/drivers/infiniband/core/iwcm.c
index c47c2034ca71..0717940ec3b5 100644
--- a/drivers/infiniband/core/iwcm.c
+++ b/drivers/infiniband/core/iwcm.c
@@ -181,9 +181,16 @@ static void add_ref(struct iw_cm_id *cm_id)
 static void rem_ref(struct iw_cm_id *cm_id)
 {
         struct iwcm_id_private *cm_id_priv;
+        int cb_destroy;
+
         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
-        if (iwcm_deref_id(cm_id_priv) &&
-            test_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags)) {
+
+        /*
+         * Test bit before deref in case the cm_id gets freed on another
+         * thread.
+         */
+        cb_destroy = test_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags);
+        if (iwcm_deref_id(cm_id_priv) && cb_destroy) {
                 BUG_ON(!list_empty(&cm_id_priv->work_list));
                 free_cm_id(cm_id_priv);
         }
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index bdc842e9faef..a283274a5a09 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -49,12 +49,20 @@
 
 #define INIT_UDATA(udata, ibuf, obuf, ilen, olen)                       \
         do {                                                            \
-                (udata)->inbuf  = (void __user *) (ibuf);               \
+                (udata)->inbuf  = (const void __user *) (ibuf);         \
                 (udata)->outbuf = (void __user *) (obuf);               \
                 (udata)->inlen  = (ilen);                               \
                 (udata)->outlen = (olen);                               \
         } while (0)
 
+#define INIT_UDATA_BUF_OR_NULL(udata, ibuf, obuf, ilen, olen)                   \
+        do {                                                                    \
+                (udata)->inbuf  = (ilen) ? (const void __user *) (ibuf) : NULL; \
+                (udata)->outbuf = (olen) ? (void __user *) (obuf) : NULL;       \
+                (udata)->inlen  = (ilen);                                       \
+                (udata)->outlen = (olen);                                       \
+        } while (0)
+
 /*
  * Our lifetime rules for these structs are the following:
  *
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index 65f6e7dc380c..f1cc83855af6 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -2593,6 +2593,9 @@ out_put:
 static int kern_spec_to_ib_spec(struct ib_uverbs_flow_spec *kern_spec,
                                 union ib_flow_spec *ib_spec)
 {
+        if (kern_spec->reserved)
+                return -EINVAL;
+
         ib_spec->type = kern_spec->type;
 
         switch (ib_spec->type) {
@@ -2646,6 +2649,9 @@ int ib_uverbs_ex_create_flow(struct ib_uverbs_file *file,
         void *ib_spec;
         int i;
 
+        if (ucore->inlen < sizeof(cmd))
+                return -EINVAL;
+
         if (ucore->outlen < sizeof(resp))
                 return -ENOSPC;
 
@@ -2671,6 +2677,10 @@ int ib_uverbs_ex_create_flow(struct ib_uverbs_file *file,
             (cmd.flow_attr.num_of_specs * sizeof(struct ib_uverbs_flow_spec)))
                 return -EINVAL;
 
+        if (cmd.flow_attr.reserved[0] ||
+            cmd.flow_attr.reserved[1])
+                return -EINVAL;
+
         if (cmd.flow_attr.num_of_specs) {
                 kern_flow_attr = kmalloc(sizeof(*kern_flow_attr) + cmd.flow_attr.size,
                                          GFP_KERNEL);
@@ -2731,6 +2741,7 @@ int ib_uverbs_ex_create_flow(struct ib_uverbs_file *file,
         if (cmd.flow_attr.size || (i != flow_attr->num_of_specs)) {
                 pr_warn("create flow failed, flow %d: %d bytes left from uverb cmd\n",
                         i, cmd.flow_attr.size);
+                err = -EINVAL;
                 goto err_free;
         }
         flow_id = ib_create_flow(qp, flow_attr, IB_FLOW_DOMAIN_USER);
@@ -2791,10 +2802,16 @@ int ib_uverbs_ex_destroy_flow(struct ib_uverbs_file *file,
         struct ib_uobject               *uobj;
         int                             ret;
 
+        if (ucore->inlen < sizeof(cmd))
+                return -EINVAL;
+
         ret = ib_copy_from_udata(&cmd, ucore, sizeof(cmd));
         if (ret)
                 return ret;
 
+        if (cmd.comp_mask)
+                return -EINVAL;
+
         uobj = idr_write_uobj(&ib_uverbs_rule_idr, cmd.flow_handle,
                               file->ucontext);
         if (!uobj)
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 34386943ebcf..08219fb3338b 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -668,25 +668,30 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
                 if ((hdr.in_words + ex_hdr.provider_in_words) * 8 != count)
                         return -EINVAL;
 
+                if (ex_hdr.cmd_hdr_reserved)
+                        return -EINVAL;
+
                 if (ex_hdr.response) {
                         if (!hdr.out_words && !ex_hdr.provider_out_words)
                                 return -EINVAL;
+
+                        if (!access_ok(VERIFY_WRITE,
+                                       (void __user *) (unsigned long) ex_hdr.response,
+                                       (hdr.out_words + ex_hdr.provider_out_words) * 8))
+                                return -EFAULT;
                 } else {
                         if (hdr.out_words || ex_hdr.provider_out_words)
                                 return -EINVAL;
                 }
 
-                INIT_UDATA(&ucore,
-                           (hdr.in_words) ? buf : 0,
-                           (unsigned long)ex_hdr.response,
-                           hdr.in_words * 8,
-                           hdr.out_words * 8);
-
-                INIT_UDATA(&uhw,
-                           (ex_hdr.provider_in_words) ? buf + ucore.inlen : 0,
-                           (ex_hdr.provider_out_words) ? (unsigned long)ex_hdr.response + ucore.outlen : 0,
-                           ex_hdr.provider_in_words * 8,
-                           ex_hdr.provider_out_words * 8);
+                INIT_UDATA_BUF_OR_NULL(&ucore, buf, (unsigned long) ex_hdr.response,
+                                       hdr.in_words * 8, hdr.out_words * 8);
+
+                INIT_UDATA_BUF_OR_NULL(&uhw,
+                                       buf + ucore.inlen,
+                                       (unsigned long) ex_hdr.response + ucore.outlen,
+                                       ex_hdr.provider_in_words * 8,
+                                       ex_hdr.provider_out_words * 8);
 
                 err = uverbs_ex_cmd_table[command](file,
                                                    &ucore,
diff --git a/drivers/infiniband/hw/cxgb4/mem.c b/drivers/infiniband/hw/cxgb4/mem.c
index 4cb8eb24497c..84e45006451c 100644
--- a/drivers/infiniband/hw/cxgb4/mem.c
+++ b/drivers/infiniband/hw/cxgb4/mem.c
@@ -173,7 +173,7 @@ static int _c4iw_write_mem_inline(struct c4iw_rdev *rdev, u32 addr, u32 len,
         return ret;
 }
 
-int _c4iw_write_mem_dma(struct c4iw_rdev *rdev, u32 addr, u32 len, void *data)
+static int _c4iw_write_mem_dma(struct c4iw_rdev *rdev, u32 addr, u32 len, void *data)
 {
         u32 remain = len;
         u32 dmalen;
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index 6be57c38638d..9804fca6bf06 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -207,7 +207,9 @@ isert_free_rx_descriptors(struct isert_conn *isert_conn)
         isert_conn->conn_rx_descs = NULL;
 }
 
+static void isert_cq_tx_work(struct work_struct *);
 static void isert_cq_tx_callback(struct ib_cq *, void *);
+static void isert_cq_rx_work(struct work_struct *);
 static void isert_cq_rx_callback(struct ib_cq *, void *);
 
 static int
@@ -259,26 +261,36 @@ isert_create_device_ib_res(struct isert_device *device)
                 cq_desc[i].device = device;
                 cq_desc[i].cq_index = i;
 
+                INIT_WORK(&cq_desc[i].cq_rx_work, isert_cq_rx_work);
                 device->dev_rx_cq[i] = ib_create_cq(device->ib_device,
                                                 isert_cq_rx_callback,
                                                 isert_cq_event_callback,
                                                 (void *)&cq_desc[i],
                                                 ISER_MAX_RX_CQ_LEN, i);
-                if (IS_ERR(device->dev_rx_cq[i]))
+                if (IS_ERR(device->dev_rx_cq[i])) {
+                        ret = PTR_ERR(device->dev_rx_cq[i]);
+                        device->dev_rx_cq[i] = NULL;
                         goto out_cq;
+                }
 
+                INIT_WORK(&cq_desc[i].cq_tx_work, isert_cq_tx_work);
                 device->dev_tx_cq[i] = ib_create_cq(device->ib_device,
                                                 isert_cq_tx_callback,
                                                 isert_cq_event_callback,
                                                 (void *)&cq_desc[i],
                                                 ISER_MAX_TX_CQ_LEN, i);
-                if (IS_ERR(device->dev_tx_cq[i]))
+                if (IS_ERR(device->dev_tx_cq[i])) {
+                        ret = PTR_ERR(device->dev_tx_cq[i]);
+                        device->dev_tx_cq[i] = NULL;
                         goto out_cq;
+                }
 
-                if (ib_req_notify_cq(device->dev_rx_cq[i], IB_CQ_NEXT_COMP))
+                ret = ib_req_notify_cq(device->dev_rx_cq[i], IB_CQ_NEXT_COMP);
+                if (ret)
                         goto out_cq;
 
-                if (ib_req_notify_cq(device->dev_tx_cq[i], IB_CQ_NEXT_COMP))
+                ret = ib_req_notify_cq(device->dev_tx_cq[i], IB_CQ_NEXT_COMP);
+                if (ret)
                         goto out_cq;
         }
 
@@ -1724,7 +1736,6 @@ isert_cq_tx_callback(struct ib_cq *cq, void *context)
 {
         struct isert_cq_desc *cq_desc = (struct isert_cq_desc *)context;
 
-        INIT_WORK(&cq_desc->cq_tx_work, isert_cq_tx_work);
         queue_work(isert_comp_wq, &cq_desc->cq_tx_work);
 }
 
@@ -1768,7 +1779,6 @@ isert_cq_rx_callback(struct ib_cq *cq, void *context)
 {
         struct isert_cq_desc *cq_desc = (struct isert_cq_desc *)context;
 
-        INIT_WORK(&cq_desc->cq_rx_work, isert_cq_rx_work);
         queue_work(isert_rx_wq, &cq_desc->cq_rx_work);
 }
 
diff --git a/drivers/irqchip/irq-renesas-intc-irqpin.c b/drivers/irqchip/irq-renesas-intc-irqpin.c
index 82cec63a9011..3ee78f02e5d7 100644
--- a/drivers/irqchip/irq-renesas-intc-irqpin.c
+++ b/drivers/irqchip/irq-renesas-intc-irqpin.c
@@ -149,8 +149,9 @@ static void intc_irqpin_read_modify_write(struct intc_irqpin_priv *p,
 static void intc_irqpin_mask_unmask_prio(struct intc_irqpin_priv *p,
                                          int irq, int do_mask)
 {
-        int bitfield_width = 4; /* PRIO assumed to have fixed bitfield width */
-        int shift = (7 - irq) * bitfield_width; /* PRIO assumed to be 32-bit */
+        /* The PRIO register is assumed to be 32-bit with fixed 4-bit fields. */
+        int bitfield_width = 4;
+        int shift = 32 - (irq + 1) * bitfield_width;
 
         intc_irqpin_read_modify_write(p, INTC_IRQPIN_REG_PRIO,
                                       shift, bitfield_width,
@@ -159,8 +160,9 @@ static void intc_irqpin_mask_unmask_prio(struct intc_irqpin_priv *p,
 
 static int intc_irqpin_set_sense(struct intc_irqpin_priv *p, int irq, int value)
 {
+        /* The SENSE register is assumed to be 32-bit. */
         int bitfield_width = p->config.sense_bitfield_width;
-        int shift = (7 - irq) * bitfield_width; /* SENSE assumed to be 32-bit */
+        int shift = 32 - (irq + 1) * bitfield_width;
 
         dev_dbg(&p->pdev->dev, "sense irq = %d, mode = %d\n", irq, value);
 
diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c
index 2b46bf1d7e40..4c9852d92b0a 100644
--- a/drivers/md/bcache/alloc.c
+++ b/drivers/md/bcache/alloc.c
@@ -421,9 +421,11 @@ out:
 
         if (watermark <= WATERMARK_METADATA) {
                 SET_GC_MARK(b, GC_MARK_METADATA);
+                SET_GC_MOVE(b, 0);
                 b->prio = BTREE_PRIO;
         } else {
                 SET_GC_MARK(b, GC_MARK_RECLAIMABLE);
+                SET_GC_MOVE(b, 0);
                 b->prio = INITIAL_PRIO;
         }
 
diff --git a/drivers/md/bcache/bcache.h b/drivers/md/bcache/bcache.h
index 4beb55a0ff30..754f43177483 100644
--- a/drivers/md/bcache/bcache.h
+++ b/drivers/md/bcache/bcache.h
@@ -197,7 +197,7 @@ struct bucket {
         uint8_t         disk_gen;
         uint8_t         last_gc; /* Most out of date gen in the btree */
         uint8_t         gc_gen;
-        uint16_t        gc_mark;
+        uint16_t        gc_mark; /* Bitfield used by GC. See below for field */
 };
 
 /*
@@ -209,7 +209,8 @@ BITMASK(GC_MARK,	 struct bucket, gc_mark, 0, 2);
 #define GC_MARK_RECLAIMABLE     0
 #define GC_MARK_DIRTY           1
 #define GC_MARK_METADATA        2
-BITMASK(GC_SECTORS_USED, struct bucket, gc_mark, 2, 14);
+BITMASK(GC_SECTORS_USED, struct bucket, gc_mark, 2, 13);
+BITMASK(GC_MOVE, struct bucket, gc_mark, 15, 1);
 
 #include "journal.h"
 #include "stats.h"
@@ -372,14 +373,14 @@ struct cached_dev {
         unsigned char           writeback_percent;
         unsigned                writeback_delay;
 
-        int                     writeback_rate_change;
-        int64_t                 writeback_rate_derivative;
         uint64_t                writeback_rate_target;
+        int64_t                 writeback_rate_proportional;
+        int64_t                 writeback_rate_derivative;
+        int64_t                 writeback_rate_change;
 
         unsigned                writeback_rate_update_seconds;
         unsigned                writeback_rate_d_term;
         unsigned                writeback_rate_p_term_inverse;
-        unsigned                writeback_rate_d_smooth;
 };
 
 enum alloc_watermarks {
@@ -445,7 +446,6 @@ struct cache {
          * call prio_write() to keep gens from wrapping.
          */
         uint8_t                 need_save_prio;
-        unsigned                gc_move_threshold;
 
         /*
          * If nonzero, we know we aren't going to find any buckets to invalidate
diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
index 5e2765aadce1..31bb53fcc67a 100644
--- a/drivers/md/bcache/btree.c
+++ b/drivers/md/bcache/btree.c
@@ -1561,6 +1561,28 @@ size_t bch_btree_gc_finish(struct cache_set *c)
                 SET_GC_MARK(PTR_BUCKET(c, &c->uuid_bucket, i),
                             GC_MARK_METADATA);
 
+        /* don't reclaim buckets to which writeback keys point */
+        rcu_read_lock();
+        for (i = 0; i < c->nr_uuids; i++) {
+                struct bcache_device *d = c->devices[i];
+                struct cached_dev *dc;
+                struct keybuf_key *w, *n;
+                unsigned j;
+
+                if (!d || UUID_FLASH_ONLY(&c->uuids[i]))
+                        continue;
+                dc = container_of(d, struct cached_dev, disk);
+
+                spin_lock(&dc->writeback_keys.lock);
+                rbtree_postorder_for_each_entry_safe(w, n,
+                                        &dc->writeback_keys.keys, node)
+                        for (j = 0; j < KEY_PTRS(&w->key); j++)
+                                SET_GC_MARK(PTR_BUCKET(c, &w->key, j),
+                                            GC_MARK_DIRTY);
+                spin_unlock(&dc->writeback_keys.lock);
+        }
+        rcu_read_unlock();
+
         for_each_cache(ca, c, i) {
                 uint64_t *i;
 
@@ -1817,7 +1839,8 @@ static bool fix_overlapping_extents(struct btree *b, struct bkey *insert,
                         if (KEY_START(k) > KEY_START(insert) + sectors_found)
                                 goto check_failed;
 
-                        if (KEY_PTRS(replace_key) != KEY_PTRS(k))
+                        if (KEY_PTRS(k) != KEY_PTRS(replace_key) ||
+                            KEY_DIRTY(k) != KEY_DIRTY(replace_key))
                                 goto check_failed;
 
                         /* skip past gen */
@@ -2217,7 +2240,7 @@ struct btree_insert_op {
         struct bkey     *replace_key;
 };
 
-int btree_insert_fn(struct btree_op *b_op, struct btree *b)
+static int btree_insert_fn(struct btree_op *b_op, struct btree *b)
 {
         struct btree_insert_op *op = container_of(b_op,
                                         struct btree_insert_op, op);
diff --git a/drivers/md/bcache/movinggc.c b/drivers/md/bcache/movinggc.c
index 7c1275e66025..f2f0998c4a91 100644
--- a/drivers/md/bcache/movinggc.c
+++ b/drivers/md/bcache/movinggc.c
@@ -25,10 +25,9 @@ static bool moving_pred(struct keybuf *buf, struct bkey *k)
         unsigned i;
 
         for (i = 0; i < KEY_PTRS(k); i++) {
-                struct cache *ca = PTR_CACHE(c, k, i);
                 struct bucket *g = PTR_BUCKET(c, k, i);
 
-                if (GC_SECTORS_USED(g) < ca->gc_move_threshold)
+                if (GC_MOVE(g))
                         return true;
         }
 
@@ -65,11 +64,16 @@ static void write_moving_finish(struct closure *cl)
 
 static void read_moving_endio(struct bio *bio, int error)
 {
+        struct bbio *b = container_of(bio, struct bbio, bio);
         struct moving_io *io = container_of(bio->bi_private,
                                             struct moving_io, cl);
 
         if (error)
                 io->op.error = error;
+        else if (!KEY_DIRTY(&b->key) &&
+                 ptr_stale(io->op.c, &b->key, 0)) {
+                io->op.error = -EINTR;
+        }
 
         bch_bbio_endio(io->op.c, bio, error, "reading data to move");
 }
@@ -141,6 +145,11 @@ static void read_moving(struct cache_set *c)
                 if (!w)
                         break;
 
+                if (ptr_stale(c, &w->key, 0)) {
+                        bch_keybuf_del(&c->moving_gc_keys, w);
+                        continue;
+                }
+
                 io = kzalloc(sizeof(struct moving_io) + sizeof(struct bio_vec)
                              * DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS),
                              GFP_KERNEL);
@@ -184,7 +193,8 @@ static bool bucket_cmp(struct bucket *l, struct bucket *r)
 
 static unsigned bucket_heap_top(struct cache *ca)
 {
-        return GC_SECTORS_USED(heap_peek(&ca->heap));
+        struct bucket *b;
+        return (b = heap_peek(&ca->heap)) ? GC_SECTORS_USED(b) : 0;
 }
 
 void bch_moving_gc(struct cache_set *c)
@@ -226,9 +236,8 @@ void bch_moving_gc(struct cache_set *c)
                         sectors_to_move -= GC_SECTORS_USED(b);
                 }
 
-                ca->gc_move_threshold = bucket_heap_top(ca);
-
-                pr_debug("threshold %u", ca->gc_move_threshold);
+                while (heap_pop(&ca->heap, b, bucket_cmp))
+                        SET_GC_MOVE(b, 1);
         }
 
         mutex_unlock(&c->bucket_lock);
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index dec15cd2d797..c57bfa071a57 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -1676,7 +1676,7 @@ err:
 static bool can_attach_cache(struct cache *ca, struct cache_set *c)
 {
         return ca->sb.block_size        == c->sb.block_size &&
-                ca->sb.bucket_size      == c->sb.block_size &&
+                ca->sb.bucket_size      == c->sb.bucket_size &&
                 ca->sb.nr_in_set        == c->sb.nr_in_set;
 }
 
diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c
index 80d4c2bee18a..a1f85612f0b3 100644
--- a/drivers/md/bcache/sysfs.c
+++ b/drivers/md/bcache/sysfs.c
@@ -83,7 +83,6 @@ rw_attribute(writeback_rate);
 rw_attribute(writeback_rate_update_seconds);
 rw_attribute(writeback_rate_d_term);
 rw_attribute(writeback_rate_p_term_inverse);
-rw_attribute(writeback_rate_d_smooth);
 read_attribute(writeback_rate_debug);
 
 read_attribute(stripe_size);
@@ -129,31 +128,41 @@ SHOW(__bch_cached_dev)
         var_printf(writeback_running,   "%i");
         var_print(writeback_delay);
         var_print(writeback_percent);
-        sysfs_print(writeback_rate,     dc->writeback_rate.rate);
+        sysfs_hprint(writeback_rate,    dc->writeback_rate.rate << 9);
 
         var_print(writeback_rate_update_seconds);
         var_print(writeback_rate_d_term);
         var_print(writeback_rate_p_term_inverse);
-        var_print(writeback_rate_d_smooth);
 
         if (attr == &sysfs_writeback_rate_debug) {
+                char rate[20];
                 char dirty[20];
-                char derivative[20];
                 char target[20];
-                bch_hprint(dirty,
-                           bcache_dev_sectors_dirty(&dc->disk) << 9);
-                bch_hprint(derivative,  dc->writeback_rate_derivative << 9);
+                char proportional[20];
+                char derivative[20];
+                char change[20];
+                s64 next_io;
+
+                bch_hprint(rate,        dc->writeback_rate.rate << 9);
+                bch_hprint(dirty,       bcache_dev_sectors_dirty(&dc->disk) << 9);
                 bch_hprint(target,      dc->writeback_rate_target << 9);
+                bch_hprint(proportional,dc->writeback_rate_proportional << 9);
+                bch_hprint(derivative,  dc->writeback_rate_derivative << 9);
+                bch_hprint(change,      dc->writeback_rate_change << 9);
+
+                next_io = div64_s64(dc->writeback_rate.next - local_clock(),
+                                    NSEC_PER_MSEC);
 
                 return sprintf(buf,
-                               "rate:\t\t%u\n"
-                               "change:\t\t%i\n"
+                               "rate:\t\t%s/sec\n"
                                "dirty:\t\t%s\n"
+                               "target:\t\t%s\n"
+                               "proportional:\t%s\n"
                                "derivative:\t%s\n"
-                               "target:\t\t%s\n",
-                               dc->writeback_rate.rate,
-                               dc->writeback_rate_change,
-                               dirty, derivative, target);
+                               "change:\t\t%s/sec\n"
+                               "next io:\t%llims\n",
+                               rate, dirty, target, proportional,
+                               derivative, change, next_io);
         }
 
         sysfs_hprint(dirty_data,
@@ -189,6 +198,7 @@ STORE(__cached_dev)
         struct kobj_uevent_env *env;
 
 #define d_strtoul(var)          sysfs_strtoul(var, dc->var)
+#define d_strtoul_nonzero(var)  sysfs_strtoul_clamp(var, dc->var, 1, INT_MAX)
 #define d_strtoi_h(var)         sysfs_hatoi(var, dc->var)
 
         sysfs_strtoul(data_csum,        dc->disk.data_csum);
@@ -197,16 +207,15 @@ STORE(__cached_dev)
         d_strtoul(writeback_metadata);
         d_strtoul(writeback_running);
         d_strtoul(writeback_delay);
-        sysfs_strtoul_clamp(writeback_rate,
-                            dc->writeback_rate.rate, 1, 1000000);
+
         sysfs_strtoul_clamp(writeback_percent, dc->writeback_percent, 0, 40);
 
-        d_strtoul(writeback_rate_update_seconds);
+        sysfs_strtoul_clamp(writeback_rate,
+                            dc->writeback_rate.rate, 1, INT_MAX);
+
+        d_strtoul_nonzero(writeback_rate_update_seconds);
         d_strtoul(writeback_rate_d_term);
-        d_strtoul(writeback_rate_p_term_inverse);
-        sysfs_strtoul_clamp(writeback_rate_p_term_inverse,
-                            dc->writeback_rate_p_term_inverse, 1, INT_MAX);
-        d_strtoul(writeback_rate_d_smooth);
+        d_strtoul_nonzero(writeback_rate_p_term_inverse);
 
         d_strtoi_h(sequential_cutoff);
         d_strtoi_h(readahead);
@@ -313,7 +322,6 @@ static struct attribute *bch_cached_dev_files[] = {
         &sysfs_writeback_rate_update_seconds,
         &sysfs_writeback_rate_d_term,
         &sysfs_writeback_rate_p_term_inverse,
-        &sysfs_writeback_rate_d_smooth,
         &sysfs_writeback_rate_debug,
         &sysfs_dirty_data,
         &sysfs_stripe_size,
diff --git a/drivers/md/bcache/util.c b/drivers/md/bcache/util.c
index 462214eeacbe..bb37618e7664 100644
--- a/drivers/md/bcache/util.c
+++ b/drivers/md/bcache/util.c
@@ -209,7 +209,13 @@ uint64_t bch_next_delay(struct bch_ratelimit *d, uint64_t done)
 {
         uint64_t now = local_clock();
 
-        d->next += div_u64(done, d->rate);
+        d->next += div_u64(done * NSEC_PER_SEC, d->rate);
+
+        if (time_before64(now + NSEC_PER_SEC, d->next))
+                d->next = now + NSEC_PER_SEC;
+
+        if (time_after64(now - NSEC_PER_SEC * 2, d->next))
+                d->next = now - NSEC_PER_SEC * 2;
 
         return time_after64(d->next, now)
                 ? div_u64(d->next - now, NSEC_PER_SEC / HZ)
diff --git a/drivers/md/bcache/util.h b/drivers/md/bcache/util.h
index 362c4b3f8b4a..1030c6020e98 100644
--- a/drivers/md/bcache/util.h
+++ b/drivers/md/bcache/util.h
@@ -110,7 +110,7 @@ do {									\
         _r;                                                             \
 })
 
-#define heap_peek(h)    ((h)->size ? (h)->data[0] : NULL)
+#define heap_peek(h)    ((h)->used ? (h)->data[0] : NULL)
 
 #define heap_full(h)    ((h)->used == (h)->size)
 
diff --git a/drivers/md/bcache/writeback.c b/drivers/md/bcache/writeback.c
index 99053b1251be..6c44fe059c27 100644
--- a/drivers/md/bcache/writeback.c
+++ b/drivers/md/bcache/writeback.c
@@ -30,38 +30,40 @@ static void __update_writeback_rate(struct cached_dev *dc)
 
         /* PD controller */
 
-        int change = 0;
-        int64_t error;
         int64_t dirty = bcache_dev_sectors_dirty(&dc->disk);
         int64_t derivative = dirty - dc->disk.sectors_dirty_last;
+        int64_t proportional = dirty - target;
+        int64_t change;
 
         dc->disk.sectors_dirty_last = dirty;
 
-        derivative *= dc->writeback_rate_d_term;
-        derivative = clamp(derivative, -dirty, dirty);
+        /* Scale to sectors per second */
 
-        derivative = ewma_add(dc->disk.sectors_dirty_derivative, derivative,
-                              dc->writeback_rate_d_smooth, 0);
+        proportional *= dc->writeback_rate_update_seconds;
+        proportional = div_s64(proportional, dc->writeback_rate_p_term_inverse);
 
-        /* Avoid divide by zero */
-        if (!target)
-                goto out;
+        derivative = div_s64(derivative, dc->writeback_rate_update_seconds);
 
-        error = div64_s64((dirty + derivative - target) << 8, target);
+        derivative = ewma_add(dc->disk.sectors_dirty_derivative, derivative,
+                              (dc->writeback_rate_d_term /
+                               dc->writeback_rate_update_seconds) ?: 1, 0);
+
+        derivative *= dc->writeback_rate_d_term;
+        derivative = div_s64(derivative, dc->writeback_rate_p_term_inverse);
 
-        change = div_s64((dc->writeback_rate.rate * error) >> 8,
-                         dc->writeback_rate_p_term_inverse);
+        change = proportional + derivative;
 
         /* Don't increase writeback rate if the device isn't keeping up */
         if (change > 0 &&
             time_after64(local_clock(),
-                         dc->writeback_rate.next + 10 * NSEC_PER_MSEC))
+                         dc->writeback_rate.next + NSEC_PER_MSEC))
                 change = 0;
 
         dc->writeback_rate.rate =
-                clamp_t(int64_t, dc->writeback_rate.rate + change,
+                clamp_t(int64_t, (int64_t) dc->writeback_rate.rate + change,
                         1, NSEC_PER_MSEC);
-out:
+
+        dc->writeback_rate_proportional = proportional;
         dc->writeback_rate_derivative = derivative;
         dc->writeback_rate_change = change;
         dc->writeback_rate_target = target;
@@ -87,15 +89,11 @@ static void update_writeback_rate(struct work_struct *work)
 
 static unsigned writeback_delay(struct cached_dev *dc, unsigned sectors)
 {
-        uint64_t ret;
-
         if (test_bit(BCACHE_DEV_DETACHING, &dc->disk.flags) ||
             !dc->writeback_percent)
                 return 0;
 
-        ret = bch_next_delay(&dc->writeback_rate, sectors * 10000000ULL);
-
-        return min_t(uint64_t, ret, HZ);
+        return bch_next_delay(&dc->writeback_rate, sectors);
 }
 
 struct dirty_io {
@@ -241,7 +239,7 @@ static void read_dirty(struct cached_dev *dc)
                 if (KEY_START(&w->key) != dc->last_read ||
                     jiffies_to_msecs(delay) > 50)
                         while (!kthread_should_stop() && delay)
-                                delay = schedule_timeout_interruptible(delay);
+                                delay = schedule_timeout_uninterruptible(delay);
 
                 dc->last_read   = KEY_OFFSET(&w->key);
 
@@ -438,7 +436,7 @@ static int bch_writeback_thread(void *arg)
                         while (delay &&
                                !kthread_should_stop() &&
                                !test_bit(BCACHE_DEV_DETACHING, &dc->disk.flags))
-                                delay = schedule_timeout_interruptible(delay);
+                                delay = schedule_timeout_uninterruptible(delay);
                 }
         }
 
@@ -476,6 +474,8 @@ void bch_sectors_dirty_init(struct cached_dev *dc)
 
         bch_btree_map_keys(&op.op, dc->disk.c, &KEY(op.inode, 0, 0),
                            sectors_dirty_init_fn, 0);
+
+        dc->disk.sectors_dirty_last = bcache_dev_sectors_dirty(&dc->disk);
 }
 
 int bch_cached_dev_writeback_init(struct cached_dev *dc)
@@ -490,18 +490,15 @@ int bch_cached_dev_writeback_init(struct cached_dev *dc)
         dc->writeback_delay             = 30;
         dc->writeback_rate.rate         = 1024;
 
-        dc->writeback_rate_update_seconds = 30;
-        dc->writeback_rate_d_term       = 16;
-        dc->writeback_rate_p_term_inverse = 64;
-        dc->writeback_rate_d_smooth     = 8;
+        dc->writeback_rate_update_seconds = 5;
+        dc->writeback_rate_d_term       = 30;
+        dc->writeback_rate_p_term_inverse = 6000;
 
         dc->writeback_thread = kthread_create(bch_writeback_thread, dc,
                                               "bcache_writeback");
         if (IS_ERR(dc->writeback_thread))
                 return PTR_ERR(dc->writeback_thread);
 
-        set_task_state(dc->writeback_thread, TASK_INTERRUPTIBLE);
-
         INIT_DELAYED_WORK(&dc->writeback_rate_update, update_writeback_rate);
         schedule_delayed_work(&dc->writeback_rate_update,
                               dc->writeback_rate_update_seconds * HZ);
diff --git a/drivers/mfd/twl6040.c b/drivers/mfd/twl6040.c
index 0779d5ab9ab1..51b6df1a7949 100644
--- a/drivers/mfd/twl6040.c
+++ b/drivers/mfd/twl6040.c
@@ -44,6 +44,54 @@
 #define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
 #define TWL6040_NUM_SUPPLIES    (2)
 
+static struct reg_default twl6040_defaults[] = {
+        { 0x01, 0x4B }, /* REG_ASICID   (ro) */
+        { 0x02, 0x00 }, /* REG_ASICREV  (ro) */
+        { 0x03, 0x00 }, /* REG_INTID    */
+        { 0x04, 0x00 }, /* REG_INTMR    */
+        { 0x05, 0x00 }, /* REG_NCPCTRL  */
+        { 0x06, 0x00 }, /* REG_LDOCTL   */
+        { 0x07, 0x60 }, /* REG_HPPLLCTL */
+        { 0x08, 0x00 }, /* REG_LPPLLCTL */
+        { 0x09, 0x4A }, /* REG_LPPLLDIV */
+        { 0x0A, 0x00 }, /* REG_AMICBCTL */
+        { 0x0B, 0x00 }, /* REG_DMICBCTL */
+        { 0x0C, 0x00 }, /* REG_MICLCTL  */
+        { 0x0D, 0x00 }, /* REG_MICRCTL  */
+        { 0x0E, 0x00 }, /* REG_MICGAIN  */
+        { 0x0F, 0x1B }, /* REG_LINEGAIN */
+        { 0x10, 0x00 }, /* REG_HSLCTL   */
+        { 0x11, 0x00 }, /* REG_HSRCTL   */
+        { 0x12, 0x00 }, /* REG_HSGAIN   */
+        { 0x13, 0x00 }, /* REG_EARCTL   */
+        { 0x14, 0x00 }, /* REG_HFLCTL   */
+        { 0x15, 0x00 }, /* REG_HFLGAIN  */
+        { 0x16, 0x00 }, /* REG_HFRCTL   */
+        { 0x17, 0x00 }, /* REG_HFRGAIN  */
+        { 0x18, 0x00 }, /* REG_VIBCTLL  */
+        { 0x19, 0x00 }, /* REG_VIBDATL  */
+        { 0x1A, 0x00 }, /* REG_VIBCTLR  */
+        { 0x1B, 0x00 }, /* REG_VIBDATR  */
+        { 0x1C, 0x00 }, /* REG_HKCTL1   */
+        { 0x1D, 0x00 }, /* REG_HKCTL2   */
+        { 0x1E, 0x00 }, /* REG_GPOCTL   */
+        { 0x1F, 0x00 }, /* REG_ALB      */
+        { 0x20, 0x00 }, /* REG_DLB      */
+        /* 0x28, REG_TRIM1 */
+        /* 0x29, REG_TRIM2 */
+        /* 0x2A, REG_TRIM3 */
+        /* 0x2B, REG_HSOTRIM */
+        /* 0x2C, REG_HFOTRIM */
+        { 0x2D, 0x08 }, /* REG_ACCCTL   */
+        { 0x2E, 0x00 }, /* REG_STATUS   (ro) */
+};
+
+struct reg_default twl6040_patch[] = {
+        /* Select I2C bus access to dual access registers */
+        { TWL6040_REG_ACCCTL, 0x09 },
+};
+
+
 static bool twl6040_has_vibra(struct device_node *node)
 {
 #ifdef CONFIG_OF
@@ -238,6 +286,9 @@ int twl6040_power(struct twl6040 *twl6040, int on)
                 if (twl6040->power_count++)
                         goto out;
 
+                /* Allow writes to the chip */
+                regcache_cache_only(twl6040->regmap, false);
+
                 if (gpio_is_valid(twl6040->audpwron)) {
                         /* use automatic power-up sequence */
                         ret = twl6040_power_up_automatic(twl6040);
@@ -253,6 +304,10 @@ int twl6040_power(struct twl6040 *twl6040, int on)
                                 goto out;
                         }
                 }
+
+                /* Sync with the HW */
+                regcache_sync(twl6040->regmap);
+
                 /* Default PLL configuration after power up */
                 twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
                 twl6040->sysclk = 19200000;
@@ -279,6 +334,11 @@ int twl6040_power(struct twl6040 *twl6040, int on)
                         /* use manual power-down sequence */
                         twl6040_power_down_manual(twl6040);
                 }
+
+                /* Set regmap to cache only and mark it as dirty */
+                regcache_cache_only(twl6040->regmap, true);
+                regcache_mark_dirty(twl6040->regmap);
+
                 twl6040->sysclk = 0;
                 twl6040->mclk = 0;
         }
@@ -490,9 +550,24 @@ static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
 static bool twl6040_volatile_reg(struct device *dev, unsigned int reg)
 {
         switch (reg) {
-        case TWL6040_REG_VIBCTLL:
-        case TWL6040_REG_VIBCTLR:
-        case TWL6040_REG_INTMR:
+        case TWL6040_REG_ASICID:
+        case TWL6040_REG_ASICREV:
+        case TWL6040_REG_INTID:
+        case TWL6040_REG_LPPLLCTL:
+        case TWL6040_REG_HPPLLCTL:
+        case TWL6040_REG_STATUS:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static bool twl6040_writeable_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case TWL6040_REG_ASICID:
+        case TWL6040_REG_ASICREV:
+        case TWL6040_REG_STATUS:
                 return false;
         default:
                 return true;
@@ -502,10 +577,15 @@ static bool twl6040_volatile_reg(struct device *dev, unsigned int reg)
 static struct regmap_config twl6040_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
+
+        .reg_defaults = twl6040_defaults,
+        .num_reg_defaults = ARRAY_SIZE(twl6040_defaults),
+
         .max_register = TWL6040_REG_STATUS, /* 0x2e */
 
         .readable_reg = twl6040_readable_reg,
         .volatile_reg = twl6040_volatile_reg,
+        .writeable_reg = twl6040_writeable_reg,
 
         .cache_type = REGCACHE_RBTREE,
 };
@@ -624,6 +704,8 @@ static int twl6040_probe(struct i2c_client *client,
 
         /* dual-access registers controlled by I2C only */
         twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL);
+        regmap_register_patch(twl6040->regmap, twl6040_patch,
+                              ARRAY_SIZE(twl6040_patch));
 
         /*
          * The main functionality of twl6040 to provide audio on OMAP4+ systems.
@@ -656,6 +738,10 @@ static int twl6040_probe(struct i2c_client *client,
         cell->name = "twl6040-gpo";
         children++;
 
+        /* The chip is powered down so mark regmap to cache only and dirty */
+        regcache_cache_only(twl6040->regmap, true);
+        regcache_mark_dirty(twl6040->regmap);
+
         ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
                               NULL, 0, NULL);
         if (ret)
diff --git a/drivers/mfd/wm5110-tables.c b/drivers/mfd/wm5110-tables.c
index bf8b3b5ad1fe..abd6713de7b0 100644
--- a/drivers/mfd/wm5110-tables.c
+++ b/drivers/mfd/wm5110-tables.c
@@ -14,6 +14,7 @@
 
 #include <linux/mfd/arizona/core.h>
 #include <linux/mfd/arizona/registers.h>
+#include <linux/device.h>
 
 #include "arizona.h"
 
@@ -524,6 +525,7 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x00000300, 0x0000 },    /* R768   - Input Enables */
         { 0x00000308, 0x0000 },    /* R776   - Input Rate */
         { 0x00000309, 0x0022 },    /* R777   - Input Volume Ramp */
+        { 0x0000030C, 0x0002 },    /* R780   - HPF Control */
         { 0x00000310, 0x2080 },    /* R784   - IN1L Control */
         { 0x00000311, 0x0180 },    /* R785   - ADC Digital Volume 1L */
         { 0x00000312, 0x0000 },    /* R786   - DMIC1L Control */
@@ -545,6 +547,7 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x00000328, 0x2000 },    /* R808   - IN4L Control */
         { 0x00000329, 0x0180 },    /* R809   - ADC Digital Volume 4L */
         { 0x0000032A, 0x0000 },    /* R810   - DMIC4L Control */
+        { 0x0000032C, 0x0000 },    /* R812   - IN4R Control */
         { 0x0000032D, 0x0180 },    /* R813   - ADC Digital Volume 4R */
         { 0x0000032E, 0x0000 },    /* R814   - DMIC4R Control */
         { 0x00000400, 0x0000 },    /* R1024  - Output Enables 1 */
@@ -598,6 +601,7 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x0000043D, 0x0180 },    /* R1085  - DAC Digital Volume 6R */
         { 0x0000043E, 0x0080 },    /* R1086  - DAC Volume Limit 6R */
         { 0x0000043F, 0x0800 },    /* R1087  - Noise Gate Select 6R */
+        { 0x00000440, 0x8FFF },    /* R1088  - DRE Enable */
         { 0x00000450, 0x0000 },    /* R1104  - DAC AEC Control 1 */
         { 0x00000458, 0x0000 },    /* R1112  - Noise Gate Control */
         { 0x00000480, 0x0040 },    /* R1152  - Class W ANC Threshold 1 */
@@ -882,6 +886,38 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x0000074D, 0x0080 },    /* R1869  - AIF2TX2MIX Input 3 Volume */
         { 0x0000074E, 0x0000 },    /* R1870  - AIF2TX2MIX Input 4 Source */
         { 0x0000074F, 0x0080 },    /* R1871  - AIF2TX2MIX Input 4 Volume */
+        { 0x00000750, 0x0000 },    /* R1872  - AIF2TX3MIX Input 1 Source */
+        { 0x00000751, 0x0080 },    /* R1873  - AIF2TX3MIX Input 1 Volume */
+        { 0x00000752, 0x0000 },    /* R1874  - AIF2TX3MIX Input 2 Source */
+        { 0x00000753, 0x0080 },    /* R1875  - AIF2TX3MIX Input 2 Volume */
+        { 0x00000754, 0x0000 },    /* R1876  - AIF2TX3MIX Input 3 Source */
+        { 0x00000755, 0x0080 },    /* R1877  - AIF2TX3MIX Input 3 Volume */
+        { 0x00000756, 0x0000 },    /* R1878  - AIF2TX3MIX Input 4 Source */
+        { 0x00000757, 0x0080 },    /* R1879  - AIF2TX3MIX Input 4 Volume */
+        { 0x00000758, 0x0000 },    /* R1880  - AIF2TX4MIX Input 1 Source */
+        { 0x00000759, 0x0080 },    /* R1881  - AIF2TX4MIX Input 1 Volume */
+        { 0x0000075A, 0x0000 },    /* R1882  - AIF2TX4MIX Input 2 Source */
+        { 0x0000075B, 0x0080 },    /* R1883  - AIF2TX4MIX Input 2 Volume */
+        { 0x0000075C, 0x0000 },    /* R1884  - AIF2TX4MIX Input 3 Source */
+        { 0x0000075D, 0x0080 },    /* R1885  - AIF2TX4MIX Input 3 Volume */
+        { 0x0000075E, 0x0000 },    /* R1886  - AIF2TX4MIX Input 4 Source */
+        { 0x0000075F, 0x0080 },    /* R1887  - AIF2TX4MIX Input 4 Volume */
+        { 0x00000760, 0x0000 },    /* R1888  - AIF2TX5MIX Input 1 Source */
+        { 0x00000761, 0x0080 },    /* R1889  - AIF2TX5MIX Input 1 Volume */
+        { 0x00000762, 0x0000 },    /* R1890  - AIF2TX5MIX Input 2 Source */
+        { 0x00000763, 0x0080 },    /* R1891  - AIF2TX5MIX Input 2 Volume */
+        { 0x00000764, 0x0000 },    /* R1892  - AIF2TX5MIX Input 3 Source */
+        { 0x00000765, 0x0080 },    /* R1893  - AIF2TX5MIX Input 3 Volume */
+        { 0x00000766, 0x0000 },    /* R1894  - AIF2TX5MIX Input 4 Source */
+        { 0x00000767, 0x0080 },    /* R1895  - AIF2TX5MIX Input 4 Volume */
+        { 0x00000768, 0x0000 },    /* R1896  - AIF2TX6MIX Input 1 Source */
+        { 0x00000769, 0x0080 },    /* R1897  - AIF2TX6MIX Input 1 Volume */
+        { 0x0000076A, 0x0000 },    /* R1898  - AIF2TX6MIX Input 2 Source */
+        { 0x0000076B, 0x0080 },    /* R1899  - AIF2TX6MIX Input 2 Volume */
+        { 0x0000076C, 0x0000 },    /* R1900  - AIF2TX6MIX Input 3 Source */
+        { 0x0000076D, 0x0080 },    /* R1901  - AIF2TX6MIX Input 3 Volume */
+        { 0x0000076E, 0x0000 },    /* R1902  - AIF2TX6MIX Input 4 Source */
+        { 0x0000076F, 0x0080 },    /* R1903  - AIF2TX6MIX Input 4 Volume */
         { 0x00000780, 0x0000 },    /* R1920  - AIF3TX1MIX Input 1 Source */
         { 0x00000781, 0x0080 },    /* R1921  - AIF3TX1MIX Input 1 Volume */
         { 0x00000782, 0x0000 },    /* R1922  - AIF3TX1MIX Input 2 Source */
@@ -1342,6 +1378,64 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x00001404, 0x0000 },    /* R5124  - DSP4 Status 1 */
 };
 
+static bool wm5110_is_rev_b_adsp_memory(unsigned int reg)
+{
+        if ((reg >= 0x100000 && reg < 0x103000) ||
+            (reg >= 0x180000 && reg < 0x181000) ||
+            (reg >= 0x190000 && reg < 0x192000) ||
+            (reg >= 0x1a8000 && reg < 0x1a9000) ||
+            (reg >= 0x200000 && reg < 0x209000) ||
+            (reg >= 0x280000 && reg < 0x281000) ||
+            (reg >= 0x290000 && reg < 0x29a000) ||
+            (reg >= 0x2a8000 && reg < 0x2aa000) ||
+            (reg >= 0x300000 && reg < 0x30f000) ||
+            (reg >= 0x380000 && reg < 0x382000) ||
+            (reg >= 0x390000 && reg < 0x39e000) ||
+            (reg >= 0x3a8000 && reg < 0x3b6000) ||
+            (reg >= 0x400000 && reg < 0x403000) ||
+            (reg >= 0x480000 && reg < 0x481000) ||
+            (reg >= 0x490000 && reg < 0x492000) ||
+            (reg >= 0x4a8000 && reg < 0x4a9000))
+                return true;
+        else
+                return false;
+}
+
+static bool wm5110_is_rev_d_adsp_memory(unsigned int reg)
+{
+        if ((reg >= 0x100000 && reg < 0x106000) ||
+            (reg >= 0x180000 && reg < 0x182000) ||
+            (reg >= 0x190000 && reg < 0x198000) ||
+            (reg >= 0x1a8000 && reg < 0x1aa000) ||
+            (reg >= 0x200000 && reg < 0x20f000) ||
+            (reg >= 0x280000 && reg < 0x282000) ||
+            (reg >= 0x290000 && reg < 0x29c000) ||
+            (reg >= 0x2a6000 && reg < 0x2b4000) ||
+            (reg >= 0x300000 && reg < 0x30f000) ||
+            (reg >= 0x380000 && reg < 0x382000) ||
+            (reg >= 0x390000 && reg < 0x3a2000) ||
+            (reg >= 0x3a6000 && reg < 0x3b4000) ||
+            (reg >= 0x400000 && reg < 0x406000) ||
+            (reg >= 0x480000 && reg < 0x482000) ||
+            (reg >= 0x490000 && reg < 0x498000) ||
+            (reg >= 0x4a8000 && reg < 0x4aa000))
+                return true;
+        else
+                return false;
+}
+
+static bool wm5110_is_adsp_memory(struct device *dev, unsigned int reg)
+{
+        struct arizona *arizona = dev_get_drvdata(dev);
+
+        switch (arizona->rev) {
+        case 0 ... 2:
+                return wm5110_is_rev_b_adsp_memory(reg);
+        default:
+                return wm5110_is_rev_d_adsp_memory(reg);
+        }
+}
+
 static bool wm5110_readable_register(struct device *dev, unsigned int reg)
 {
         switch (reg) {
@@ -1460,6 +1554,7 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_INPUT_ENABLES_STATUS:
         case ARIZONA_INPUT_RATE:
         case ARIZONA_INPUT_VOLUME_RAMP:
+        case ARIZONA_HPF_CONTROL:
         case ARIZONA_IN1L_CONTROL:
         case ARIZONA_ADC_DIGITAL_VOLUME_1L:
         case ARIZONA_DMIC1L_CONTROL:
@@ -1481,6 +1576,7 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_IN4L_CONTROL:
         case ARIZONA_ADC_DIGITAL_VOLUME_4L:
         case ARIZONA_DMIC4L_CONTROL:
+        case ARIZONA_IN4R_CONTROL:
         case ARIZONA_ADC_DIGITAL_VOLUME_4R:
         case ARIZONA_DMIC4R_CONTROL:
         case ARIZONA_OUTPUT_ENABLES_1:
@@ -1536,6 +1632,7 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_DAC_DIGITAL_VOLUME_6R:
         case ARIZONA_DAC_VOLUME_LIMIT_6R:
         case ARIZONA_NOISE_GATE_SELECT_6R:
+        case ARIZONA_DRE_ENABLE:
         case ARIZONA_DAC_AEC_CONTROL_1:
         case ARIZONA_NOISE_GATE_CONTROL:
         case ARIZONA_PDM_SPK1_CTRL_1:
@@ -1820,6 +1917,38 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_AIF2TX2MIX_INPUT_3_VOLUME:
         case ARIZONA_AIF2TX2MIX_INPUT_4_SOURCE:
         case ARIZONA_AIF2TX2MIX_INPUT_4_VOLUME:
+        case ARIZONA_AIF2TX3MIX_INPUT_1_SOURCE:
+        case ARIZONA_AIF2TX3MIX_INPUT_1_VOLUME:
+        case ARIZONA_AIF2TX3MIX_INPUT_2_SOURCE:
+        case ARIZONA_AIF2TX3MIX_INPUT_2_VOLUME:
+        case ARIZONA_AIF2TX3MIX_INPUT_3_SOURCE:
+        case ARIZONA_AIF2TX3MIX_INPUT_3_VOLUME:
+        case ARIZONA_AIF2TX3MIX_INPUT_4_SOURCE:
+        case ARIZONA_AIF2TX3MIX_INPUT_4_VOLUME:
+        case ARIZONA_AIF2TX4MIX_INPUT_1_SOURCE:
+        case ARIZONA_AIF2TX4MIX_INPUT_1_VOLUME:
+        case ARIZONA_AIF2TX4MIX_INPUT_2_SOURCE:
+        case ARIZONA_AIF2TX4MIX_INPUT_2_VOLUME:
+        case ARIZONA_AIF2TX4MIX_INPUT_3_SOURCE:
+        case ARIZONA_AIF2TX4MIX_INPUT_3_VOLUME:
+        case ARIZONA_AIF2TX4MIX_INPUT_4_SOURCE:
+        case ARIZONA_AIF2TX4MIX_INPUT_4_VOLUME:
+        case ARIZONA_AIF2TX5MIX_INPUT_1_SOURCE:
+        case ARIZONA_AIF2TX5MIX_INPUT_1_VOLUME:
+        case ARIZONA_AIF2TX5MIX_INPUT_2_SOURCE:
+        case ARIZONA_AIF2TX5MIX_INPUT_2_VOLUME:
+        case ARIZONA_AIF2TX5MIX_INPUT_3_SOURCE:
+        case ARIZONA_AIF2TX5MIX_INPUT_3_VOLUME:
+        case ARIZONA_AIF2TX5MIX_INPUT_4_SOURCE:
+        case ARIZONA_AIF2TX5MIX_INPUT_4_VOLUME:
+        case ARIZONA_AIF2TX6MIX_INPUT_1_SOURCE:
+        case ARIZONA_AIF2TX6MIX_INPUT_1_VOLUME:
+        case ARIZONA_AIF2TX6MIX_INPUT_2_SOURCE:
+        case ARIZONA_AIF2TX6MIX_INPUT_2_VOLUME:
+        case ARIZONA_AIF2TX6MIX_INPUT_3_SOURCE:
+        case ARIZONA_AIF2TX6MIX_INPUT_3_VOLUME:
+        case ARIZONA_AIF2TX6MIX_INPUT_4_SOURCE:
+        case ARIZONA_AIF2TX6MIX_INPUT_4_VOLUME:
         case ARIZONA_AIF3TX1MIX_INPUT_1_SOURCE:
         case ARIZONA_AIF3TX1MIX_INPUT_1_VOLUME:
         case ARIZONA_AIF3TX1MIX_INPUT_2_SOURCE:
@@ -2331,7 +2460,7 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_DSP4_SCRATCH_3:
                 return true;
         default:
-                return false;
+                return wm5110_is_adsp_memory(dev, reg);
         }
 }
 
@@ -2407,16 +2536,18 @@ static bool wm5110_volatile_register(struct device *dev, unsigned int reg)
         case ARIZONA_DSP4_SCRATCH_3:
                 return true;
         default:
-                return false;
+                return wm5110_is_adsp_memory(dev, reg);
         }
 }
 
+#define WM5110_MAX_REGISTER 0x4a9fff
+
 const struct regmap_config wm5110_spi_regmap = {
         .reg_bits = 32,
         .pad_bits = 16,
         .val_bits = 16,
 
-        .max_register = ARIZONA_DSP1_STATUS_2,
+        .max_register = WM5110_MAX_REGISTER,
         .readable_reg = wm5110_readable_register,
         .volatile_reg = wm5110_volatile_register,
 
@@ -2430,7 +2561,7 @@ const struct regmap_config wm5110_i2c_regmap = {
         .reg_bits = 32,
         .val_bits = 16,
 
-        .max_register = ARIZONA_DSP1_STATUS_2,
+        .max_register = WM5110_MAX_REGISTER,
         .readable_reg = wm5110_readable_register,
         .volatile_reg = wm5110_volatile_register,
 
diff --git a/drivers/net/can/usb/ems_usb.c b/drivers/net/can/usb/ems_usb.c
index 5f9a7ad9b964..8aeec0b4601a 100644
--- a/drivers/net/can/usb/ems_usb.c
+++ b/drivers/net/can/usb/ems_usb.c
@@ -625,6 +625,7 @@ static int ems_usb_start(struct ems_usb *dev)
                         usb_unanchor_urb(urb);
                         usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
                                           urb->transfer_dma);
+                        usb_free_urb(urb);
                         break;
                 }
 
@@ -798,8 +799,8 @@ static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *ne
          * allowed (MAX_TX_URBS).
          */
         if (!context) {
-                usb_unanchor_urb(urb);
                 usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
+                usb_free_urb(urb);
 
                 netdev_warn(netdev, "couldn't find free context\n");
 
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
index 8ee9d1556e6e..263dd921edc4 100644
--- a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
+++ b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
@@ -927,6 +927,9 @@ static int pcan_usb_pro_init(struct peak_usb_device *dev)
         /* set LED in default state (end of init phase) */
         pcan_usb_pro_set_led(dev, 0, 1);
 
+        kfree(bi);
+        kfree(fi);
+
         return 0;
 
  err_out:
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c
index b1cb0ffb15c7..6055d397a29e 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c
@@ -447,8 +447,9 @@ irqreturn_t qlcnic_83xx_intr(int irq, void *data)
 
         qlcnic_83xx_poll_process_aen(adapter);
 
-        if (ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
-                ahw->diag_cnt++;
+        if (ahw->diag_test) {
+                if (ahw->diag_test == QLCNIC_INTERRUPT_TEST)
+                        ahw->diag_cnt++;
                 qlcnic_83xx_enable_legacy_msix_mbx_intr(adapter);
                 return IRQ_HANDLED;
         }
@@ -1345,11 +1346,6 @@ static int qlcnic_83xx_diag_alloc_res(struct net_device *netdev, int test,
         }
 
         if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
-                /* disable and free mailbox interrupt */
-                if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
-                        qlcnic_83xx_enable_mbx_poll(adapter);
-                        qlcnic_83xx_free_mbx_intr(adapter);
-                }
                 adapter->ahw->loopback_state = 0;
                 adapter->ahw->hw_ops->setup_link_event(adapter, 1);
         }
@@ -1363,33 +1359,20 @@ static void qlcnic_83xx_diag_free_res(struct net_device *netdev,
 {
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
         struct qlcnic_host_sds_ring *sds_ring;
-        int ring, err;
+        int ring;
 
         clear_bit(__QLCNIC_DEV_UP, &adapter->state);
         if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
                 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
                         sds_ring = &adapter->recv_ctx->sds_rings[ring];
-                        qlcnic_83xx_disable_intr(adapter, sds_ring);
-                        if (!(adapter->flags & QLCNIC_MSIX_ENABLED))
-                                qlcnic_83xx_enable_mbx_poll(adapter);
+                        if (adapter->flags & QLCNIC_MSIX_ENABLED)
+                                qlcnic_83xx_disable_intr(adapter, sds_ring);
                 }
         }
 
         qlcnic_fw_destroy_ctx(adapter);
         qlcnic_detach(adapter);
 
-        if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
-                if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
-                        err = qlcnic_83xx_setup_mbx_intr(adapter);
-                        qlcnic_83xx_disable_mbx_poll(adapter);
-                        if (err) {
-                                dev_err(&adapter->pdev->dev,
-                                        "%s: failed to setup mbx interrupt\n",
-                                        __func__);
-                                goto out;
-                        }
-                }
-        }
         adapter->ahw->diag_test = 0;
         adapter->drv_sds_rings = drv_sds_rings;
 
@@ -1399,9 +1382,6 @@ static void qlcnic_83xx_diag_free_res(struct net_device *netdev,
         if (netif_running(netdev))
                 __qlcnic_up(adapter, netdev);
 
-        if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST &&
-            !(adapter->flags & QLCNIC_MSIX_ENABLED))
-                qlcnic_83xx_disable_mbx_poll(adapter);
 out:
         netif_device_attach(netdev);
 }
@@ -3754,6 +3734,19 @@ static void qlcnic_83xx_decode_mbx_rsp(struct qlcnic_adapter *adapter,
         return;
 }
 
+static inline void qlcnic_dump_mailbox_registers(struct qlcnic_adapter *adapter)
+{
+        struct qlcnic_hardware_context *ahw = adapter->ahw;
+        u32 offset;
+
+        offset = QLCRDX(ahw, QLCNIC_DEF_INT_MASK);
+        dev_info(&adapter->pdev->dev, "Mbx interrupt mask=0x%x, Mbx interrupt enable=0x%x, Host mbx control=0x%x, Fw mbx control=0x%x",
+                 readl(ahw->pci_base0 + offset),
+                 QLCRDX(ahw, QLCNIC_MBX_INTR_ENBL),
+                 QLCRDX(ahw, QLCNIC_HOST_MBX_CTRL),
+                 QLCRDX(ahw, QLCNIC_FW_MBX_CTRL));
+}
+
 static void qlcnic_83xx_mailbox_worker(struct work_struct *work)
 {
         struct qlcnic_mailbox *mbx = container_of(work, struct qlcnic_mailbox,
@@ -3798,6 +3791,8 @@ static void qlcnic_83xx_mailbox_worker(struct work_struct *work)
                                 __func__, cmd->cmd_op, cmd->type, ahw->pci_func,
                                 ahw->op_mode);
                         clear_bit(QLC_83XX_MBX_READY, &mbx->status);
+                        qlcnic_dump_mailbox_registers(adapter);
+                        qlcnic_83xx_get_mbx_data(adapter, cmd);
                         qlcnic_dump_mbx(adapter, cmd);
                         qlcnic_83xx_idc_request_reset(adapter,
                                                       QLCNIC_FORCE_FW_DUMP_KEY);
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.h b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.h
index 4cae6caa6bfa..a6a33508e401 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.h
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.h
@@ -662,4 +662,5 @@ pci_ers_result_t qlcnic_83xx_io_error_detected(struct pci_dev *,
                                                pci_channel_state_t);
 pci_ers_result_t qlcnic_83xx_io_slot_reset(struct pci_dev *);
 void qlcnic_83xx_io_resume(struct pci_dev *);
+void qlcnic_83xx_stop_hw(struct qlcnic_adapter *);
 #endif
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c
index 89208e5b25d6..918e18ddf038 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c
@@ -740,6 +740,7 @@ static int qlcnic_83xx_idc_unknown_state(struct qlcnic_adapter *adapter)
         adapter->ahw->idc.err_code = -EIO;
         dev_err(&adapter->pdev->dev,
                 "%s: Device in unknown state\n", __func__);
+        clear_bit(__QLCNIC_RESETTING, &adapter->state);
         return 0;
 }
 
@@ -818,7 +819,6 @@ static int qlcnic_83xx_idc_ready_state(struct qlcnic_adapter *adapter)
         struct qlcnic_hardware_context *ahw = adapter->ahw;
         struct qlcnic_mailbox *mbx = ahw->mailbox;
         int ret = 0;
-        u32 owner;
         u32 val;
 
         /* Perform NIC configuration based ready state entry actions */
@@ -848,9 +848,9 @@ static int qlcnic_83xx_idc_ready_state(struct qlcnic_adapter *adapter)
                         set_bit(__QLCNIC_RESETTING, &adapter->state);
                         qlcnic_83xx_idc_enter_need_reset_state(adapter, 1);
                 }  else {
-                        owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
-                        if (ahw->pci_func == owner)
-                                qlcnic_dump_fw(adapter);
+                        netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
+                                    __func__);
+                        qlcnic_83xx_idc_enter_failed_state(adapter, 1);
                 }
                 return -EIO;
         }
@@ -948,13 +948,26 @@ static int qlcnic_83xx_idc_need_quiesce_state(struct qlcnic_adapter *adapter)
         return 0;
 }
 
-static int qlcnic_83xx_idc_failed_state(struct qlcnic_adapter *adapter)
+static void qlcnic_83xx_idc_failed_state(struct qlcnic_adapter *adapter)
 {
-        dev_err(&adapter->pdev->dev, "%s: please restart!!\n", __func__);
+        struct qlcnic_hardware_context *ahw = adapter->ahw;
+        u32 val, owner;
+
+        val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
+        if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
+                owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
+                if (ahw->pci_func == owner) {
+                        qlcnic_83xx_stop_hw(adapter);
+                        qlcnic_dump_fw(adapter);
+                }
+        }
+
+        netdev_warn(adapter->netdev, "%s: Reboot will be required to recover the adapter!!\n",
+                    __func__);
         clear_bit(__QLCNIC_RESETTING, &adapter->state);
-        adapter->ahw->idc.err_code = -EIO;
+        ahw->idc.err_code = -EIO;
 
-        return 0;
+        return;
 }
 
 static int qlcnic_83xx_idc_quiesce_state(struct qlcnic_adapter *adapter)
@@ -1063,12 +1076,6 @@ void qlcnic_83xx_idc_poll_dev_state(struct work_struct *work)
         adapter->ahw->idc.prev_state = adapter->ahw->idc.curr_state;
         qlcnic_83xx_periodic_tasks(adapter);
 
-        /* Do not reschedule if firmaware is in hanged state and auto
-         * recovery is disabled
-         */
-        if ((adapter->flags & QLCNIC_FW_HANG) && !qlcnic_auto_fw_reset)
-                return;
-
         /* Re-schedule the function */
         if (test_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status))
                 qlcnic_schedule_work(adapter, qlcnic_83xx_idc_poll_dev_state,
@@ -1219,10 +1226,10 @@ void qlcnic_83xx_idc_request_reset(struct qlcnic_adapter *adapter, u32 key)
         }
 
         val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
-        if ((val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) ||
-            !qlcnic_auto_fw_reset) {
-                dev_err(&adapter->pdev->dev,
-                        "%s:failed, device in non reset mode\n", __func__);
+        if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
+                netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
+                            __func__);
+                qlcnic_83xx_idc_enter_failed_state(adapter, 0);
                 qlcnic_83xx_unlock_driver(adapter);
                 return;
         }
@@ -1254,24 +1261,24 @@ static int qlcnic_83xx_copy_bootloader(struct qlcnic_adapter *adapter)
         if (size & 0xF)
                 size = (size + 16) & ~0xF;
 
-        p_cache = kzalloc(size, GFP_KERNEL);
+        p_cache = vzalloc(size);
         if (p_cache == NULL)
                 return -ENOMEM;
 
         ret = qlcnic_83xx_lockless_flash_read32(adapter, src, p_cache,
                                                 size / sizeof(u32));
         if (ret) {
-                kfree(p_cache);
+                vfree(p_cache);
                 return ret;
         }
         /* 16 byte write to MS memory */
         ret = qlcnic_83xx_ms_mem_write128(adapter, dest, (u32 *)p_cache,
                                           size / 16);
         if (ret) {
-                kfree(p_cache);
+                vfree(p_cache);
                 return ret;
         }
-        kfree(p_cache);
+        vfree(p_cache);
 
         return ret;
 }
@@ -1939,7 +1946,7 @@ static void qlcnic_83xx_exec_template_cmd(struct qlcnic_adapter *p_dev,
         p_dev->ahw->reset.seq_index = index;
 }
 
-static void qlcnic_83xx_stop_hw(struct qlcnic_adapter *p_dev)
+void qlcnic_83xx_stop_hw(struct qlcnic_adapter *p_dev)
 {
         p_dev->ahw->reset.seq_index = 0;
 
@@ -1994,6 +2001,14 @@ static int qlcnic_83xx_restart_hw(struct qlcnic_adapter *adapter)
         val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
         if (!(val & QLC_83XX_IDC_GRACEFULL_RESET))
                 qlcnic_dump_fw(adapter);
+
+        if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
+                netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
+                            __func__);
+                qlcnic_83xx_idc_enter_failed_state(adapter, 1);
+                return err;
+        }
+
         qlcnic_83xx_init_hw(adapter);
 
         if (qlcnic_83xx_copy_bootloader(adapter))
@@ -2073,8 +2088,8 @@ int qlcnic_83xx_configure_opmode(struct qlcnic_adapter *adapter)
                 ahw->nic_mode = QLCNIC_DEFAULT_MODE;
                 adapter->nic_ops->init_driver = qlcnic_83xx_init_default_driver;
                 ahw->idc.state_entry = qlcnic_83xx_idc_ready_state_entry;
-                adapter->max_sds_rings = ahw->max_rx_ques;
-                adapter->max_tx_rings = ahw->max_tx_ques;
+                adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
+                adapter->max_tx_rings = QLCNIC_MAX_TX_RINGS;
         } else {
                 return -EIO;
         }
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c
index b36c02fafcfd..e3be2760665c 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c
@@ -667,30 +667,25 @@ qlcnic_set_ringparam(struct net_device *dev,
 static int qlcnic_validate_ring_count(struct qlcnic_adapter *adapter,
                                       u8 rx_ring, u8 tx_ring)
 {
+        if (rx_ring == 0 || tx_ring == 0)
+                return -EINVAL;
+
         if (rx_ring != 0) {
                 if (rx_ring > adapter->max_sds_rings) {
-                        netdev_err(adapter->netdev, "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n",
+                        netdev_err(adapter->netdev,
+                                   "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n",
                                    rx_ring, adapter->max_sds_rings);
                         return -EINVAL;
                 }
         }
 
          if (tx_ring != 0) {
-                if (qlcnic_82xx_check(adapter) &&
-                    (tx_ring > adapter->max_tx_rings)) {
+                if (tx_ring > adapter->max_tx_rings) {
                         netdev_err(adapter->netdev,
                                    "Invalid ring count, Tx ring count %d should not be greater than max %d driver Tx rings.\n",
                                    tx_ring, adapter->max_tx_rings);
                         return -EINVAL;
                 }
-
-                if (qlcnic_83xx_check(adapter) &&
-                    (tx_ring > QLCNIC_SINGLE_RING)) {
-                        netdev_err(adapter->netdev,
-                                   "Invalid ring count, Tx ring count %d should not be greater than %d driver Tx rings.\n",
-                                   tx_ring, QLCNIC_SINGLE_RING);
-                         return -EINVAL;
-                }
         }
 
         return 0;
@@ -948,6 +943,7 @@ static int qlcnic_irq_test(struct net_device *netdev)
         struct qlcnic_hardware_context *ahw = adapter->ahw;
         struct qlcnic_cmd_args cmd;
         int ret, drv_sds_rings = adapter->drv_sds_rings;
+        int drv_tx_rings = adapter->drv_tx_rings;
 
         if (qlcnic_83xx_check(adapter))
                 return qlcnic_83xx_interrupt_test(netdev);
@@ -980,6 +976,7 @@ free_diag_res:
 
 clear_diag_irq:
         adapter->drv_sds_rings = drv_sds_rings;
+        adapter->drv_tx_rings = drv_tx_rings;
         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 
         return ret;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
index 0149c9495347..eda6c691d897 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
@@ -687,17 +687,11 @@ void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
         if (adapter->ahw->linkup && !linkup) {
                 netdev_info(netdev, "NIC Link is down\n");
                 adapter->ahw->linkup = 0;
-                if (netif_running(netdev)) {
-                        netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
-                }
+                netif_carrier_off(netdev);
         } else if (!adapter->ahw->linkup && linkup) {
                 netdev_info(netdev, "NIC Link is up\n");
                 adapter->ahw->linkup = 1;
-                if (netif_running(netdev)) {
-                        netif_carrier_on(netdev);
-                        netif_wake_queue(netdev);
-                }
+                netif_carrier_on(netdev);
         }
 }
 
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
index 05c1eef8df13..2c8cac0c6a55 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
@@ -1178,6 +1178,7 @@ qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
         } else {
                 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
                 adapter->max_tx_rings = QLCNIC_MAX_HW_TX_RINGS;
+                adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
                 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
         }
 
@@ -1940,7 +1941,6 @@ int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
         qlcnic_detach(adapter);
 
         adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
-        adapter->drv_tx_rings = QLCNIC_SINGLE_RING;
         adapter->ahw->diag_test = test;
         adapter->ahw->linkup = 0;
 
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 524f713f6017..f8135725bcf6 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -327,7 +327,6 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
                 return -EINVAL;
 
         nvdev->start_remove = true;
-        cancel_delayed_work_sync(&ndevctx->dwork);
         cancel_work_sync(&ndevctx->work);
         netif_tx_disable(ndev);
         rndis_filter_device_remove(hdev);
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index e884ee1fe7ed..27bbe58dcbe7 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -1197,6 +1197,9 @@ static int checksum_setup_ip(struct xenvif *vif, struct sk_buff *skb,
 
         err = -EPROTO;
 
+        if (fragment)
+                goto out;
+
         switch (ip_hdr(skb)->protocol) {
         case IPPROTO_TCP:
                 err = maybe_pull_tail(skb,
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index a344f3d52361..330ef2d06567 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -24,8 +24,8 @@ config PHY_EXYNOS_MIPI_VIDEO
 config OMAP_USB2
         tristate "OMAP USB2 PHY Driver"
         depends on ARCH_OMAP2PLUS
+        depends on USB_PHY
         select GENERIC_PHY
-        select USB_PHY
         select OMAP_CONTROL_USB
         help
           Enable this to support the transceiver that is part of SOC. This
@@ -36,8 +36,8 @@ config OMAP_USB2
 config TWL4030_USB
         tristate "TWL4030 USB Transceiver Driver"
         depends on TWL4030_CORE && REGULATOR_TWL4030 && USB_MUSB_OMAP2PLUS
+        depends on USB_PHY
         select GENERIC_PHY
-        select USB_PHY
         help
           Enable this to support the USB OTG transceiver on TWL4030
           family chips (including the TWL5030 and TPS659x0 devices).
diff --git a/drivers/phy/phy-core.c b/drivers/phy/phy-core.c
index 03cf8fb81554..58e0e9739028 100644
--- a/drivers/phy/phy-core.c
+++ b/drivers/phy/phy-core.c
@@ -437,23 +437,18 @@ struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
         int id;
         struct phy *phy;
 
-        if (!dev) {
-                dev_WARN(dev, "no device provided for PHY\n");
-                ret = -EINVAL;
-                goto err0;
-        }
+        if (WARN_ON(!dev))
+                return ERR_PTR(-EINVAL);
 
         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
-        if (!phy) {
-                ret = -ENOMEM;
-                goto err0;
-        }
+        if (!phy)
+                return ERR_PTR(-ENOMEM);
 
         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
         if (id < 0) {
                 dev_err(dev, "unable to get id\n");
                 ret = id;
-                goto err0;
+                goto free_phy;
         }
 
         device_initialize(&phy->dev);
@@ -468,11 +463,11 @@ struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
 
         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
         if (ret)
-                goto err1;
+                goto put_dev;
 
         ret = device_add(&phy->dev);
         if (ret)
-                goto err1;
+                goto put_dev;
 
         if (pm_runtime_enabled(dev)) {
                 pm_runtime_enable(&phy->dev);
@@ -481,12 +476,11 @@ struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
 
         return phy;
 
-err1:
-        ida_remove(&phy_ida, phy->id);
+put_dev:
         put_device(&phy->dev);
+        ida_remove(&phy_ida, phy->id);
+free_phy:
         kfree(phy);
-
-err0:
         return ERR_PTR(ret);
 }
 EXPORT_SYMBOL_GPL(phy_create);
diff --git a/drivers/pinctrl/pinctrl-baytrail.c b/drivers/pinctrl/pinctrl-baytrail.c
index 2832576d8b12..114f5ef4b73a 100644
--- a/drivers/pinctrl/pinctrl-baytrail.c
+++ b/drivers/pinctrl/pinctrl-baytrail.c
@@ -512,6 +512,7 @@ static const struct dev_pm_ops byt_gpio_pm_ops = {
 
 static const struct acpi_device_id byt_gpio_acpi_match[] = {
         { "INT33B2", 0 },
+        { "INT33FC", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(acpi, byt_gpio_acpi_match);
diff --git a/drivers/pinctrl/sh-pfc/sh_pfc.h b/drivers/pinctrl/sh-pfc/sh_pfc.h
index 11bd0d970a52..e2142956a8e5 100644
--- a/drivers/pinctrl/sh-pfc/sh_pfc.h
+++ b/drivers/pinctrl/sh-pfc/sh_pfc.h
@@ -254,7 +254,7 @@ struct sh_pfc_soc_info {
 #define PINMUX_GPIO(_pin)                                               \
         [GPIO_##_pin] = {                                               \
                 .pin = (u16)-1,                                         \
-                .name = __stringify(name),                              \
+                .name = __stringify(GPIO_##_pin),                       \
                 .enum_id = _pin##_DATA,                                 \
         }
 
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index 2a786c504460..3c6768378a94 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -833,6 +833,11 @@ static int rapl_write_data_raw(struct rapl_domain *rd,
         return 0;
 }
 
+static const struct x86_cpu_id energy_unit_quirk_ids[] = {
+        { X86_VENDOR_INTEL, 6, 0x37},/* VLV */
+        {}
+};
+
 static int rapl_check_unit(struct rapl_package *rp, int cpu)
 {
         u64 msr_val;
@@ -853,8 +858,11 @@ static int rapl_check_unit(struct rapl_package *rp, int cpu)
          * time unit: 1/time_unit_divisor Seconds
          */
         value = (msr_val & ENERGY_UNIT_MASK) >> ENERGY_UNIT_OFFSET;
-        rp->energy_unit_divisor = 1 << value;
-
+        /* some CPUs have different way to calculate energy unit */
+        if (x86_match_cpu(energy_unit_quirk_ids))
+                rp->energy_unit_divisor = 1000000 / (1 << value);
+        else
+                rp->energy_unit_divisor = 1 << value;
 
         value = (msr_val & POWER_UNIT_MASK) >> POWER_UNIT_OFFSET;
         rp->power_unit_divisor = 1 << value;
@@ -941,6 +949,7 @@ static void package_power_limit_irq_restore(int package_id)
 static const struct x86_cpu_id rapl_ids[] = {
         { X86_VENDOR_INTEL, 6, 0x2a},/* SNB */
         { X86_VENDOR_INTEL, 6, 0x2d},/* SNB EP */
+        { X86_VENDOR_INTEL, 6, 0x37},/* VLV */
         { X86_VENDOR_INTEL, 6, 0x3a},/* IVB */
         { X86_VENDOR_INTEL, 6, 0x45},/* HSW */
         /* TODO: Add more CPU IDs after testing */
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index 333677d68d0e..9e61922d8230 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -438,7 +438,7 @@ common_reg:
         platform_set_drvdata(pdev, s2mps11);
 
         config.dev = &pdev->dev;
-        config.regmap = iodev->regmap;
+        config.regmap = iodev->regmap_pmic;
         config.driver_data = s2mps11;
         for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) {
                 if (!reg_np) {
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 596480022b0a..38a1257e76e1 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -471,7 +471,7 @@ static void qlt_schedule_sess_for_deletion(struct qla_tgt_sess *sess,
                 schedule_delayed_work(&tgt->sess_del_work, 0);
         else
                 schedule_delayed_work(&tgt->sess_del_work,
-                    jiffies - sess->expires);
+                    sess->expires - jiffies);
 }
 
 /* ha->hardware_lock supposed to be held on entry */
@@ -550,13 +550,14 @@ static void qlt_del_sess_work_fn(struct delayed_work *work)
         struct scsi_qla_host *vha = tgt->vha;
         struct qla_hw_data *ha = vha->hw;
         struct qla_tgt_sess *sess;
-        unsigned long flags;
+        unsigned long flags, elapsed;
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
         while (!list_empty(&tgt->del_sess_list)) {
                 sess = list_entry(tgt->del_sess_list.next, typeof(*sess),
                     del_list_entry);
-                if (time_after_eq(jiffies, sess->expires)) {
+                elapsed = jiffies;
+                if (time_after_eq(elapsed, sess->expires)) {
                         qlt_undelete_sess(sess);
 
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf004,
@@ -566,7 +567,7 @@ static void qlt_del_sess_work_fn(struct delayed_work *work)
                         ha->tgt.tgt_ops->put_sess(sess);
                 } else {
                         schedule_delayed_work(&tgt->sess_del_work,
-                            jiffies - sess->expires);
+                            sess->expires - elapsed);
                         break;
                 }
         }
@@ -4290,6 +4291,7 @@ int qlt_lport_register(struct qla_tgt_func_tmpl *qla_tgt_ops, u64 wwpn,
                 if (rc != 0) {
                         ha->tgt.tgt_ops = NULL;
                         ha->tgt.target_lport_ptr = NULL;
+                        scsi_host_put(host);
                 }
                 mutex_unlock(&qla_tgt_mutex);
                 return rc;
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index eb1f1ef5fa2e..e2dd2fbec5ee 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -395,7 +395,7 @@ config SPI_S3C24XX_FIQ
 config SPI_S3C64XX
         tristate "Samsung S3C64XX series type SPI"
         depends on PLAT_SAMSUNG
-        select S3C64XX_DMA if ARCH_S3C64XX
+        select S3C64XX_PL080 if ARCH_S3C64XX
         help
           SPI driver for Samsung S3C64XX and newer SoCs.
 
diff --git a/drivers/staging/comedi/drivers.c b/drivers/staging/comedi/drivers.c
index 8f02bf66e20b..4964d2a2fc7d 100644
--- a/drivers/staging/comedi/drivers.c
+++ b/drivers/staging/comedi/drivers.c
@@ -446,7 +446,7 @@ int comedi_load_firmware(struct comedi_device *dev,
                 release_firmware(fw);
         }
 
-        return ret;
+        return ret < 0 ? ret : 0;
 }
 EXPORT_SYMBOL_GPL(comedi_load_firmware);
 
diff --git a/drivers/staging/comedi/drivers/8255_pci.c b/drivers/staging/comedi/drivers/8255_pci.c
index 432e3f9c3301..c55f234b29e6 100644
--- a/drivers/staging/comedi/drivers/8255_pci.c
+++ b/drivers/staging/comedi/drivers/8255_pci.c
@@ -63,7 +63,8 @@ enum pci_8255_boardid {
         BOARD_ADLINK_PCI7296,
         BOARD_CB_PCIDIO24,
         BOARD_CB_PCIDIO24H,
-        BOARD_CB_PCIDIO48H,
+        BOARD_CB_PCIDIO48H_OLD,
+        BOARD_CB_PCIDIO48H_NEW,
         BOARD_CB_PCIDIO96H,
         BOARD_NI_PCIDIO96,
         BOARD_NI_PCIDIO96B,
@@ -106,11 +107,16 @@ static const struct pci_8255_boardinfo pci_8255_boards[] = {
                 .dio_badr       = 2,
                 .n_8255         = 1,
         },
-        [BOARD_CB_PCIDIO48H] = {
+        [BOARD_CB_PCIDIO48H_OLD] = {
                 .name           = "cb_pci-dio48h",
                 .dio_badr       = 1,
                 .n_8255         = 2,
         },
+        [BOARD_CB_PCIDIO48H_NEW] = {
+                .name           = "cb_pci-dio48h",
+                .dio_badr       = 2,
+                .n_8255         = 2,
+        },
         [BOARD_CB_PCIDIO96H] = {
                 .name           = "cb_pci-dio96h",
                 .dio_badr       = 2,
@@ -263,7 +269,10 @@ static DEFINE_PCI_DEVICE_TABLE(pci_8255_pci_table) = {
         { PCI_VDEVICE(ADLINK, 0x7296), BOARD_ADLINK_PCI7296 },
         { PCI_VDEVICE(CB, 0x0028), BOARD_CB_PCIDIO24 },
         { PCI_VDEVICE(CB, 0x0014), BOARD_CB_PCIDIO24H },
-        { PCI_VDEVICE(CB, 0x000b), BOARD_CB_PCIDIO48H },
+        { PCI_DEVICE_SUB(PCI_VENDOR_ID_CB, 0x000b, 0x0000, 0x0000),
+          .driver_data = BOARD_CB_PCIDIO48H_OLD },
+        { PCI_DEVICE_SUB(PCI_VENDOR_ID_CB, 0x000b, PCI_VENDOR_ID_CB, 0x000b),
+          .driver_data = BOARD_CB_PCIDIO48H_NEW },
         { PCI_VDEVICE(CB, 0x0017), BOARD_CB_PCIDIO96H },
         { PCI_VDEVICE(NI, 0x0160), BOARD_NI_PCIDIO96 },
         { PCI_VDEVICE(NI, 0x1630), BOARD_NI_PCIDIO96B },
diff --git a/drivers/staging/iio/magnetometer/hmc5843.c b/drivers/staging/iio/magnetometer/hmc5843.c
index 99421f90d189..0485d7f39867 100644
--- a/drivers/staging/iio/magnetometer/hmc5843.c
+++ b/drivers/staging/iio/magnetometer/hmc5843.c
@@ -451,7 +451,12 @@ done:
                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
                         BIT(IIO_CHAN_INFO_SAMP_FREQ),                   \
                 .scan_index = idx,                                      \
-                .scan_type = IIO_ST('s', 16, 16, IIO_BE),               \
+                .scan_type = {                                          \
+                        .sign = 's',                                    \
+                        .realbits = 16,                                 \
+                        .storagebits = 16,                              \
+                        .endianness = IIO_BE,                           \
+                },                                                      \
         }
 
 static const struct iio_chan_spec hmc5843_channels[] = {
diff --git a/drivers/staging/imx-drm/imx-drm-core.c b/drivers/staging/imx-drm/imx-drm-core.c
index 6bd015ac9d68..96e4eee344ef 100644
--- a/drivers/staging/imx-drm/imx-drm-core.c
+++ b/drivers/staging/imx-drm/imx-drm-core.c
@@ -88,8 +88,9 @@ static int imx_drm_driver_unload(struct drm_device *drm)
 
         imx_drm_device_put();
 
-        drm_mode_config_cleanup(imxdrm->drm);
+        drm_vblank_cleanup(imxdrm->drm);
         drm_kms_helper_poll_fini(imxdrm->drm);
+        drm_mode_config_cleanup(imxdrm->drm);
 
         return 0;
 }
@@ -199,8 +200,8 @@ static void imx_drm_driver_preclose(struct drm_device *drm,
         if (!file->is_master)
                 return;
 
-        for (i = 0; i < 4; i++)
-                imx_drm_disable_vblank(drm , i);
+        for (i = 0; i < MAX_CRTC; i++)
+                imx_drm_disable_vblank(drm, i);
 }
 
 static const struct file_operations imx_drm_driver_fops = {
@@ -376,8 +377,6 @@ static int imx_drm_crtc_register(struct imx_drm_crtc *imx_drm_crtc)
         struct imx_drm_device *imxdrm = __imx_drm_device();
         int ret;
 
-        drm_crtc_init(imxdrm->drm, imx_drm_crtc->crtc,
-                        imx_drm_crtc->imx_drm_helper_funcs.crtc_funcs);
         ret = drm_mode_crtc_set_gamma_size(imx_drm_crtc->crtc, 256);
         if (ret)
                 return ret;
@@ -385,6 +384,9 @@ static int imx_drm_crtc_register(struct imx_drm_crtc *imx_drm_crtc)
         drm_crtc_helper_add(imx_drm_crtc->crtc,
                         imx_drm_crtc->imx_drm_helper_funcs.crtc_helper_funcs);
 
+        drm_crtc_init(imxdrm->drm, imx_drm_crtc->crtc,
+                        imx_drm_crtc->imx_drm_helper_funcs.crtc_funcs);
+
         drm_mode_group_reinit(imxdrm->drm);
 
         return 0;
@@ -428,11 +430,11 @@ static int imx_drm_driver_load(struct drm_device *drm, unsigned long flags)
         ret = drm_mode_group_init_legacy_group(imxdrm->drm,
                         &imxdrm->drm->primary->mode_group);
         if (ret)
-                goto err_init;
+                goto err_kms;
 
         ret = drm_vblank_init(imxdrm->drm, MAX_CRTC);
         if (ret)
-                goto err_init;
+                goto err_kms;
 
         /*
          * with vblank_disable_allowed = true, vblank interrupt will be disabled
@@ -441,12 +443,19 @@ static int imx_drm_driver_load(struct drm_device *drm, unsigned long flags)
          */
         imxdrm->drm->vblank_disable_allowed = true;
 
-        if (!imx_drm_device_get())
+        if (!imx_drm_device_get()) {
                 ret = -EINVAL;
+                goto err_vblank;
+        }
 
-        ret = 0;
+        mutex_unlock(&imxdrm->mutex);
+        return 0;
 
-err_init:
+err_vblank:
+        drm_vblank_cleanup(drm);
+err_kms:
+        drm_kms_helper_poll_fini(drm);
+        drm_mode_config_cleanup(drm);
         mutex_unlock(&imxdrm->mutex);
 
         return ret;
@@ -492,6 +501,15 @@ int imx_drm_add_crtc(struct drm_crtc *crtc,
 
         mutex_lock(&imxdrm->mutex);
 
+        /*
+         * The vblank arrays are dimensioned by MAX_CRTC - we can't
+         * pass IDs greater than this to those functions.
+         */
+        if (imxdrm->pipes >= MAX_CRTC) {
+                ret = -EINVAL;
+                goto err_busy;
+        }
+
         if (imxdrm->drm->open_count) {
                 ret = -EBUSY;
                 goto err_busy;
@@ -528,6 +546,7 @@ int imx_drm_add_crtc(struct drm_crtc *crtc,
         return 0;
 
 err_register:
+        list_del(&imx_drm_crtc->list);
         kfree(imx_drm_crtc);
 err_alloc:
 err_busy:
diff --git a/drivers/staging/imx-drm/imx-tve.c b/drivers/staging/imx-drm/imx-tve.c
index 680f4c8fa081..2c44fef8d58b 100644
--- a/drivers/staging/imx-drm/imx-tve.c
+++ b/drivers/staging/imx-drm/imx-tve.c
@@ -114,7 +114,6 @@ struct imx_tve {
         struct drm_encoder encoder;
         struct imx_drm_encoder *imx_drm_encoder;
         struct device *dev;
-        spinlock_t enable_lock; /* serializes tve_enable/disable */
         spinlock_t lock;        /* register lock */
         bool enabled;
         int mode;
@@ -146,10 +145,8 @@ __releases(&tve->lock)
 
 static void tve_enable(struct imx_tve *tve)
 {
-        unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&tve->enable_lock, flags);
         if (!tve->enabled) {
                 tve->enabled = true;
                 clk_prepare_enable(tve->clk);
@@ -169,23 +166,18 @@ static void tve_enable(struct imx_tve *tve)
                              TVE_CD_SM_IEN |
                              TVE_CD_LM_IEN |
                              TVE_CD_MON_END_IEN);
-
-        spin_unlock_irqrestore(&tve->enable_lock, flags);
 }
 
 static void tve_disable(struct imx_tve *tve)
 {
-        unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&tve->enable_lock, flags);
         if (tve->enabled) {
                 tve->enabled = false;
                 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG,
                                          TVE_IPU_CLK_EN | TVE_EN, 0);
                 clk_disable_unprepare(tve->clk);
         }
-        spin_unlock_irqrestore(&tve->enable_lock, flags);
 }
 
 static int tve_setup_tvout(struct imx_tve *tve)
@@ -601,7 +593,6 @@ static int imx_tve_probe(struct platform_device *pdev)
 
         tve->dev = &pdev->dev;
         spin_lock_init(&tve->lock);
-        spin_lock_init(&tve->enable_lock);
 
         ddc_node = of_parse_phandle(np, "ddc", 0);
         if (ddc_node) {
diff --git a/drivers/staging/imx-drm/ipu-v3/ipu-common.c b/drivers/staging/imx-drm/ipu-v3/ipu-common.c
index 7a22ce619ed2..97ca6924dbb3 100644
--- a/drivers/staging/imx-drm/ipu-v3/ipu-common.c
+++ b/drivers/staging/imx-drm/ipu-v3/ipu-common.c
@@ -996,35 +996,35 @@ static const struct ipu_platform_reg client_reg[] = {
         },
 };
 
+static DEFINE_MUTEX(ipu_client_id_mutex);
 static int ipu_client_id;
 
-static int ipu_add_subdevice_pdata(struct device *dev,
-                const struct ipu_platform_reg *reg)
-{
-        struct platform_device *pdev;
-
-        pdev = platform_device_register_data(dev, reg->name, ipu_client_id++,
-                        &reg->pdata, sizeof(struct ipu_platform_reg));
-
-        return PTR_ERR_OR_ZERO(pdev);
-}
-
 static int ipu_add_client_devices(struct ipu_soc *ipu)
 {
-        int ret;
-        int i;
+        struct device *dev = ipu->dev;
+        unsigned i;
+        int id, ret;
+
+        mutex_lock(&ipu_client_id_mutex);
+        id = ipu_client_id;
+        ipu_client_id += ARRAY_SIZE(client_reg);
+        mutex_unlock(&ipu_client_id_mutex);
 
         for (i = 0; i < ARRAY_SIZE(client_reg); i++) {
                 const struct ipu_platform_reg *reg = &client_reg[i];
-                ret = ipu_add_subdevice_pdata(ipu->dev, reg);
-                if (ret)
+                struct platform_device *pdev;
+
+                pdev = platform_device_register_data(dev, reg->name,
+                        id++, &reg->pdata, sizeof(reg->pdata));
+
+                if (IS_ERR(pdev))
                         goto err_register;
         }
 
         return 0;
 
 err_register:
-        platform_device_unregister_children(to_platform_device(ipu->dev));
+        platform_device_unregister_children(to_platform_device(dev));
 
         return ret;
 }
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index d70e9119e906..00867190413c 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -465,6 +465,7 @@ int iscsit_del_np(struct iscsi_np *np)
                  */
                 send_sig(SIGINT, np->np_thread, 1);
                 kthread_stop(np->np_thread);
+                np->np_thread = NULL;
         }
 
         np->np_transport->iscsit_free_np(np);
@@ -823,24 +824,22 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
         if (((hdr->flags & ISCSI_FLAG_CMD_READ) ||
              (hdr->flags & ISCSI_FLAG_CMD_WRITE)) && !hdr->data_length) {
                 /*
-                 * Vmware ESX v3.0 uses a modified Cisco Initiator (v3.4.2)
-                 * that adds support for RESERVE/RELEASE.  There is a bug
-                 * add with this new functionality that sets R/W bits when
-                 * neither CDB carries any READ or WRITE datapayloads.
+                 * From RFC-3720 Section 10.3.1:
+                 *
+                 * "Either or both of R and W MAY be 1 when either the
+                 *  Expected Data Transfer Length and/or Bidirectional Read
+                 *  Expected Data Transfer Length are 0"
+                 *
+                 * For this case, go ahead and clear the unnecssary bits
+                 * to avoid any confusion with ->data_direction.
                  */
-                if ((hdr->cdb[0] == 0x16) || (hdr->cdb[0] == 0x17)) {
-                        hdr->flags &= ~ISCSI_FLAG_CMD_READ;
-                        hdr->flags &= ~ISCSI_FLAG_CMD_WRITE;
-                        goto done;
-                }
+                hdr->flags &= ~ISCSI_FLAG_CMD_READ;
+                hdr->flags &= ~ISCSI_FLAG_CMD_WRITE;
 
-                pr_err("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE"
+                pr_warn("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE"
                         " set when Expected Data Transfer Length is 0 for"
-                        " CDB: 0x%02x. Bad iSCSI Initiator.\n", hdr->cdb[0]);
-                return iscsit_add_reject_cmd(cmd,
-                                             ISCSI_REASON_BOOKMARK_INVALID, buf);
+                        " CDB: 0x%02x, Fixing up flags\n", hdr->cdb[0]);
         }
-done:
 
         if (!(hdr->flags & ISCSI_FLAG_CMD_READ) &&
             !(hdr->flags & ISCSI_FLAG_CMD_WRITE) && (hdr->data_length != 0)) {
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index e3318edb233d..1c0088fe9e99 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -474,7 +474,8 @@ static ssize_t __iscsi_##prefix##_store_##name(				\
                                                                         \
         if (!capable(CAP_SYS_ADMIN))                                    \
                 return -EPERM;                                          \
-                                                                        \
+        if (count >= sizeof(auth->name))                                \
+                return -EINVAL;                                         \
         snprintf(auth->name, sizeof(auth->name), "%s", page);           \
         if (!strncmp("NULL", auth->name, 4))                            \
                 auth->naf_flags &= ~flags;                              \
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 4eb93b2b6473..e29279e6b577 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -1403,11 +1403,6 @@ old_sess_out:
 
 out:
         stop = kthread_should_stop();
-        if (!stop && signal_pending(current)) {
-                spin_lock_bh(&np->np_thread_lock);
-                stop = (np->np_thread_state == ISCSI_NP_THREAD_SHUTDOWN);
-                spin_unlock_bh(&np->np_thread_lock);
-        }
         /* Wait for another socket.. */
         if (!stop)
                 return 1;
@@ -1415,7 +1410,6 @@ exit:
         iscsi_stop_login_thread_timer(np);
         spin_lock_bh(&np->np_thread_lock);
         np->np_thread_state = ISCSI_NP_THREAD_EXIT;
-        np->np_thread = NULL;
         spin_unlock_bh(&np->np_thread_lock);
 
         return 0;
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 207b340498a3..d06de84b069b 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -1106,6 +1106,11 @@ int se_dev_set_block_size(struct se_device *dev, u32 block_size)
         dev->dev_attrib.block_size = block_size;
         pr_debug("dev[%p]: SE Device block_size changed to %u\n",
                         dev, block_size);
+
+        if (dev->dev_attrib.max_bytes_per_io)
+                dev->dev_attrib.hw_max_sectors =
+                        dev->dev_attrib.max_bytes_per_io / block_size;
+
         return 0;
 }
 
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 0e34cda3271e..78241a53b555 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -66,9 +66,8 @@ static int fd_attach_hba(struct se_hba *hba, u32 host_id)
         pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
                 " Target Core Stack %s\n", hba->hba_id, FD_VERSION,
                 TARGET_CORE_MOD_VERSION);
-        pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
-                " MaxSectors: %u\n",
-                hba->hba_id, fd_host->fd_host_id, FD_MAX_SECTORS);
+        pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",
+                hba->hba_id, fd_host->fd_host_id);
 
         return 0;
 }
@@ -220,7 +219,8 @@ static int fd_configure_device(struct se_device *dev)
         }
 
         dev->dev_attrib.hw_block_size = fd_dev->fd_block_size;
-        dev->dev_attrib.hw_max_sectors = FD_MAX_SECTORS;
+        dev->dev_attrib.max_bytes_per_io = FD_MAX_BYTES;
+        dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size;
         dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
 
         if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
diff --git a/drivers/target/target_core_file.h b/drivers/target/target_core_file.h
index 37ffc5bd2399..d7772c167685 100644
--- a/drivers/target/target_core_file.h
+++ b/drivers/target/target_core_file.h
@@ -7,7 +7,10 @@
 #define FD_DEVICE_QUEUE_DEPTH   32
 #define FD_MAX_DEVICE_QUEUE_DEPTH 128
 #define FD_BLOCKSIZE            512
-#define FD_MAX_SECTORS          2048
+/*
+ * Limited by the number of iovecs (2048) per vfs_[writev,readv] call
+ */
+#define FD_MAX_BYTES            8388608
 
 #define RRF_EMULATE_CDB         0x01
 #define RRF_GOT_LBA             0x02
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index f697f8baec54..2a573de19a9f 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -278,7 +278,6 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
         snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
         acl->se_tpg = tpg;
         acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
-        spin_lock_init(&acl->stats_lock);
         acl->dynamic_node_acl = 1;
 
         tpg->se_tpg_tfo->set_default_node_attributes(acl);
@@ -406,7 +405,6 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
         snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
         acl->se_tpg = tpg;
         acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
-        spin_lock_init(&acl->stats_lock);
 
         tpg->se_tpg_tfo->set_default_node_attributes(acl);
 
@@ -658,15 +656,9 @@ static int core_tpg_setup_virtual_lun0(struct se_portal_group *se_tpg)
         spin_lock_init(&lun->lun_sep_lock);
         init_completion(&lun->lun_ref_comp);
 
-        ret = percpu_ref_init(&lun->lun_ref, core_tpg_lun_ref_release);
-        if (ret < 0)
-                return ret;
-
         ret = core_tpg_post_addlun(se_tpg, lun, lun_access, dev);
-        if (ret < 0) {
-                percpu_ref_cancel_init(&lun->lun_ref);
+        if (ret < 0)
                 return ret;
-        }
 
         return 0;
 }
diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c
index 268b62768f2b..34aacaaae14a 100644
--- a/drivers/tty/n_tty.c
+++ b/drivers/tty/n_tty.c
@@ -93,6 +93,7 @@ struct n_tty_data {
         size_t canon_head;
         size_t echo_head;
         size_t echo_commit;
+        size_t echo_mark;
         DECLARE_BITMAP(char_map, 256);
 
         /* private to n_tty_receive_overrun (single-threaded) */
@@ -336,6 +337,7 @@ static void reset_buffer_flags(struct n_tty_data *ldata)
 {
         ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
         ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
+        ldata->echo_mark = 0;
         ldata->line_start = 0;
 
         ldata->erasing = 0;
@@ -787,6 +789,7 @@ static void commit_echoes(struct tty_struct *tty)
         size_t head;
 
         head = ldata->echo_head;
+        ldata->echo_mark = head;
         old = ldata->echo_commit - ldata->echo_tail;
 
         /* Process committed echoes if the accumulated # of bytes
@@ -811,10 +814,11 @@ static void process_echoes(struct tty_struct *tty)
         size_t echoed;
 
         if ((!L_ECHO(tty) && !L_ECHONL(tty)) ||
-            ldata->echo_commit == ldata->echo_tail)
+            ldata->echo_mark == ldata->echo_tail)
                 return;
 
         mutex_lock(&ldata->output_lock);
+        ldata->echo_commit = ldata->echo_mark;
         echoed = __process_echoes(tty);
         mutex_unlock(&ldata->output_lock);
 
@@ -822,6 +826,7 @@ static void process_echoes(struct tty_struct *tty)
                 tty->ops->flush_chars(tty);
 }
 
+/* NB: echo_mark and echo_head should be equivalent here */
 static void flush_echoes(struct tty_struct *tty)
 {
         struct n_tty_data *ldata = tty->disc_data;
diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index 4658e3e0ec42..06525f10e364 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -96,7 +96,8 @@ static void dw8250_serial_out(struct uart_port *p, int offset, int value)
         if (offset == UART_LCR) {
                 int tries = 1000;
                 while (tries--) {
-                        if (value == p->serial_in(p, UART_LCR))
+                        unsigned int lcr = p->serial_in(p, UART_LCR);
+                        if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
                                 return;
                         dw8250_force_idle(p);
                         writeb(value, p->membase + (UART_LCR << p->regshift));
@@ -132,7 +133,8 @@ static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
         if (offset == UART_LCR) {
                 int tries = 1000;
                 while (tries--) {
-                        if (value == p->serial_in(p, UART_LCR))
+                        unsigned int lcr = p->serial_in(p, UART_LCR);
+                        if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
                                 return;
                         dw8250_force_idle(p);
                         writel(value, p->membase + (UART_LCR << p->regshift));
@@ -455,6 +457,8 @@ MODULE_DEVICE_TABLE(of, dw8250_of_match);
 static const struct acpi_device_id dw8250_acpi_match[] = {
         { "INT33C4", 0 },
         { "INT33C5", 0 },
+        { "INT3434", 0 },
+        { "INT3435", 0 },
         { "80860F0A", 0 },
         { },
 };
diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c
index e46e9f3f19b9..f619ad5b5eae 100644
--- a/drivers/tty/serial/xilinx_uartps.c
+++ b/drivers/tty/serial/xilinx_uartps.c
@@ -240,6 +240,7 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
                                         continue;
                         }
 
+#ifdef SUPPORT_SYSRQ
                         /*
                          * uart_handle_sysrq_char() doesn't work if
                          * spinlocked, for some reason
@@ -253,6 +254,7 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
                                 }
                                 spin_lock(&port->lock);
                         }
+#endif
 
                         port->icount.rx++;
 
diff --git a/drivers/tty/tty_ldsem.c b/drivers/tty/tty_ldsem.c
index 22fad8ad5ac2..d8a55e87877f 100644
--- a/drivers/tty/tty_ldsem.c
+++ b/drivers/tty/tty_ldsem.c
@@ -86,11 +86,21 @@ static inline long ldsem_atomic_update(long delta, struct ld_semaphore *sem)
         return atomic_long_add_return(delta, (atomic_long_t *)&sem->count);
 }
 
+/*
+ * ldsem_cmpxchg() updates @*old with the last-known sem->count value.
+ * Returns 1 if count was successfully changed; @*old will have @new value.
+ * Returns 0 if count was not changed; @*old will have most recent sem->count
+ */
 static inline int ldsem_cmpxchg(long *old, long new, struct ld_semaphore *sem)
 {
-        long tmp = *old;
-        *old = atomic_long_cmpxchg(&sem->count, *old, new);
-        return *old == tmp;
+        long tmp = atomic_long_cmpxchg(&sem->count, *old, new);
+        if (tmp == *old) {
+                *old = new;
+                return 1;
+        } else {
+                *old = tmp;
+                return 0;
+        }
 }
 
 /*
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 5d8981c5235e..6e73f8cd60e5 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -642,6 +642,10 @@ static int ci_hdrc_probe(struct platform_device *pdev)
                         : CI_ROLE_GADGET;
         }
 
+        /* only update vbus status for peripheral */
+        if (ci->role == CI_ROLE_GADGET)
+                ci_handle_vbus_change(ci);
+
         ret = ci_role_start(ci, ci->role);
         if (ret) {
                 dev_err(dev, "can't start %s role\n", ci_role(ci)->name);
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index 59e6020ea753..526cd77563d8 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -88,7 +88,8 @@ static int host_start(struct ci_hdrc *ci)
         return ret;
 
 disable_reg:
-        regulator_disable(ci->platdata->reg_vbus);
+        if (ci->platdata->reg_vbus)
+                regulator_disable(ci->platdata->reg_vbus);
 
 put_hcd:
         usb_put_hcd(hcd);
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index b34c81969cba..69d20fbb38a2 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -1795,9 +1795,6 @@ static int udc_start(struct ci_hdrc *ci)
         pm_runtime_no_callbacks(&ci->gadget.dev);
         pm_runtime_enable(&ci->gadget.dev);
 
-        /* Update ci->vbus_active */
-        ci_handle_vbus_change(ci);
-
         return retval;
 
 destroy_eps:
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 4d387596f3f0..0b23a8639311 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -854,13 +854,11 @@ static int wdm_manage_power(struct usb_interface *intf, int on)
 {
         /* need autopm_get/put here to ensure the usbcore sees the new value */
         int rv = usb_autopm_get_interface(intf);
-        if (rv < 0)
-                goto err;
 
         intf->needs_remote_wakeup = on;
-        usb_autopm_put_interface(intf);
-err:
-        return rv;
+        if (!rv)
+                usb_autopm_put_interface(intf);
+        return 0;
 }
 
 static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 74f9cf02da07..a49217ae3533 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -455,9 +455,6 @@ static int dwc3_probe(struct platform_device *pdev)
         if (IS_ERR(regs))
                 return PTR_ERR(regs);
 
-        usb_phy_set_suspend(dwc->usb2_phy, 0);
-        usb_phy_set_suspend(dwc->usb3_phy, 0);
-
         spin_lock_init(&dwc->lock);
         platform_set_drvdata(pdev, dwc);
 
@@ -488,6 +485,9 @@ static int dwc3_probe(struct platform_device *pdev)
                 goto err0;
         }
 
+        usb_phy_set_suspend(dwc->usb2_phy, 0);
+        usb_phy_set_suspend(dwc->usb3_phy, 0);
+
         ret = dwc3_event_buffers_setup(dwc);
         if (ret) {
                 dev_err(dwc->dev, "failed to setup event buffers\n");
@@ -569,6 +569,8 @@ err2:
         dwc3_event_buffers_cleanup(dwc);
 
 err1:
+        usb_phy_set_suspend(dwc->usb2_phy, 1);
+        usb_phy_set_suspend(dwc->usb3_phy, 1);
         dwc3_core_exit(dwc);
 
 err0:
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 418444ebb1b8..8c356af79409 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -136,23 +136,27 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         struct ohci_hcd *ohci;
         int retval;
         struct usb_hcd *hcd = NULL;
-
-        if (pdev->num_resources != 2) {
-                pr_debug("hcd probe: invalid num_resources");
-                return -ENODEV;
+        struct device *dev = &pdev->dev;
+        struct resource *res;
+        int irq;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(dev, "hcd probe: missing memory resource\n");
+                return -ENXIO;
         }
 
-        if ((pdev->resource[0].flags != IORESOURCE_MEM)
-                        || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
-                pr_debug("hcd probe: invalid resource type\n");
-                return -ENODEV;
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_dbg(dev, "hcd probe: missing irq resource\n");
+                return irq;
         }
 
         hcd = usb_create_hcd(driver, &pdev->dev, "at91");
         if (!hcd)
                 return -ENOMEM;
-        hcd->rsrc_start = pdev->resource[0].start;
-        hcd->rsrc_len = resource_size(&pdev->resource[0]);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 pr_debug("request_mem_region failed\n");
@@ -199,7 +203,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         ohci->num_ports = board->ports;
         at91_start_hc(pdev);
 
-        retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index b8dffd59eb25..73f5208714a4 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -128,7 +128,12 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  * any other sleep) on Haswell machines with LPT and LPT-LP
                  * with the new Intel BIOS
                  */
-                xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
+                /* Limit the quirk to only known vendors, as this triggers
+                 * yet another BIOS bug on some other machines
+                 * https://bugzilla.kernel.org/show_bug.cgi?id=66171
+                 */
+                if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP)
+                        xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index 08e2f39027ec..2b41c636a52a 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -19,8 +19,9 @@ config AB8500_USB
           in host mode, low speed.
 
 config FSL_USB2_OTG
-        bool "Freescale USB OTG Transceiver Driver"
+        tristate "Freescale USB OTG Transceiver Driver"
         depends on USB_EHCI_FSL && USB_FSL_USB2 && PM_RUNTIME
+        depends on USB
         select USB_OTG
         select USB_PHY
         help
@@ -29,6 +30,7 @@ config FSL_USB2_OTG
 config ISP1301_OMAP
         tristate "Philips ISP1301 with OMAP OTG"
         depends on I2C && ARCH_OMAP_OTG
+        depends on USB
         select USB_PHY
         help
           If you say yes here you get support for the Philips ISP1301
diff --git a/drivers/usb/phy/phy-tegra-usb.c b/drivers/usb/phy/phy-tegra-usb.c
index 82232acf1ab6..bbe4f8e6e8d7 100644
--- a/drivers/usb/phy/phy-tegra-usb.c
+++ b/drivers/usb/phy/phy-tegra-usb.c
@@ -876,7 +876,7 @@ static int utmi_phy_probe(struct tegra_usb_phy *tegra_phy,
 
         tegra_phy->pad_regs = devm_ioremap(&pdev->dev, res->start,
                 resource_size(res));
-        if (!tegra_phy->regs) {
+        if (!tegra_phy->pad_regs) {
                 dev_err(&pdev->dev, "Failed to remap UTMI Pad regs\n");
                 return -ENOMEM;
         }
diff --git a/drivers/usb/phy/phy-twl6030-usb.c b/drivers/usb/phy/phy-twl6030-usb.c
index 30e8a61552d4..bad57ce77ba5 100644
--- a/drivers/usb/phy/phy-twl6030-usb.c
+++ b/drivers/usb/phy/phy-twl6030-usb.c
@@ -127,7 +127,8 @@ static inline int twl6030_writeb(struct twl6030_usb *twl, u8 module,
 
 static inline u8 twl6030_readb(struct twl6030_usb *twl, u8 module, u8 address)
 {
-        u8 data, ret = 0;
+        u8 data;
+        int ret;
 
         ret = twl_i2c_read_u8(module, &data, address);
         if (ret >= 0)
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 496b7e39d5be..cc7a24154490 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -251,6 +251,7 @@ static void option_instat_callback(struct urb *urb);
 #define ZTE_PRODUCT_MF628                       0x0015
 #define ZTE_PRODUCT_MF626                       0x0031
 #define ZTE_PRODUCT_MC2718                      0xffe8
+#define ZTE_PRODUCT_AC2726                      0xfff1
 
 #define BENQ_VENDOR_ID                          0x04a5
 #define BENQ_PRODUCT_H10                        0x4068
@@ -1453,6 +1454,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x02, 0x01) },
         { USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x02, 0x05) },
         { USB_VENDOR_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff, 0x86, 0x10) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
 
         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
         { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
diff --git a/drivers/usb/serial/zte_ev.c b/drivers/usb/serial/zte_ev.c
index fca4c752a4ed..eae2c873b39f 100644
--- a/drivers/usb/serial/zte_ev.c
+++ b/drivers/usb/serial/zte_ev.c
@@ -281,8 +281,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x19d2, 0xfffd) },
         { USB_DEVICE(0x19d2, 0xfffc) },
         { USB_DEVICE(0x19d2, 0xfffb) },
-        /* AC2726, AC8710_V3 */
-        { USB_DEVICE_AND_INTERFACE_INFO(0x19d2, 0xfff1, 0xff, 0xff, 0xff) },
+        /* AC8710_V3 */
         { USB_DEVICE(0x19d2, 0xfff6) },
         { USB_DEVICE(0x19d2, 0xfff7) },
         { USB_DEVICE(0x19d2, 0xfff8) },
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index c444654fc33f..5c4a95b516cf 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -285,7 +285,7 @@ static void update_balloon_size(struct virtio_balloon *vb)
 {
         __le32 actual = cpu_to_le32(vb->num_pages);
 
-        virtio_cwrite(vb->vdev, struct virtio_balloon_config, num_pages,
+        virtio_cwrite(vb->vdev, struct virtio_balloon_config, actual,
                       &actual);
 }
 
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 55ea73f7c70b..4c02e2b94103 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -350,17 +350,19 @@ static enum bp_state increase_reservation(unsigned long nr_pages)
 
                 pfn = page_to_pfn(page);
 
-                set_phys_to_machine(pfn, frame_list[i]);
-
 #ifdef CONFIG_XEN_HAVE_PVMMU
-                /* Link back into the page tables if not highmem. */
-                if (xen_pv_domain() && !PageHighMem(page)) {
-                        int ret;
-                        ret = HYPERVISOR_update_va_mapping(
-                                (unsigned long)__va(pfn << PAGE_SHIFT),
-                                mfn_pte(frame_list[i], PAGE_KERNEL),
-                                0);
-                        BUG_ON(ret);
+                if (!xen_feature(XENFEAT_auto_translated_physmap)) {
+                        set_phys_to_machine(pfn, frame_list[i]);
+
+                        /* Link back into the page tables if not highmem. */
+                        if (!PageHighMem(page)) {
+                                int ret;
+                                ret = HYPERVISOR_update_va_mapping(
+                                                (unsigned long)__va(pfn << PAGE_SHIFT),
+                                                mfn_pte(frame_list[i], PAGE_KERNEL),
+                                                0);
+                                BUG_ON(ret);
+                        }
                 }
 #endif
 
@@ -378,7 +380,6 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
         enum bp_state state = BP_DONE;
         unsigned long  pfn, i;
         struct page   *page;
-        struct page   *scratch_page;
         int ret;
         struct xen_memory_reservation reservation = {
                 .address_bits = 0,
@@ -411,27 +412,29 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
 
                 scrub_page(page);
 
+#ifdef CONFIG_XEN_HAVE_PVMMU
                 /*
                  * Ballooned out frames are effectively replaced with
                  * a scratch frame.  Ensure direct mappings and the
                  * p2m are consistent.
                  */
-                scratch_page = get_balloon_scratch_page();
-#ifdef CONFIG_XEN_HAVE_PVMMU
-                if (xen_pv_domain() && !PageHighMem(page)) {
-                        ret = HYPERVISOR_update_va_mapping(
-                                (unsigned long)__va(pfn << PAGE_SHIFT),
-                                pfn_pte(page_to_pfn(scratch_page),
-                                        PAGE_KERNEL_RO), 0);
-                        BUG_ON(ret);
-                }
-#endif
                 if (!xen_feature(XENFEAT_auto_translated_physmap)) {
                         unsigned long p;
+                        struct page   *scratch_page = get_balloon_scratch_page();
+
+                        if (!PageHighMem(page)) {
+                                ret = HYPERVISOR_update_va_mapping(
+                                                (unsigned long)__va(pfn << PAGE_SHIFT),
+                                                pfn_pte(page_to_pfn(scratch_page),
+                                                        PAGE_KERNEL_RO), 0);
+                                BUG_ON(ret);
+                        }
                         p = page_to_pfn(scratch_page);
                         __set_phys_to_machine(pfn, pfn_to_mfn(p));
+
+                        put_balloon_scratch_page();
                 }
-                put_balloon_scratch_page();
+#endif
 
                 balloon_append(pfn_to_page(pfn));
         }
@@ -627,15 +630,17 @@ static int __init balloon_init(void)
         if (!xen_domain())
                 return -ENODEV;
 
-        for_each_online_cpu(cpu)
-        {
-                per_cpu(balloon_scratch_page, cpu) = alloc_page(GFP_KERNEL);
-                if (per_cpu(balloon_scratch_page, cpu) == NULL) {
-                        pr_warn("Failed to allocate balloon_scratch_page for cpu %d\n", cpu);
-                        return -ENOMEM;
+        if (!xen_feature(XENFEAT_auto_translated_physmap)) {
+                for_each_online_cpu(cpu)
+                {
+                        per_cpu(balloon_scratch_page, cpu) = alloc_page(GFP_KERNEL);
+                        if (per_cpu(balloon_scratch_page, cpu) == NULL) {
+                                pr_warn("Failed to allocate balloon_scratch_page for cpu %d\n", cpu);
+                                return -ENOMEM;
+                        }
                 }
+                register_cpu_notifier(&balloon_cpu_notifier);
         }
-        register_cpu_notifier(&balloon_cpu_notifier);
 
         pr_info("Initialising balloon driver\n");
 
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index 028387192b60..aa846a48f400 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -1176,7 +1176,8 @@ static int gnttab_setup(void)
                 gnttab_shared.addr = xen_remap(xen_hvm_resume_frames,
                                                 PAGE_SIZE * max_nr_gframes);
                 if (gnttab_shared.addr == NULL) {
-                        pr_warn("Failed to ioremap gnttab share frames!\n");
+                        pr_warn("Failed to ioremap gnttab share frames (addr=0x%08lx)!\n",
+                                        xen_hvm_resume_frames);
                         return -ENOMEM;
                 }
         }
diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c
index 8e74590fa1bb..569a13b9e856 100644
--- a/drivers/xen/privcmd.c
+++ b/drivers/xen/privcmd.c
@@ -533,12 +533,17 @@ static void privcmd_close(struct vm_area_struct *vma)
 {
         struct page **pages = vma->vm_private_data;
         int numpgs = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
+        int rc;
 
         if (!xen_feature(XENFEAT_auto_translated_physmap) || !numpgs || !pages)
                 return;
 
-        xen_unmap_domain_mfn_range(vma, numpgs, pages);
-        free_xenballooned_pages(numpgs, pages);
+        rc = xen_unmap_domain_mfn_range(vma, numpgs, pages);
+        if (rc == 0)
+                free_xenballooned_pages(numpgs, pages);
+        else
+                pr_crit("unable to unmap MFN range: leaking %d pages. rc=%d\n",
+                        numpgs, rc);
         kfree(pages);
 }
 
diff --git a/fs/aio.c b/fs/aio.c
index 6efb7f6cb22e..062a5f6a1448 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -244,9 +244,14 @@ static void aio_free_ring(struct kioctx *ctx)
         int i;
 
         for (i = 0; i < ctx->nr_pages; i++) {
+                struct page *page;
                 pr_debug("pid(%d) [%d] page->count=%d\n", current->pid, i,
                                 page_count(ctx->ring_pages[i]));
-                put_page(ctx->ring_pages[i]);
+                page = ctx->ring_pages[i];
+                if (!page)
+                        continue;
+                ctx->ring_pages[i] = NULL;
+                put_page(page);
         }
 
         put_aio_ring_file(ctx);
@@ -280,18 +285,38 @@ static int aio_migratepage(struct address_space *mapping, struct page *new,
         unsigned long flags;
         int rc;
 
+        rc = 0;
+
+        /* Make sure the old page hasn't already been changed */
+        spin_lock(&mapping->private_lock);
+        ctx = mapping->private_data;
+        if (ctx) {
+                pgoff_t idx;
+                spin_lock_irqsave(&ctx->completion_lock, flags);
+                idx = old->index;
+                if (idx < (pgoff_t)ctx->nr_pages) {
+                        if (ctx->ring_pages[idx] != old)
+                                rc = -EAGAIN;
+                } else
+                        rc = -EINVAL;
+                spin_unlock_irqrestore(&ctx->completion_lock, flags);
+        } else
+                rc = -EINVAL;
+        spin_unlock(&mapping->private_lock);
+
+        if (rc != 0)
+                return rc;
+
         /* Writeback must be complete */
         BUG_ON(PageWriteback(old));
-        put_page(old);
+        get_page(new);
 
-        rc = migrate_page_move_mapping(mapping, new, old, NULL, mode);
+        rc = migrate_page_move_mapping(mapping, new, old, NULL, mode, 1);
         if (rc != MIGRATEPAGE_SUCCESS) {
-                get_page(old);
+                put_page(new);
                 return rc;
         }
 
-        get_page(new);
-
         /* We can potentially race against kioctx teardown here.  Use the
          * address_space's private data lock to protect the mapping's
          * private_data.
@@ -303,13 +328,24 @@ static int aio_migratepage(struct address_space *mapping, struct page *new,
                 spin_lock_irqsave(&ctx->completion_lock, flags);
                 migrate_page_copy(new, old);
                 idx = old->index;
-                if (idx < (pgoff_t)ctx->nr_pages)
-                        ctx->ring_pages[idx] = new;
+                if (idx < (pgoff_t)ctx->nr_pages) {
+                        /* And only do the move if things haven't changed */
+                        if (ctx->ring_pages[idx] == old)
+                                ctx->ring_pages[idx] = new;
+                        else
+                                rc = -EAGAIN;
+                } else
+                        rc = -EINVAL;
                 spin_unlock_irqrestore(&ctx->completion_lock, flags);
         } else
                 rc = -EBUSY;
         spin_unlock(&mapping->private_lock);
 
+        if (rc == MIGRATEPAGE_SUCCESS)
+                put_page(old);
+        else
+                put_page(new);
+
         return rc;
 }
 #endif
@@ -326,7 +362,7 @@ static int aio_setup_ring(struct kioctx *ctx)
         struct aio_ring *ring;
         unsigned nr_events = ctx->max_reqs;
         struct mm_struct *mm = current->mm;
-        unsigned long size, populate;
+        unsigned long size, unused;
         int nr_pages;
         int i;
         struct file *file;
@@ -347,6 +383,20 @@ static int aio_setup_ring(struct kioctx *ctx)
                 return -EAGAIN;
         }
 
+        ctx->aio_ring_file = file;
+        nr_events = (PAGE_SIZE * nr_pages - sizeof(struct aio_ring))
+                        / sizeof(struct io_event);
+
+        ctx->ring_pages = ctx->internal_pages;
+        if (nr_pages > AIO_RING_PAGES) {
+                ctx->ring_pages = kcalloc(nr_pages, sizeof(struct page *),
+                                          GFP_KERNEL);
+                if (!ctx->ring_pages) {
+                        put_aio_ring_file(ctx);
+                        return -ENOMEM;
+                }
+        }
+
         for (i = 0; i < nr_pages; i++) {
                 struct page *page;
                 page = find_or_create_page(file->f_inode->i_mapping,
@@ -358,19 +408,14 @@ static int aio_setup_ring(struct kioctx *ctx)
                 SetPageUptodate(page);
                 SetPageDirty(page);
                 unlock_page(page);
+
+                ctx->ring_pages[i] = page;
         }
-        ctx->aio_ring_file = file;
-        nr_events = (PAGE_SIZE * nr_pages - sizeof(struct aio_ring))
-                        / sizeof(struct io_event);
+        ctx->nr_pages = i;
 
-        ctx->ring_pages = ctx->internal_pages;
-        if (nr_pages > AIO_RING_PAGES) {
-                ctx->ring_pages = kcalloc(nr_pages, sizeof(struct page *),
-                                          GFP_KERNEL);
-                if (!ctx->ring_pages) {
-                        put_aio_ring_file(ctx);
-                        return -ENOMEM;
-                }
+        if (unlikely(i != nr_pages)) {
+                aio_free_ring(ctx);
+                return -EAGAIN;
         }
 
         ctx->mmap_size = nr_pages * PAGE_SIZE;
@@ -379,9 +424,9 @@ static int aio_setup_ring(struct kioctx *ctx)
         down_write(&mm->mmap_sem);
         ctx->mmap_base = do_mmap_pgoff(ctx->aio_ring_file, 0, ctx->mmap_size,
                                        PROT_READ | PROT_WRITE,
-                                       MAP_SHARED | MAP_POPULATE, 0, &populate);
+                                       MAP_SHARED, 0, &unused);
+        up_write(&mm->mmap_sem);
         if (IS_ERR((void *)ctx->mmap_base)) {
-                up_write(&mm->mmap_sem);
                 ctx->mmap_size = 0;
                 aio_free_ring(ctx);
                 return -EAGAIN;
@@ -389,27 +434,6 @@ static int aio_setup_ring(struct kioctx *ctx)
 
         pr_debug("mmap address: 0x%08lx\n", ctx->mmap_base);
 
-        /* We must do this while still holding mmap_sem for write, as we
-         * need to be protected against userspace attempting to mremap()
-         * or munmap() the ring buffer.
-         */
-        ctx->nr_pages = get_user_pages(current, mm, ctx->mmap_base, nr_pages,
-                                       1, 0, ctx->ring_pages, NULL);
-
-        /* Dropping the reference here is safe as the page cache will hold
-         * onto the pages for us.  It is also required so that page migration
-         * can unmap the pages and get the right reference count.
-         */
-        for (i = 0; i < ctx->nr_pages; i++)
-                put_page(ctx->ring_pages[i]);
-
-        up_write(&mm->mmap_sem);
-
-        if (unlikely(ctx->nr_pages != nr_pages)) {
-                aio_free_ring(ctx);
-                return -EAGAIN;
-        }
-
         ctx->user_id = ctx->mmap_base;
         ctx->nr_events = nr_events; /* trusted copy */
 
@@ -652,7 +676,8 @@ static struct kioctx *ioctx_alloc(unsigned nr_events)
         aio_nr += ctx->max_reqs;
         spin_unlock(&aio_nr_lock);
 
-        percpu_ref_get(&ctx->users); /* io_setup() will drop this ref */
+        percpu_ref_get(&ctx->users);    /* io_setup() will drop this ref */
+        percpu_ref_get(&ctx->reqs);     /* free_ioctx_users() will drop this */
 
         err = ioctx_add_table(ctx, mm);
         if (err)
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 1e561c059539..ec3ba43b9faa 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -210,9 +210,13 @@ static int readpage_nounlock(struct file *filp, struct page *page)
         if (err < 0) {
                 SetPageError(page);
                 goto out;
-        } else if (err < PAGE_CACHE_SIZE) {
+        } else {
+                if (err < PAGE_CACHE_SIZE) {
                 /* zero fill remainder of page */
-                zero_user_segment(page, err, PAGE_CACHE_SIZE);
+                        zero_user_segment(page, err, PAGE_CACHE_SIZE);
+                } else {
+                        flush_dcache_page(page);
+                }
         }
         SetPageUptodate(page);
 
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 9a8e396aed89..278fd2891288 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -978,7 +978,6 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
         struct ceph_mds_reply_inode *ininfo;
         struct ceph_vino vino;
         struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
-        int i = 0;
         int err = 0;
 
         dout("fill_trace %p is_dentry %d is_target %d\n", req,
@@ -1039,6 +1038,29 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                 }
         }
 
+        if (rinfo->head->is_target) {
+                vino.ino = le64_to_cpu(rinfo->targeti.in->ino);
+                vino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
+
+                in = ceph_get_inode(sb, vino);
+                if (IS_ERR(in)) {
+                        err = PTR_ERR(in);
+                        goto done;
+                }
+                req->r_target_inode = in;
+
+                err = fill_inode(in, &rinfo->targeti, NULL,
+                                session, req->r_request_started,
+                                (le32_to_cpu(rinfo->head->result) == 0) ?
+                                req->r_fmode : -1,
+                                &req->r_caps_reservation);
+                if (err < 0) {
+                        pr_err("fill_inode badness %p %llx.%llx\n",
+                                in, ceph_vinop(in));
+                        goto done;
+                }
+        }
+
         /*
          * ignore null lease/binding on snapdir ENOENT, or else we
          * will have trouble splicing in the virtual snapdir later
@@ -1108,7 +1130,6 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                              ceph_dentry(req->r_old_dentry)->offset);
 
                         dn = req->r_old_dentry;  /* use old_dentry */
-                        in = dn->d_inode;
                 }
 
                 /* null dentry? */
@@ -1130,44 +1151,28 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                 }
 
                 /* attach proper inode */
-                ininfo = rinfo->targeti.in;
-                vino.ino = le64_to_cpu(ininfo->ino);
-                vino.snap = le64_to_cpu(ininfo->snapid);
-                in = dn->d_inode;
-                if (!in) {
-                        in = ceph_get_inode(sb, vino);
-                        if (IS_ERR(in)) {
-                                pr_err("fill_trace bad get_inode "
-                                       "%llx.%llx\n", vino.ino, vino.snap);
-                                err = PTR_ERR(in);
-                                d_drop(dn);
-                                goto done;
-                        }
+                if (!dn->d_inode) {
+                        ihold(in);
                         dn = splice_dentry(dn, in, &have_lease, true);
                         if (IS_ERR(dn)) {
                                 err = PTR_ERR(dn);
                                 goto done;
                         }
                         req->r_dentry = dn;  /* may have spliced */
-                        ihold(in);
-                } else if (ceph_ino(in) == vino.ino &&
-                           ceph_snap(in) == vino.snap) {
-                        ihold(in);
-                } else {
+                } else if (dn->d_inode && dn->d_inode != in) {
                         dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
-                             dn, in, ceph_ino(in), ceph_snap(in),
-                             vino.ino, vino.snap);
+                             dn, dn->d_inode, ceph_vinop(dn->d_inode),
+                             ceph_vinop(in));
                         have_lease = false;
-                        in = NULL;
                 }
 
                 if (have_lease)
                         update_dentry_lease(dn, rinfo->dlease, session,
                                             req->r_request_started);
                 dout(" final dn %p\n", dn);
-                i++;
-        } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
-                   req->r_op == CEPH_MDS_OP_MKSNAP) && !req->r_aborted) {
+        } else if (!req->r_aborted &&
+                   (req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
+                    req->r_op == CEPH_MDS_OP_MKSNAP)) {
                 struct dentry *dn = req->r_dentry;
 
                 /* fill out a snapdir LOOKUPSNAP dentry */
@@ -1177,52 +1182,15 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                 ininfo = rinfo->targeti.in;
                 vino.ino = le64_to_cpu(ininfo->ino);
                 vino.snap = le64_to_cpu(ininfo->snapid);
-                in = ceph_get_inode(sb, vino);
-                if (IS_ERR(in)) {
-                        pr_err("fill_inode get_inode badness %llx.%llx\n",
-                               vino.ino, vino.snap);
-                        err = PTR_ERR(in);
-                        d_delete(dn);
-                        goto done;
-                }
                 dout(" linking snapped dir %p to dn %p\n", in, dn);
+                ihold(in);
                 dn = splice_dentry(dn, in, NULL, true);
                 if (IS_ERR(dn)) {
                         err = PTR_ERR(dn);
                         goto done;
                 }
                 req->r_dentry = dn;  /* may have spliced */
-                ihold(in);
-                rinfo->head->is_dentry = 1;  /* fool notrace handlers */
-        }
-
-        if (rinfo->head->is_target) {
-                vino.ino = le64_to_cpu(rinfo->targeti.in->ino);
-                vino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
-
-                if (in == NULL || ceph_ino(in) != vino.ino ||
-                    ceph_snap(in) != vino.snap) {
-                        in = ceph_get_inode(sb, vino);
-                        if (IS_ERR(in)) {
-                                err = PTR_ERR(in);
-                                goto done;
-                        }
-                }
-                req->r_target_inode = in;
-
-                err = fill_inode(in,
-                                 &rinfo->targeti, NULL,
-                                 session, req->r_request_started,
-                                 (le32_to_cpu(rinfo->head->result) == 0) ?
-                                 req->r_fmode : -1,
-                                 &req->r_caps_reservation);
-                if (err < 0) {
-                        pr_err("fill_inode badness %p %llx.%llx\n",
-                               in, ceph_vinop(in));
-                        goto done;
-                }
         }
-
 done:
         dout("fill_trace done err=%d\n", err);
         return err;
@@ -1272,7 +1240,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
         struct qstr dname;
         struct dentry *dn;
         struct inode *in;
-        int err = 0, i;
+        int err = 0, ret, i;
         struct inode *snapdir = NULL;
         struct ceph_mds_request_head *rhead = req->r_request->front.iov_base;
         struct ceph_dentry_info *di;
@@ -1305,6 +1273,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                         ceph_fill_dirfrag(parent->d_inode, rinfo->dir_dir);
         }
 
+        /* FIXME: release caps/leases if error occurs */
         for (i = 0; i < rinfo->dir_nr; i++) {
                 struct ceph_vino vino;
 
@@ -1329,9 +1298,10 @@ retry_lookup:
                                 err = -ENOMEM;
                                 goto out;
                         }
-                        err = ceph_init_dentry(dn);
-                        if (err < 0) {
+                        ret = ceph_init_dentry(dn);
+                        if (ret < 0) {
                                 dput(dn);
+                                err = ret;
                                 goto out;
                         }
                 } else if (dn->d_inode &&
@@ -1351,9 +1321,6 @@ retry_lookup:
                         spin_unlock(&parent->d_lock);
                 }
 
-                di = dn->d_fsdata;
-                di->offset = ceph_make_fpos(frag, i + r_readdir_offset);
-
                 /* inode */
                 if (dn->d_inode) {
                         in = dn->d_inode;
@@ -1366,26 +1333,39 @@ retry_lookup:
                                 err = PTR_ERR(in);
                                 goto out;
                         }
-                        dn = splice_dentry(dn, in, NULL, false);
-                        if (IS_ERR(dn))
-                                dn = NULL;
                 }
 
                 if (fill_inode(in, &rinfo->dir_in[i], NULL, session,
                                req->r_request_started, -1,
                                &req->r_caps_reservation) < 0) {
                         pr_err("fill_inode badness on %p\n", in);
+                        if (!dn->d_inode)
+                                iput(in);
+                        d_drop(dn);
                         goto next_item;
                 }
-                if (dn)
-                        update_dentry_lease(dn, rinfo->dir_dlease[i],
-                                            req->r_session,
-                                            req->r_request_started);
+
+                if (!dn->d_inode) {
+                        dn = splice_dentry(dn, in, NULL, false);
+                        if (IS_ERR(dn)) {
+                                err = PTR_ERR(dn);
+                                dn = NULL;
+                                goto next_item;
+                        }
+                }
+
+                di = dn->d_fsdata;
+                di->offset = ceph_make_fpos(frag, i + r_readdir_offset);
+
+                update_dentry_lease(dn, rinfo->dir_dlease[i],
+                                    req->r_session,
+                                    req->r_request_started);
 next_item:
                 if (dn)
                         dput(dn);
         }
-        req->r_did_prepopulate = true;
+        if (err == 0)
+                req->r_did_prepopulate = true;
 
 out:
         if (snapdir) {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 288534920fe5..20d6697bd638 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1493,6 +1493,7 @@ static ssize_t ext2_quota_write(struct super_block *sb, int type,
                                 sb->s_blocksize - offset : towrite;
 
                 tmp_bh.b_state = 0;
+                tmp_bh.b_size = sb->s_blocksize;
                 err = ext2_get_block(inode, blk, &tmp_bh, 1);
                 if (err < 0)
                         goto out;
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index e6185031c1cc..ece55565b9cd 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -268,6 +268,16 @@ struct ext4_io_submit {
 /* Translate # of blks to # of clusters */
 #define EXT4_NUM_B2C(sbi, blks) (((blks) + (sbi)->s_cluster_ratio - 1) >> \
                                  (sbi)->s_cluster_bits)
+/* Mask out the low bits to get the starting block of the cluster */
+#define EXT4_PBLK_CMASK(s, pblk) ((pblk) &                              \
+                                  ~((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
+#define EXT4_LBLK_CMASK(s, lblk) ((lblk) &                              \
+                                  ~((ext4_lblk_t) (s)->s_cluster_ratio - 1))
+/* Get the cluster offset */
+#define EXT4_PBLK_COFF(s, pblk) ((pblk) &                               \
+                                 ((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
+#define EXT4_LBLK_COFF(s, lblk) ((lblk) &                               \
+                                 ((ext4_lblk_t) (s)->s_cluster_ratio - 1))
 
 /*
  * Structure of a blocks group descriptor
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index 17ac112ab101..3fe29de832c8 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -259,6 +259,15 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
                 if (WARN_ON_ONCE(err)) {
                         ext4_journal_abort_handle(where, line, __func__, bh,
                                                   handle, err);
+                        ext4_error_inode(inode, where, line,
+                                         bh->b_blocknr,
+                                         "journal_dirty_metadata failed: "
+                                         "handle type %u started at line %u, "
+                                         "credits %u/%u, errcode %d",
+                                         handle->h_type,
+                                         handle->h_line_no,
+                                         handle->h_requested_credits,
+                                         handle->h_buffer_credits, err);
                 }
         } else {
                 if (inode)
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 35f65cf4f318..4410cc3d6ee2 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -360,8 +360,10 @@ static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
 {
         ext4_fsblk_t block = ext4_ext_pblock(ext);
         int len = ext4_ext_get_actual_len(ext);
+        ext4_lblk_t lblock = le32_to_cpu(ext->ee_block);
+        ext4_lblk_t last = lblock + len - 1;
 
-        if (len == 0)
+        if (lblock > last)
                 return 0;
         return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
 }
@@ -387,11 +389,26 @@ static int ext4_valid_extent_entries(struct inode *inode,
         if (depth == 0) {
                 /* leaf entries */
                 struct ext4_extent *ext = EXT_FIRST_EXTENT(eh);
+                struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
+                ext4_fsblk_t pblock = 0;
+                ext4_lblk_t lblock = 0;
+                ext4_lblk_t prev = 0;
+                int len = 0;
                 while (entries) {
                         if (!ext4_valid_extent(inode, ext))
                                 return 0;
+
+                        /* Check for overlapping extents */
+                        lblock = le32_to_cpu(ext->ee_block);
+                        len = ext4_ext_get_actual_len(ext);
+                        if ((lblock <= prev) && prev) {
+                                pblock = ext4_ext_pblock(ext);
+                                es->s_last_error_block = cpu_to_le64(pblock);
+                                return 0;
+                        }
                         ext++;
                         entries--;
+                        prev = lblock + len - 1;
                 }
         } else {
                 struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh);
@@ -1834,8 +1851,7 @@ static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi,
         depth = ext_depth(inode);
         if (!path[depth].p_ext)
                 goto out;
-        b2 = le32_to_cpu(path[depth].p_ext->ee_block);
-        b2 &= ~(sbi->s_cluster_ratio - 1);
+        b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block));
 
         /*
          * get the next allocated block if the extent in the path
@@ -1845,7 +1861,7 @@ static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi,
                 b2 = ext4_ext_next_allocated_block(path);
                 if (b2 == EXT_MAX_BLOCKS)
                         goto out;
-                b2 &= ~(sbi->s_cluster_ratio - 1);
+                b2 = EXT4_LBLK_CMASK(sbi, b2);
         }
 
         /* check for wrap through zero on extent logical start block*/
@@ -2504,7 +2520,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
                  * extent, we have to mark the cluster as used (store negative
                  * cluster number in partial_cluster).
                  */
-                unaligned = pblk & (sbi->s_cluster_ratio - 1);
+                unaligned = EXT4_PBLK_COFF(sbi, pblk);
                 if (unaligned && (ee_len == num) &&
                     (*partial_cluster != -((long long)EXT4_B2C(sbi, pblk))))
                         *partial_cluster = EXT4_B2C(sbi, pblk);
@@ -2598,7 +2614,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
                          * accidentally freeing it later on
                          */
                         pblk = ext4_ext_pblock(ex);
-                        if (pblk & (sbi->s_cluster_ratio - 1))
+                        if (EXT4_PBLK_COFF(sbi, pblk))
                                 *partial_cluster =
                                         -((long long)EXT4_B2C(sbi, pblk));
                         ex--;
@@ -3753,7 +3769,7 @@ int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk)
 {
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         ext4_lblk_t lblk_start, lblk_end;
-        lblk_start = lblk & (~(sbi->s_cluster_ratio - 1));
+        lblk_start = EXT4_LBLK_CMASK(sbi, lblk);
         lblk_end = lblk_start + sbi->s_cluster_ratio - 1;
 
         return ext4_find_delalloc_range(inode, lblk_start, lblk_end);
@@ -3812,9 +3828,9 @@ get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start,
         trace_ext4_get_reserved_cluster_alloc(inode, lblk_start, num_blks);
 
         /* Check towards left side */
-        c_offset = lblk_start & (sbi->s_cluster_ratio - 1);
+        c_offset = EXT4_LBLK_COFF(sbi, lblk_start);
         if (c_offset) {
-                lblk_from = lblk_start & (~(sbi->s_cluster_ratio - 1));
+                lblk_from = EXT4_LBLK_CMASK(sbi, lblk_start);
                 lblk_to = lblk_from + c_offset - 1;
 
                 if (ext4_find_delalloc_range(inode, lblk_from, lblk_to))
@@ -3822,7 +3838,7 @@ get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start,
         }
 
         /* Now check towards right. */
-        c_offset = (lblk_start + num_blks) & (sbi->s_cluster_ratio - 1);
+        c_offset = EXT4_LBLK_COFF(sbi, lblk_start + num_blks);
         if (allocated_clusters && c_offset) {
                 lblk_from = lblk_start + num_blks;
                 lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1;
@@ -4030,7 +4046,7 @@ static int get_implied_cluster_alloc(struct super_block *sb,
                                      struct ext4_ext_path *path)
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
-        ext4_lblk_t c_offset = map->m_lblk & (sbi->s_cluster_ratio-1);
+        ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
         ext4_lblk_t ex_cluster_start, ex_cluster_end;
         ext4_lblk_t rr_cluster_start;
         ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
@@ -4048,8 +4064,7 @@ static int get_implied_cluster_alloc(struct super_block *sb,
             (rr_cluster_start == ex_cluster_start)) {
                 if (rr_cluster_start == ex_cluster_end)
                         ee_start += ee_len - 1;
-                map->m_pblk = (ee_start & ~(sbi->s_cluster_ratio - 1)) +
-                        c_offset;
+                map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset;
                 map->m_len = min(map->m_len,
                                  (unsigned) sbi->s_cluster_ratio - c_offset);
                 /*
@@ -4203,7 +4218,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
          */
         map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;
         newex.ee_block = cpu_to_le32(map->m_lblk);
-        cluster_offset = map->m_lblk & (sbi->s_cluster_ratio-1);
+        cluster_offset = EXT4_LBLK_CMASK(sbi, map->m_lblk);
 
         /*
          * If we are doing bigalloc, check to see if the extent returned
@@ -4271,7 +4286,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
          * needed so that future calls to get_implied_cluster_alloc()
          * work correctly.
          */
-        offset = map->m_lblk & (sbi->s_cluster_ratio - 1);
+        offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
         ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
         ar.goal -= offset;
         ar.logical -= offset;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 075763474118..61d49ff22c81 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1206,7 +1206,6 @@ static int ext4_journalled_write_end(struct file *file,
  */
 static int ext4_da_reserve_metadata(struct inode *inode, ext4_lblk_t lblock)
 {
-        int retries = 0;
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         struct ext4_inode_info *ei = EXT4_I(inode);
         unsigned int md_needed;
@@ -1218,7 +1217,6 @@ static int ext4_da_reserve_metadata(struct inode *inode, ext4_lblk_t lblock)
          * in order to allocate nrblocks
          * worse case is one extent per block
          */
-repeat:
         spin_lock(&ei->i_block_reservation_lock);
         /*
          * ext4_calc_metadata_amount() has side effects, which we have
@@ -1238,10 +1236,6 @@ repeat:
                 ei->i_da_metadata_calc_len = save_len;
                 ei->i_da_metadata_calc_last_lblock = save_last_lblock;
                 spin_unlock(&ei->i_block_reservation_lock);
-                if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
-                        cond_resched();
-                        goto repeat;
-                }
                 return -ENOSPC;
         }
         ei->i_reserved_meta_blocks += md_needed;
@@ -1255,7 +1249,6 @@ repeat:
  */
 static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
 {
-        int retries = 0;
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         struct ext4_inode_info *ei = EXT4_I(inode);
         unsigned int md_needed;
@@ -1277,7 +1270,6 @@ static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
          * in order to allocate nrblocks
          * worse case is one extent per block
          */
-repeat:
         spin_lock(&ei->i_block_reservation_lock);
         /*
          * ext4_calc_metadata_amount() has side effects, which we have
@@ -1297,10 +1289,6 @@ repeat:
                 ei->i_da_metadata_calc_len = save_len;
                 ei->i_da_metadata_calc_last_lblock = save_last_lblock;
                 spin_unlock(&ei->i_block_reservation_lock);
-                if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
-                        cond_resched();
-                        goto repeat;
-                }
                 dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
                 return -ENOSPC;
         }
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 4d113efa024c..04a5c7504be9 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -3442,6 +3442,9 @@ static void ext4_mb_pa_callback(struct rcu_head *head)
 {
         struct ext4_prealloc_space *pa;
         pa = container_of(head, struct ext4_prealloc_space, u.pa_rcu);
+
+        BUG_ON(atomic_read(&pa->pa_count));
+        BUG_ON(pa->pa_deleted == 0);
         kmem_cache_free(ext4_pspace_cachep, pa);
 }
 
@@ -3455,11 +3458,13 @@ static void ext4_mb_put_pa(struct ext4_allocation_context *ac,
         ext4_group_t grp;
         ext4_fsblk_t grp_blk;
 
-        if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0)
-                return;
-
         /* in this short window concurrent discard can set pa_deleted */
         spin_lock(&pa->pa_lock);
+        if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) {
+                spin_unlock(&pa->pa_lock);
+                return;
+        }
+
         if (pa->pa_deleted == 1) {
                 spin_unlock(&pa->pa_lock);
                 return;
@@ -4121,7 +4126,7 @@ ext4_mb_initialize_context(struct ext4_allocation_context *ac,
         ext4_get_group_no_and_offset(sb, goal, &group, &block);
 
         /* set up allocation goals */
-        ac->ac_b_ex.fe_logical = ar->logical & ~(sbi->s_cluster_ratio - 1);
+        ac->ac_b_ex.fe_logical = EXT4_LBLK_CMASK(sbi, ar->logical);
         ac->ac_status = AC_STATUS_CONTINUE;
         ac->ac_sb = sb;
         ac->ac_inode = ar->inode;
@@ -4663,7 +4668,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
          * blocks at the beginning or the end unless we are explicitly
          * requested to avoid doing so.
          */
-        overflow = block & (sbi->s_cluster_ratio - 1);
+        overflow = EXT4_PBLK_COFF(sbi, block);
         if (overflow) {
                 if (flags & EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER) {
                         overflow = sbi->s_cluster_ratio - overflow;
@@ -4677,7 +4682,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
                         count += overflow;
                 }
         }
-        overflow = count & (sbi->s_cluster_ratio - 1);
+        overflow = EXT4_LBLK_COFF(sbi, count);
         if (overflow) {
                 if (flags & EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER) {
                         if (count > overflow)
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index c977f4e4e63b..1f7784de05b6 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -792,7 +792,7 @@ static void ext4_put_super(struct super_block *sb)
         }
 
         ext4_es_unregister_shrinker(sbi);
-        del_timer(&sbi->s_err_report);
+        del_timer_sync(&sbi->s_err_report);
         ext4_release_system_zone(sb);
         ext4_mb_release(sb);
         ext4_ext_release(sb);
@@ -3316,11 +3316,19 @@ int ext4_calculate_overhead(struct super_block *sb)
 }
 
 
-static ext4_fsblk_t ext4_calculate_resv_clusters(struct ext4_sb_info *sbi)
+static ext4_fsblk_t ext4_calculate_resv_clusters(struct super_block *sb)
 {
         ext4_fsblk_t resv_clusters;
 
         /*
+         * There's no need to reserve anything when we aren't using extents.
+         * The space estimates are exact, there are no unwritten extents,
+         * hole punching doesn't need new metadata... This is needed especially
+         * to keep ext2/3 backward compatibility.
+         */
+        if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS))
+                return 0;
+        /*
          * By default we reserve 2% or 4096 clusters, whichever is smaller.
          * This should cover the situations where we can not afford to run
          * out of space like for example punch hole, or converting
@@ -3328,7 +3336,8 @@ static ext4_fsblk_t ext4_calculate_resv_clusters(struct ext4_sb_info *sbi)
          * allocation would require 1, or 2 blocks, higher numbers are
          * very rare.
          */
-        resv_clusters = ext4_blocks_count(sbi->s_es) >> sbi->s_cluster_bits;
+        resv_clusters = ext4_blocks_count(EXT4_SB(sb)->s_es) >>
+                        EXT4_SB(sb)->s_cluster_bits;
 
         do_div(resv_clusters, 50);
         resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
@@ -4071,10 +4080,10 @@ no_journal:
                          "available");
         }
 
-        err = ext4_reserve_clusters(sbi, ext4_calculate_resv_clusters(sbi));
+        err = ext4_reserve_clusters(sbi, ext4_calculate_resv_clusters(sb));
         if (err) {
                 ext4_msg(sb, KERN_ERR, "failed to reserve %llu clusters for "
-                         "reserved pool", ext4_calculate_resv_clusters(sbi));
+                         "reserved pool", ext4_calculate_resv_clusters(sb));
                 goto failed_mount4a;
         }
 
@@ -4184,7 +4193,7 @@ failed_mount_wq:
         }
 failed_mount3:
         ext4_es_unregister_shrinker(sbi);
-        del_timer(&sbi->s_err_report);
+        del_timer_sync(&sbi->s_err_report);
         if (sbi->s_flex_groups)
                 ext4_kvfree(sbi->s_flex_groups);
         percpu_counter_destroy(&sbi->s_freeclusters_counter);
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 52032647dd4a..5fa344afb49a 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -702,7 +702,7 @@ int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
         read_lock(&journal->j_state_lock);
 #ifdef CONFIG_JBD2_DEBUG
         if (!tid_geq(journal->j_commit_request, tid)) {
-                printk(KERN_EMERG
+                printk(KERN_ERR
                        "%s: error: j_commit_request=%d, tid=%d\n",
                        __func__, journal->j_commit_request, tid);
         }
@@ -718,10 +718,8 @@ int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
         }
         read_unlock(&journal->j_state_lock);
 
-        if (unlikely(is_journal_aborted(journal))) {
-                printk(KERN_EMERG "journal commit I/O error\n");
+        if (unlikely(is_journal_aborted(journal)))
                 err = -EIO;
-        }
         return err;
 }
 
@@ -1527,13 +1525,13 @@ static int journal_get_superblock(journal_t *journal)
         if (JBD2_HAS_COMPAT_FEATURE(journal, JBD2_FEATURE_COMPAT_CHECKSUM) &&
             JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) {
                 /* Can't have checksum v1 and v2 on at the same time! */
-                printk(KERN_ERR "JBD: Can't enable checksumming v1 and v2 "
+                printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2 "
                        "at the same time!\n");
                 goto out;
         }
 
         if (!jbd2_verify_csum_type(journal, sb)) {
-                printk(KERN_ERR "JBD: Unknown checksum type\n");
+                printk(KERN_ERR "JBD2: Unknown checksum type\n");
                 goto out;
         }
 
@@ -1541,7 +1539,7 @@ static int journal_get_superblock(journal_t *journal)
         if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) {
                 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
                 if (IS_ERR(journal->j_chksum_driver)) {
-                        printk(KERN_ERR "JBD: Cannot load crc32c driver.\n");
+                        printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
                         err = PTR_ERR(journal->j_chksum_driver);
                         journal->j_chksum_driver = NULL;
                         goto out;
@@ -1550,7 +1548,7 @@ static int journal_get_superblock(journal_t *journal)
 
         /* Check superblock checksum */
         if (!jbd2_superblock_csum_verify(journal, sb)) {
-                printk(KERN_ERR "JBD: journal checksum error\n");
+                printk(KERN_ERR "JBD2: journal checksum error\n");
                 goto out;
         }
 
@@ -1836,7 +1834,7 @@ int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
                         journal->j_chksum_driver = crypto_alloc_shash("crc32c",
                                                                       0, 0);
                         if (IS_ERR(journal->j_chksum_driver)) {
-                                printk(KERN_ERR "JBD: Cannot load crc32c "
+                                printk(KERN_ERR "JBD2: Cannot load crc32c "
                                        "driver.\n");
                                 journal->j_chksum_driver = NULL;
                                 return 0;
@@ -2645,7 +2643,7 @@ static void __exit journal_exit(void)
 #ifdef CONFIG_JBD2_DEBUG
         int n = atomic_read(&nr_journal_heads);
         if (n)
-                printk(KERN_EMERG "JBD2: leaked %d journal_heads!\n", n);
+                printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
 #endif
         jbd2_remove_jbd_stats_proc_entry();
         jbd2_journal_destroy_caches();
diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
index 3929c50428b1..3b6bb19d60b1 100644
--- a/fs/jbd2/recovery.c
+++ b/fs/jbd2/recovery.c
@@ -594,7 +594,7 @@ static int do_one_pass(journal_t *journal,
                                                 be32_to_cpu(tmp->h_sequence))) {
                                                 brelse(obh);
                                                 success = -EIO;
-                                                printk(KERN_ERR "JBD: Invalid "
+                                                printk(KERN_ERR "JBD2: Invalid "
                                                        "checksum recovering "
                                                        "block %llu in log\n",
                                                        blocknr);
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 7aa9a32573bb..8360674c85bc 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -932,7 +932,7 @@ repeat:
                                         jbd2_alloc(jh2bh(jh)->b_size,
                                                          GFP_NOFS);
                                 if (!frozen_buffer) {
-                                        printk(KERN_EMERG
+                                        printk(KERN_ERR
                                                "%s: OOM for frozen_buffer\n",
                                                __func__);
                                         JBUFFER_TRACE(jh, "oom!");
@@ -1166,7 +1166,7 @@ repeat:
         if (!jh->b_committed_data) {
                 committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
                 if (!committed_data) {
-                        printk(KERN_EMERG "%s: No memory for committed data\n",
+                        printk(KERN_ERR "%s: No memory for committed data\n",
                                 __func__);
                         err = -ENOMEM;
                         goto out;
@@ -1290,7 +1290,10 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
                  * once a transaction -bzzz
                  */
                 jh->b_modified = 1;
-                J_ASSERT_JH(jh, handle->h_buffer_credits > 0);
+                if (handle->h_buffer_credits <= 0) {
+                        ret = -ENOSPC;
+                        goto out_unlock_bh;
+                }
                 handle->h_buffer_credits--;
         }
 
@@ -1305,7 +1308,7 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
                 JBUFFER_TRACE(jh, "fastpath");
                 if (unlikely(jh->b_transaction !=
                              journal->j_running_transaction)) {
-                        printk(KERN_EMERG "JBD: %s: "
+                        printk(KERN_ERR "JBD2: %s: "
                                "jh->b_transaction (%llu, %p, %u) != "
                                "journal->j_running_transaction (%p, %u)",
                                journal->j_devname,
@@ -1332,7 +1335,7 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
                 JBUFFER_TRACE(jh, "already on other transaction");
                 if (unlikely(jh->b_transaction !=
                              journal->j_committing_transaction)) {
-                        printk(KERN_EMERG "JBD: %s: "
+                        printk(KERN_ERR "JBD2: %s: "
                                "jh->b_transaction (%llu, %p, %u) != "
                                "journal->j_committing_transaction (%p, %u)",
                                journal->j_devname,
@@ -1345,7 +1348,7 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
                         ret = -EINVAL;
                 }
                 if (unlikely(jh->b_next_transaction != transaction)) {
-                        printk(KERN_EMERG "JBD: %s: "
+                        printk(KERN_ERR "JBD2: %s: "
                                "jh->b_next_transaction (%llu, %p, %u) != "
                                "transaction (%p, %u)",
                                journal->j_devname,
@@ -1373,7 +1376,6 @@ out_unlock_bh:
         jbd2_journal_put_journal_head(jh);
 out:
         JBUFFER_TRACE(jh, "exit");
-        WARN_ON(ret);   /* All errors are bugs, so dump the stack */
         return ret;
 }
 
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index b8e93a40a5d3..78c3c2097787 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -443,8 +443,11 @@ int pstore_register(struct pstore_info *psi)
                 pstore_get_records(0);
 
         kmsg_dump_register(&pstore_dumper);
-        pstore_register_console();
-        pstore_register_ftrace();
+
+        if ((psi->flags & PSTORE_FLAGS_FRAGILE) == 0) {
+                pstore_register_console();
+                pstore_register_ftrace();
+        }
 
         if (pstore_update_ms >= 0) {
                 pstore_timer.expires = jiffies +
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index b94f93685093..35e7d08fe629 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -609,7 +609,7 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
         struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
         struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
         struct sysfs_open_file *of;
-        bool has_read, has_write, has_mmap;
+        bool has_read, has_write;
         int error = -EACCES;
 
         /* need attr_sd for attr and ops, its parent for kobj */
@@ -621,7 +621,6 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
 
                 has_read = battr->read || battr->mmap;
                 has_write = battr->write || battr->mmap;
-                has_mmap = battr->mmap;
         } else {
                 const struct sysfs_ops *ops = sysfs_file_ops(attr_sd);
 
@@ -633,7 +632,6 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
 
                 has_read = ops->show;
                 has_write = ops->store;
-                has_mmap = false;
         }
 
         /* check perms and supported operations */
@@ -661,9 +659,9 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
          * open file has a separate mutex, it's okay as long as those don't
          * happen on the same file.  At this point, we can't easily give
          * each file a separate locking class.  Let's differentiate on
-         * whether the file has mmap or not for now.
+         * whether the file is bin or not for now.
          */
-        if (has_mmap)
+        if (sysfs_is_bin(attr_sd))
                 mutex_init(&of->mutex);
         else
                 mutex_init(&of->mutex);
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 3ef11b22e750..3b2c14b6f0fb 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -1635,7 +1635,7 @@ xfs_bmap_last_extent(
  * blocks at the end of the file which do not start at the previous data block,
  * we will try to align the new blocks at stripe unit boundaries.
  *
- * Returns 0 in bma->aeof if the file (fork) is empty as any new write will be
+ * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be
  * at, or past the EOF.
  */
 STATIC int
@@ -1650,9 +1650,14 @@ xfs_bmap_isaeof(
         bma->aeof = 0;
         error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
                                      &is_empty);
-        if (error || is_empty)
+        if (error)
                 return error;
 
+        if (is_empty) {
+                bma->aeof = 1;
+                return 0;
+        }
+
         /*
          * Check if we are allocation or past the last extent, or at least into
          * the last delayed allocated extent.
@@ -3643,10 +3648,19 @@ xfs_bmap_btalloc(
         int             isaligned;
         int             tryagain;
         int             error;
+        int             stripe_align;
 
         ASSERT(ap->length);
 
         mp = ap->ip->i_mount;
+
+        /* stripe alignment for allocation is determined by mount parameters */
+        stripe_align = 0;
+        if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC))
+                stripe_align = mp->m_swidth;
+        else if (mp->m_dalign)
+                stripe_align = mp->m_dalign;
+
         align = ap->userdata ? xfs_get_extsz_hint(ap->ip) : 0;
         if (unlikely(align)) {
                 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
@@ -3655,6 +3669,8 @@ xfs_bmap_btalloc(
                 ASSERT(!error);
                 ASSERT(ap->length);
         }
+
+
         nullfb = *ap->firstblock == NULLFSBLOCK;
         fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock);
         if (nullfb) {
@@ -3730,7 +3746,7 @@ xfs_bmap_btalloc(
          */
         if (!ap->flist->xbf_low && ap->aeof) {
                 if (!ap->offset) {
-                        args.alignment = mp->m_dalign;
+                        args.alignment = stripe_align;
                         atype = args.type;
                         isaligned = 1;
                         /*
@@ -3755,13 +3771,13 @@ xfs_bmap_btalloc(
                          * of minlen+alignment+slop doesn't go up
                          * between the calls.
                          */
-                        if (blen > mp->m_dalign && blen <= args.maxlen)
-                                nextminlen = blen - mp->m_dalign;
+                        if (blen > stripe_align && blen <= args.maxlen)
+                                nextminlen = blen - stripe_align;
                         else
                                 nextminlen = args.minlen;
-                        if (nextminlen + mp->m_dalign > args.minlen + 1)
+                        if (nextminlen + stripe_align > args.minlen + 1)
                                 args.minalignslop =
-                                        nextminlen + mp->m_dalign -
+                                        nextminlen + stripe_align -
                                         args.minlen - 1;
                         else
                                 args.minalignslop = 0;
@@ -3783,7 +3799,7 @@ xfs_bmap_btalloc(
                  */
                 args.type = atype;
                 args.fsbno = ap->blkno;
-                args.alignment = mp->m_dalign;
+                args.alignment = stripe_align;
                 args.minlen = nextminlen;
                 args.minalignslop = 0;
                 isaligned = 1;
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 5887e41c0323..1394106ed22d 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1187,7 +1187,12 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_UNWRITE(bp);
                 XFS_BUF_READ(bp);
                 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
-                xfsbdstrat(mp, bp);
+
+                if (XFS_FORCED_SHUTDOWN(mp)) {
+                        error = XFS_ERROR(EIO);
+                        break;
+                }
+                xfs_buf_iorequest(bp);
                 error = xfs_buf_iowait(bp);
                 if (error) {
                         xfs_buf_ioerror_alert(bp,
@@ -1200,7 +1205,12 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_UNDONE(bp);
                 XFS_BUF_UNREAD(bp);
                 XFS_BUF_WRITE(bp);
-                xfsbdstrat(mp, bp);
+
+                if (XFS_FORCED_SHUTDOWN(mp)) {
+                        error = XFS_ERROR(EIO);
+                        break;
+                }
+                xfs_buf_iorequest(bp);
                 error = xfs_buf_iowait(bp);
                 if (error) {
                         xfs_buf_ioerror_alert(bp,
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index c7f0b77dcb00..afe7645e4b2b 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -698,7 +698,11 @@ xfs_buf_read_uncached(
         bp->b_flags |= XBF_READ;
         bp->b_ops = ops;
 
-        xfsbdstrat(target->bt_mount, bp);
+        if (XFS_FORCED_SHUTDOWN(target->bt_mount)) {
+                xfs_buf_relse(bp);
+                return NULL;
+        }
+        xfs_buf_iorequest(bp);
         xfs_buf_iowait(bp);
         return bp;
 }
@@ -1089,7 +1093,7 @@ xfs_bioerror(
  * This is meant for userdata errors; metadata bufs come with
  * iodone functions attached, so that we can track down errors.
  */
-STATIC int
+int
 xfs_bioerror_relse(
         struct xfs_buf  *bp)
 {
@@ -1152,7 +1156,7 @@ xfs_bwrite(
         ASSERT(xfs_buf_islocked(bp));
 
         bp->b_flags |= XBF_WRITE;
-        bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q);
+        bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q | XBF_WRITE_FAIL);
 
         xfs_bdstrat_cb(bp);
 
@@ -1164,25 +1168,6 @@ xfs_bwrite(
         return error;
 }
 
-/*
- * Wrapper around bdstrat so that we can stop data from going to disk in case
- * we are shutting down the filesystem.  Typically user data goes thru this
- * path; one of the exceptions is the superblock.
- */
-void
-xfsbdstrat(
-        struct xfs_mount        *mp,
-        struct xfs_buf          *bp)
-{
-        if (XFS_FORCED_SHUTDOWN(mp)) {
-                trace_xfs_bdstrat_shut(bp, _RET_IP_);
-                xfs_bioerror_relse(bp);
-                return;
-        }
-
-        xfs_buf_iorequest(bp);
-}
-
 STATIC void
 _xfs_buf_ioend(
         xfs_buf_t               *bp,
@@ -1516,6 +1501,12 @@ xfs_wait_buftarg(
                         struct xfs_buf *bp;
                         bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
                         list_del_init(&bp->b_lru);
+                        if (bp->b_flags & XBF_WRITE_FAIL) {
+                                xfs_alert(btp->bt_mount,
+"Corruption Alert: Buffer at block 0x%llx had permanent write failures!\n"
+"Please run xfs_repair to determine the extent of the problem.",
+                                        (long long)bp->b_bn);
+                        }
                         xfs_buf_rele(bp);
                 }
                 if (loop++ != 0)
@@ -1799,7 +1790,7 @@ __xfs_buf_delwri_submit(
 
         blk_start_plug(&plug);
         list_for_each_entry_safe(bp, n, io_list, b_list) {
-                bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC);
+                bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC | XBF_WRITE_FAIL);
                 bp->b_flags |= XBF_WRITE;
 
                 if (!wait) {
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index e65683361017..1cf21a4a9f22 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -45,6 +45,7 @@ typedef enum {
 #define XBF_ASYNC        (1 << 4) /* initiator will not wait for completion */
 #define XBF_DONE         (1 << 5) /* all pages in the buffer uptodate */
 #define XBF_STALE        (1 << 6) /* buffer has been staled, do not find it */
+#define XBF_WRITE_FAIL   (1 << 24)/* async writes have failed on this buffer */
 
 /* I/O hints for the BIO layer */
 #define XBF_SYNCIO       (1 << 10)/* treat this buffer as synchronous I/O */
@@ -70,6 +71,7 @@ typedef unsigned int xfs_buf_flags_t;
         { XBF_ASYNC,            "ASYNC" }, \
         { XBF_DONE,             "DONE" }, \
         { XBF_STALE,            "STALE" }, \
+        { XBF_WRITE_FAIL,       "WRITE_FAIL" }, \
         { XBF_SYNCIO,           "SYNCIO" }, \
         { XBF_FUA,              "FUA" }, \
         { XBF_FLUSH,            "FLUSH" }, \
@@ -80,6 +82,7 @@ typedef unsigned int xfs_buf_flags_t;
         { _XBF_DELWRI_Q,        "DELWRI_Q" }, \
         { _XBF_COMPOUND,        "COMPOUND" }
 
+
 /*
  * Internal state flags.
  */
@@ -269,9 +272,6 @@ extern void xfs_buf_unlock(xfs_buf_t *);
 
 /* Buffer Read and Write Routines */
 extern int xfs_bwrite(struct xfs_buf *bp);
-
-extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
-
 extern void xfs_buf_ioend(xfs_buf_t *,  int);
 extern void xfs_buf_ioerror(xfs_buf_t *, int);
 extern void xfs_buf_ioerror_alert(struct xfs_buf *, const char *func);
@@ -282,6 +282,8 @@ extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
 #define xfs_buf_zero(bp, off, len) \
             xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
 
+extern int xfs_bioerror_relse(struct xfs_buf *);
+
 static inline int xfs_buf_geterror(xfs_buf_t *bp)
 {
         return bp ? bp->b_error : ENOMEM;
@@ -301,7 +303,8 @@ extern void xfs_buf_terminate(void);
 
 #define XFS_BUF_ZEROFLAGS(bp) \
         ((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC| \
-                            XBF_SYNCIO|XBF_FUA|XBF_FLUSH))
+                            XBF_SYNCIO|XBF_FUA|XBF_FLUSH| \
+                            XBF_WRITE_FAIL))
 
 void xfs_buf_stale(struct xfs_buf *bp);
 #define XFS_BUF_UNSTALE(bp)     ((bp)->b_flags &= ~XBF_STALE)
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index a64f67ba25d3..2227b9b050bb 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -496,6 +496,14 @@ xfs_buf_item_unpin(
         }
 }
 
+/*
+ * Buffer IO error rate limiting. Limit it to no more than 10 messages per 30
+ * seconds so as to not spam logs too much on repeated detection of the same
+ * buffer being bad..
+ */
+
+DEFINE_RATELIMIT_STATE(xfs_buf_write_fail_rl_state, 30 * HZ, 10);
+
 STATIC uint
 xfs_buf_item_push(
         struct xfs_log_item     *lip,
@@ -524,6 +532,14 @@ xfs_buf_item_push(
 
         trace_xfs_buf_item_push(bip);
 
+        /* has a previous flush failed due to IO errors? */
+        if ((bp->b_flags & XBF_WRITE_FAIL) &&
+            ___ratelimit(&xfs_buf_write_fail_rl_state, "XFS:")) {
+                xfs_warn(bp->b_target->bt_mount,
+"Detected failing async write on buffer block 0x%llx. Retrying async write.\n",
+                         (long long)bp->b_bn);
+        }
+
         if (!xfs_buf_delwri_queue(bp, buffer_list))
                 rval = XFS_ITEM_FLUSHING;
         xfs_buf_unlock(bp);
@@ -1096,8 +1112,9 @@ xfs_buf_iodone_callbacks(
 
                 xfs_buf_ioerror(bp, 0); /* errno of 0 unsets the flag */
 
-                if (!XFS_BUF_ISSTALE(bp)) {
-                        bp->b_flags |= XBF_WRITE | XBF_ASYNC | XBF_DONE;
+                if (!(bp->b_flags & (XBF_STALE|XBF_WRITE_FAIL))) {
+                        bp->b_flags |= XBF_WRITE | XBF_ASYNC |
+                                       XBF_DONE | XBF_WRITE_FAIL;
                         xfs_buf_iorequest(bp);
                 } else {
                         xfs_buf_relse(bp);
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index 56369d4509d5..48c7d18f68c3 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -2067,12 +2067,12 @@ xfs_dir2_node_lookup(
  */
 int                                             /* error */
 xfs_dir2_node_removename(
-        xfs_da_args_t           *args)          /* operation arguments */
+        struct xfs_da_args      *args)          /* operation arguments */
 {
-        xfs_da_state_blk_t      *blk;           /* leaf block */
+        struct xfs_da_state_blk *blk;           /* leaf block */
         int                     error;          /* error return value */
         int                     rval;           /* operation return value */
-        xfs_da_state_t          *state;         /* btree cursor */
+        struct xfs_da_state     *state;         /* btree cursor */
 
         trace_xfs_dir2_node_removename(args);
 
@@ -2084,19 +2084,18 @@ xfs_dir2_node_removename(
         state->mp = args->dp->i_mount;
         state->blocksize = state->mp->m_dirblksize;
         state->node_ents = state->mp->m_dir_node_ents;
-        /*
-         * Look up the entry we're deleting, set up the cursor.
-         */
+
+        /* Look up the entry we're deleting, set up the cursor. */
         error = xfs_da3_node_lookup_int(state, &rval);
         if (error)
-                rval = error;
-        /*
-         * Didn't find it, upper layer screwed up.
-         */
+                goto out_free;
+
+        /* Didn't find it, upper layer screwed up. */
         if (rval != EEXIST) {
-                xfs_da_state_free(state);
-                return rval;
+                error = rval;
+                goto out_free;
         }
+
         blk = &state->path.blk[state->path.active - 1];
         ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
         ASSERT(state->extravalid);
@@ -2107,7 +2106,7 @@ xfs_dir2_node_removename(
         error = xfs_dir2_leafn_remove(args, blk->bp, blk->index,
                 &state->extrablk, &rval);
         if (error)
-                return error;
+                goto out_free;
         /*
          * Fix the hash values up the btree.
          */
@@ -2122,6 +2121,7 @@ xfs_dir2_node_removename(
          */
         if (!error)
                 error = xfs_dir2_node_to_leaf(state);
+out_free:
         xfs_da_state_free(state);
         return error;
 }
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 27e0e544e963..104455b8046c 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -618,7 +618,8 @@ xfs_setattr_nonsize(
                 }
                 if (!gid_eq(igid, gid)) {
                         if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
-                                ASSERT(!XFS_IS_PQUOTA_ON(mp));
+                                ASSERT(xfs_sb_version_has_pquotino(&mp->m_sb) ||
+                                       !XFS_IS_PQUOTA_ON(mp));
                                 ASSERT(mask & ATTR_GID);
                                 ASSERT(gdqp);
                                 olddquot2 = xfs_qm_vop_chown(tp, ip,
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index b6b669df40f3..eae16920655b 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -193,7 +193,10 @@ xlog_bread_noalign(
         bp->b_io_length = nbblks;
         bp->b_error = 0;
 
-        xfsbdstrat(log->l_mp, bp);
+        if (XFS_FORCED_SHUTDOWN(log->l_mp))
+                return XFS_ERROR(EIO);
+
+        xfs_buf_iorequest(bp);
         error = xfs_buf_iowait(bp);
         if (error)
                 xfs_buf_ioerror_alert(bp, __func__);
@@ -4397,7 +4400,13 @@ xlog_do_recover(
         XFS_BUF_READ(bp);
         XFS_BUF_UNASYNC(bp);
         bp->b_ops = &xfs_sb_buf_ops;
-        xfsbdstrat(log->l_mp, bp);
+
+        if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
+                xfs_buf_relse(bp);
+                return XFS_ERROR(EIO);
+        }
+
+        xfs_buf_iorequest(bp);
         error = xfs_buf_iowait(bp);
         if (error) {
                 xfs_buf_ioerror_alert(bp, __func__);
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 14a4996cfec6..dd88f0e27bd8 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -134,8 +134,6 @@ xfs_qm_dqpurge(
 {
         struct xfs_mount        *mp = dqp->q_mount;
         struct xfs_quotainfo    *qi = mp->m_quotainfo;
-        struct xfs_dquot        *gdqp = NULL;
-        struct xfs_dquot        *pdqp = NULL;
 
         xfs_dqlock(dqp);
         if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
@@ -143,21 +141,6 @@ xfs_qm_dqpurge(
                 return EAGAIN;
         }
 
-        /*
-         * If this quota has a hint attached, prepare for releasing it now.
-         */
-        gdqp = dqp->q_gdquot;
-        if (gdqp) {
-                xfs_dqlock(gdqp);
-                dqp->q_gdquot = NULL;
-        }
-
-        pdqp = dqp->q_pdquot;
-        if (pdqp) {
-                xfs_dqlock(pdqp);
-                dqp->q_pdquot = NULL;
-        }
-
         dqp->dq_flags |= XFS_DQ_FREEING;
 
         xfs_dqflock(dqp);
@@ -206,11 +189,47 @@ xfs_qm_dqpurge(
         XFS_STATS_DEC(xs_qm_dquot_unused);
 
         xfs_qm_dqdestroy(dqp);
+        return 0;
+}
+
+/*
+ * Release the group or project dquot pointers the user dquots maybe carrying
+ * around as a hint, and proceed to purge the user dquot cache if requested.
+*/
+STATIC int
+xfs_qm_dqpurge_hints(
+        struct xfs_dquot        *dqp,
+        void                    *data)
+{
+        struct xfs_dquot        *gdqp = NULL;
+        struct xfs_dquot        *pdqp = NULL;
+        uint                    flags = *((uint *)data);
+
+        xfs_dqlock(dqp);
+        if (dqp->dq_flags & XFS_DQ_FREEING) {
+                xfs_dqunlock(dqp);
+                return EAGAIN;
+        }
+
+        /* If this quota has a hint attached, prepare for releasing it now */
+        gdqp = dqp->q_gdquot;
+        if (gdqp)
+                dqp->q_gdquot = NULL;
+
+        pdqp = dqp->q_pdquot;
+        if (pdqp)
+                dqp->q_pdquot = NULL;
+
+        xfs_dqunlock(dqp);
 
         if (gdqp)
-                xfs_qm_dqput(gdqp);
+                xfs_qm_dqrele(gdqp);
         if (pdqp)
-                xfs_qm_dqput(pdqp);
+                xfs_qm_dqrele(pdqp);
+
+        if (flags & XFS_QMOPT_UQUOTA)
+                return xfs_qm_dqpurge(dqp, NULL);
+
         return 0;
 }
 
@@ -222,8 +241,18 @@ xfs_qm_dqpurge_all(
         struct xfs_mount        *mp,
         uint                    flags)
 {
-        if (flags & XFS_QMOPT_UQUOTA)
-                xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
+        /*
+         * We have to release group/project dquot hint(s) from the user dquot
+         * at first if they are there, otherwise we would run into an infinite
+         * loop while walking through radix tree to purge other type of dquots
+         * since their refcount is not zero if the user dquot refers to them
+         * as hint.
+         *
+         * Call the special xfs_qm_dqpurge_hints() will end up go through the
+         * general xfs_qm_dqpurge() against user dquot cache if requested.
+         */
+        xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge_hints, &flags);
+
         if (flags & XFS_QMOPT_GQUOTA)
                 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
         if (flags & XFS_QMOPT_PQUOTA)
@@ -2082,24 +2111,21 @@ xfs_qm_vop_create_dqattach(
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 
-        if (udqp) {
+        if (udqp && XFS_IS_UQUOTA_ON(mp)) {
                 ASSERT(ip->i_udquot == NULL);
-                ASSERT(XFS_IS_UQUOTA_ON(mp));
                 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
 
                 ip->i_udquot = xfs_qm_dqhold(udqp);
                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
         }
-        if (gdqp) {
+        if (gdqp && XFS_IS_GQUOTA_ON(mp)) {
                 ASSERT(ip->i_gdquot == NULL);
-                ASSERT(XFS_IS_GQUOTA_ON(mp));
                 ASSERT(ip->i_d.di_gid == be32_to_cpu(gdqp->q_core.d_id));
                 ip->i_gdquot = xfs_qm_dqhold(gdqp);
                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
         }
-        if (pdqp) {
+        if (pdqp && XFS_IS_PQUOTA_ON(mp)) {
                 ASSERT(ip->i_pdquot == NULL);
-                ASSERT(XFS_IS_PQUOTA_ON(mp));
                 ASSERT(xfs_get_projid(ip) == be32_to_cpu(pdqp->q_core.d_id));
 
                 ip->i_pdquot = xfs_qm_dqhold(pdqp);
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index c035d11b7734..647b6f1d8923 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -314,7 +314,18 @@ xfs_trans_read_buf_map(
                         ASSERT(bp->b_iodone == NULL);
                         XFS_BUF_READ(bp);
                         bp->b_ops = ops;
-                        xfsbdstrat(tp->t_mountp, bp);
+
+                        /*
+                         * XXX(hch): clean up the error handling here to be less
+                         * of a mess..
+                         */
+                        if (XFS_FORCED_SHUTDOWN(mp)) {
+                                trace_xfs_bdstrat_shut(bp, _RET_IP_);
+                                xfs_bioerror_relse(bp);
+                        } else {
+                                xfs_buf_iorequest(bp);
+                        }
+
                         error = xfs_buf_iowait(bp);
                         if (error) {
                                 xfs_buf_ioerror_alert(bp, __func__);
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h
index f330d28e4d0e..db0923458940 100644
--- a/include/asm-generic/pgtable.h
+++ b/include/asm-generic/pgtable.h
@@ -217,7 +217,7 @@ static inline int pmd_same(pmd_t pmd_a, pmd_t pmd_b)
 #endif
 
 #ifndef pte_accessible
-# define pte_accessible(pte)            ((void)(pte),1)
+# define pte_accessible(mm, pte)        ((void)(pte), 1)
 #endif
 
 #ifndef flush_tlb_fix_spurious_fault
@@ -599,11 +599,10 @@ static inline int pmd_none_or_trans_huge_or_clear_bad(pmd_t *pmd)
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
         barrier();
 #endif
-        if (pmd_none(pmdval))
+        if (pmd_none(pmdval) || pmd_trans_huge(pmdval))
                 return 1;
         if (unlikely(pmd_bad(pmdval))) {
-                if (!pmd_trans_huge(pmdval))
-                        pmd_clear_bad(pmd);
+                pmd_clear_bad(pmd);
                 return 1;
         }
         return 0;
diff --git a/include/asm-generic/preempt.h b/include/asm-generic/preempt.h
index ddf2b420ac8f..1cd3f5d767a8 100644
--- a/include/asm-generic/preempt.h
+++ b/include/asm-generic/preempt.h
@@ -3,13 +3,11 @@
 
 #include <linux/thread_info.h>
 
-/*
- * We mask the PREEMPT_NEED_RESCHED bit so as not to confuse all current users
- * that think a non-zero value indicates we cannot preempt.
- */
+#define PREEMPT_ENABLED (0)
+
 static __always_inline int preempt_count(void)
 {
-        return current_thread_info()->preempt_count & ~PREEMPT_NEED_RESCHED;
+        return current_thread_info()->preempt_count;
 }
 
 static __always_inline int *preempt_count_ptr(void)
@@ -17,11 +15,6 @@ static __always_inline int *preempt_count_ptr(void)
         return &current_thread_info()->preempt_count;
 }
 
-/*
- * We now loose PREEMPT_NEED_RESCHED and cause an extra reschedule; however the
- * alternative is loosing a reschedule. Better schedule too often -- also this
- * should be a very rare operation.
- */
 static __always_inline void preempt_count_set(int pc)
 {
         *preempt_count_ptr() = pc;
@@ -41,28 +34,17 @@ static __always_inline void preempt_count_set(int pc)
         task_thread_info(p)->preempt_count = PREEMPT_ENABLED; \
 } while (0)
 
-/*
- * We fold the NEED_RESCHED bit into the preempt count such that
- * preempt_enable() can decrement and test for needing to reschedule with a
- * single instruction.
- *
- * We invert the actual bit, so that when the decrement hits 0 we know we both
- * need to resched (the bit is cleared) and can resched (no preempt count).
- */
-
 static __always_inline void set_preempt_need_resched(void)
 {
-        *preempt_count_ptr() &= ~PREEMPT_NEED_RESCHED;
 }
 
 static __always_inline void clear_preempt_need_resched(void)
 {
-        *preempt_count_ptr() |= PREEMPT_NEED_RESCHED;
 }
 
 static __always_inline bool test_preempt_need_resched(void)
 {
-        return !(*preempt_count_ptr() & PREEMPT_NEED_RESCHED);
+        return false;
 }
 
 /*
@@ -81,7 +63,12 @@ static __always_inline void __preempt_count_sub(int val)
 
 static __always_inline bool __preempt_count_dec_and_test(void)
 {
-        return !--*preempt_count_ptr();
+        /*
+         * Because of load-store architectures cannot do per-cpu atomic
+         * operations; we cannot use PREEMPT_NEED_RESCHED because it might get
+         * lost.
+         */
+        return !--*preempt_count_ptr() && tif_need_resched();
 }
 
 /*
@@ -89,7 +76,7 @@ static __always_inline bool __preempt_count_dec_and_test(void)
  */
 static __always_inline bool should_resched(void)
 {
-        return unlikely(!*preempt_count_ptr());
+        return unlikely(!preempt_count() && tif_need_resched());
 }
 
 #ifdef CONFIG_PREEMPT
diff --git a/include/linux/auxvec.h b/include/linux/auxvec.h
index 669fef5c745a..3e0fbe441763 100644
--- a/include/linux/auxvec.h
+++ b/include/linux/auxvec.h
@@ -3,6 +3,6 @@
 
 #include <uapi/linux/auxvec.h>
 
-#define AT_VECTOR_SIZE_BASE 19 /* NEW_AUX_ENT entries in auxiliary table */
+#define AT_VECTOR_SIZE_BASE 20 /* NEW_AUX_ENT entries in auxiliary table */
   /* number of "#define AT_.*" above, minus {AT_NULL, AT_IGNORE, AT_NOTELF} */
 #endif /* _LINUX_AUXVEC_H */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 41cf0c399288..ed92b30a02fd 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -22,6 +22,7 @@
 #define LINUX_DMAENGINE_H
 
 #include <linux/device.h>
+#include <linux/err.h>
 #include <linux/uio.h>
 #include <linux/bug.h>
 #include <linux/scatterlist.h>
@@ -1040,6 +1041,8 @@ enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
 void dma_issue_pending_all(void);
 struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
                                         dma_filter_fn fn, void *fn_param);
+struct dma_chan *dma_request_slave_channel_reason(struct device *dev,
+                                                  const char *name);
 struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
 void dma_release_channel(struct dma_chan *chan);
 #else
@@ -1063,6 +1066,11 @@ static inline struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
 {
         return NULL;
 }
+static inline struct dma_chan *dma_request_slave_channel_reason(
+                                        struct device *dev, const char *name)
+{
+        return ERR_PTR(-ENODEV);
+}
 static inline struct dma_chan *dma_request_slave_channel(struct device *dev,
                                                          const char *name)
 {
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 0e23c26485f4..9b503376738f 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -418,6 +418,7 @@ enum {
         ATA_HORKAGE_DUMP_ID     = (1 << 16),    /* dump IDENTIFY data */
         ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),  /* Set max sects to 65535 */
         ATA_HORKAGE_ATAPI_DMADIR = (1 << 18),   /* device requires dmadir */
+        ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19),    /* don't use queued TRIM */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
diff --git a/include/linux/lockref.h b/include/linux/lockref.h
index c8929c3832db..4bfde0e99ed5 100644
--- a/include/linux/lockref.h
+++ b/include/linux/lockref.h
@@ -19,7 +19,7 @@
 
 #define USE_CMPXCHG_LOCKREF \
         (IS_ENABLED(CONFIG_ARCH_USE_CMPXCHG_LOCKREF) && \
-         IS_ENABLED(CONFIG_SMP) && !BLOATED_SPINLOCKS)
+         IS_ENABLED(CONFIG_SMP) && SPINLOCK_SIZE <= 4)
 
 struct lockref {
         union {
diff --git a/include/linux/math64.h b/include/linux/math64.h
index 69ed5f5e9f6e..c45c089bfdac 100644
--- a/include/linux/math64.h
+++ b/include/linux/math64.h
@@ -133,4 +133,34 @@ __iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder)
         return ret;
 }
 
+#if defined(CONFIG_ARCH_SUPPORTS_INT128) && defined(__SIZEOF_INT128__)
+
+#ifndef mul_u64_u32_shr
+static inline u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift)
+{
+        return (u64)(((unsigned __int128)a * mul) >> shift);
+}
+#endif /* mul_u64_u32_shr */
+
+#else
+
+#ifndef mul_u64_u32_shr
+static inline u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift)
+{
+        u32 ah, al;
+        u64 ret;
+
+        al = a;
+        ah = a >> 32;
+
+        ret = ((u64)al * mul) >> shift;
+        if (ah)
+                ret += ((u64)ah * mul) << (32 - shift);
+
+        return ret;
+}
+#endif /* mul_u64_u32_shr */
+
+#endif
+
 #endif /* _LINUX_MATH64_H */
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index cb49417f8ba9..22916c0f1ca4 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -139,6 +139,7 @@
 #define ARIZONA_INPUT_ENABLES_STATUS             0x301
 #define ARIZONA_INPUT_RATE                       0x308
 #define ARIZONA_INPUT_VOLUME_RAMP                0x309
+#define ARIZONA_HPF_CONTROL                      0x30C
 #define ARIZONA_IN1L_CONTROL                     0x310
 #define ARIZONA_ADC_DIGITAL_VOLUME_1L            0x311
 #define ARIZONA_DMIC1L_CONTROL                   0x312
@@ -160,6 +161,7 @@
 #define ARIZONA_IN4L_CONTROL                     0x328
 #define ARIZONA_ADC_DIGITAL_VOLUME_4L            0x329
 #define ARIZONA_DMIC4L_CONTROL                   0x32A
+#define ARIZONA_IN4R_CONTROL                     0x32C
 #define ARIZONA_ADC_DIGITAL_VOLUME_4R            0x32D
 #define ARIZONA_DMIC4R_CONTROL                   0x32E
 #define ARIZONA_OUTPUT_ENABLES_1                 0x400
@@ -511,6 +513,38 @@
 #define ARIZONA_AIF2TX2MIX_INPUT_3_VOLUME        0x74D
 #define ARIZONA_AIF2TX2MIX_INPUT_4_SOURCE        0x74E
 #define ARIZONA_AIF2TX2MIX_INPUT_4_VOLUME        0x74F
+#define ARIZONA_AIF2TX3MIX_INPUT_1_SOURCE        0x750
+#define ARIZONA_AIF2TX3MIX_INPUT_1_VOLUME        0x751
+#define ARIZONA_AIF2TX3MIX_INPUT_2_SOURCE        0x752
+#define ARIZONA_AIF2TX3MIX_INPUT_2_VOLUME        0x753
+#define ARIZONA_AIF2TX3MIX_INPUT_3_SOURCE        0x754
+#define ARIZONA_AIF2TX3MIX_INPUT_3_VOLUME        0x755
+#define ARIZONA_AIF2TX3MIX_INPUT_4_SOURCE        0x756
+#define ARIZONA_AIF2TX3MIX_INPUT_4_VOLUME        0x757
+#define ARIZONA_AIF2TX4MIX_INPUT_1_SOURCE        0x758
+#define ARIZONA_AIF2TX4MIX_INPUT_1_VOLUME        0x759
+#define ARIZONA_AIF2TX4MIX_INPUT_2_SOURCE        0x75A
+#define ARIZONA_AIF2TX4MIX_INPUT_2_VOLUME        0x75B
+#define ARIZONA_AIF2TX4MIX_INPUT_3_SOURCE        0x75C
+#define ARIZONA_AIF2TX4MIX_INPUT_3_VOLUME        0x75D
+#define ARIZONA_AIF2TX4MIX_INPUT_4_SOURCE        0x75E
+#define ARIZONA_AIF2TX4MIX_INPUT_4_VOLUME        0x75F
+#define ARIZONA_AIF2TX5MIX_INPUT_1_SOURCE        0x760
+#define ARIZONA_AIF2TX5MIX_INPUT_1_VOLUME        0x761
+#define ARIZONA_AIF2TX5MIX_INPUT_2_SOURCE        0x762
+#define ARIZONA_AIF2TX5MIX_INPUT_2_VOLUME        0x763
+#define ARIZONA_AIF2TX5MIX_INPUT_3_SOURCE        0x764
+#define ARIZONA_AIF2TX5MIX_INPUT_3_VOLUME        0x765
+#define ARIZONA_AIF2TX5MIX_INPUT_4_SOURCE        0x766
+#define ARIZONA_AIF2TX5MIX_INPUT_4_VOLUME        0x767
+#define ARIZONA_AIF2TX6MIX_INPUT_1_SOURCE        0x768
+#define ARIZONA_AIF2TX6MIX_INPUT_1_VOLUME        0x769
+#define ARIZONA_AIF2TX6MIX_INPUT_2_SOURCE        0x76A
+#define ARIZONA_AIF2TX6MIX_INPUT_2_VOLUME        0x76B
+#define ARIZONA_AIF2TX6MIX_INPUT_3_SOURCE        0x76C
+#define ARIZONA_AIF2TX6MIX_INPUT_3_VOLUME        0x76D
+#define ARIZONA_AIF2TX6MIX_INPUT_4_SOURCE        0x76E
+#define ARIZONA_AIF2TX6MIX_INPUT_4_VOLUME        0x76F
 #define ARIZONA_AIF3TX1MIX_INPUT_1_SOURCE        0x780
 #define ARIZONA_AIF3TX1MIX_INPUT_1_VOLUME        0x781
 #define ARIZONA_AIF3TX1MIX_INPUT_2_SOURCE        0x782
@@ -2293,8 +2327,18 @@
 #define ARIZONA_IN_VI_RAMP_WIDTH                      3  /* IN_VI_RAMP - [2:0] */
 
 /*
+ * R780 (0x30C) - HPF Control
+ */
+#define ARIZONA_IN_HPF_CUT_MASK                  0x0007  /* IN_HPF_CUT [2:0] */
+#define ARIZONA_IN_HPF_CUT_SHIFT                      0  /* IN_HPF_CUT [2:0] */
+#define ARIZONA_IN_HPF_CUT_WIDTH                      3  /* IN_HPF_CUT [2:0] */
+
+/*
  * R784 (0x310) - IN1L Control
  */
+#define ARIZONA_IN1L_HPF_MASK                    0x8000  /* IN1L_HPF - [15] */
+#define ARIZONA_IN1L_HPF_SHIFT                       15  /* IN1L_HPF - [15] */
+#define ARIZONA_IN1L_HPF_WIDTH                        1  /* IN1L_HPF - [15] */
 #define ARIZONA_IN1_OSR_MASK                     0x6000  /* IN1_OSR - [14:13] */
 #define ARIZONA_IN1_OSR_SHIFT                        13  /* IN1_OSR - [14:13] */
 #define ARIZONA_IN1_OSR_WIDTH                         2  /* IN1_OSR - [14:13] */
@@ -2333,6 +2377,9 @@
 /*
  * R788 (0x314) - IN1R Control
  */
+#define ARIZONA_IN1R_HPF_MASK                    0x8000  /* IN1R_HPF - [15] */
+#define ARIZONA_IN1R_HPF_SHIFT                       15  /* IN1R_HPF - [15] */
+#define ARIZONA_IN1R_HPF_WIDTH                        1  /* IN1R_HPF - [15] */
 #define ARIZONA_IN1R_PGA_VOL_MASK                0x00FE  /* IN1R_PGA_VOL - [7:1] */
 #define ARIZONA_IN1R_PGA_VOL_SHIFT                    1  /* IN1R_PGA_VOL - [7:1] */
 #define ARIZONA_IN1R_PGA_VOL_WIDTH                    7  /* IN1R_PGA_VOL - [7:1] */
@@ -2362,6 +2409,9 @@
 /*
  * R792 (0x318) - IN2L Control
  */
+#define ARIZONA_IN2L_HPF_MASK                    0x8000  /* IN2L_HPF - [15] */
+#define ARIZONA_IN2L_HPF_SHIFT                       15  /* IN2L_HPF - [15] */
+#define ARIZONA_IN2L_HPF_WIDTH                        1  /* IN2L_HPF - [15] */
 #define ARIZONA_IN2_OSR_MASK                     0x6000  /* IN2_OSR - [14:13] */
 #define ARIZONA_IN2_OSR_SHIFT                        13  /* IN2_OSR - [14:13] */
 #define ARIZONA_IN2_OSR_WIDTH                         2  /* IN2_OSR - [14:13] */
@@ -2400,6 +2450,9 @@
 /*
  * R796 (0x31C) - IN2R Control
  */
+#define ARIZONA_IN2R_HPF_MASK                    0x8000  /* IN2R_HPF - [15] */
+#define ARIZONA_IN2R_HPF_SHIFT                       15  /* IN2R_HPF - [15] */
+#define ARIZONA_IN2R_HPF_WIDTH                        1  /* IN2R_HPF - [15] */
 #define ARIZONA_IN2R_PGA_VOL_MASK                0x00FE  /* IN2R_PGA_VOL - [7:1] */
 #define ARIZONA_IN2R_PGA_VOL_SHIFT                    1  /* IN2R_PGA_VOL - [7:1] */
 #define ARIZONA_IN2R_PGA_VOL_WIDTH                    7  /* IN2R_PGA_VOL - [7:1] */
@@ -2429,6 +2482,9 @@
 /*
  * R800 (0x320) - IN3L Control
  */
+#define ARIZONA_IN3L_HPF_MASK                    0x8000  /* IN3L_HPF - [15] */
+#define ARIZONA_IN3L_HPF_SHIFT                       15  /* IN3L_HPF - [15] */
+#define ARIZONA_IN3L_HPF_WIDTH                        1  /* IN3L_HPF - [15] */
 #define ARIZONA_IN3_OSR_MASK                     0x6000  /* IN3_OSR - [14:13] */
 #define ARIZONA_IN3_OSR_SHIFT                        13  /* IN3_OSR - [14:13] */
 #define ARIZONA_IN3_OSR_WIDTH                         2  /* IN3_OSR - [14:13] */
@@ -2467,6 +2523,9 @@
 /*
  * R804 (0x324) - IN3R Control
  */
+#define ARIZONA_IN3R_HPF_MASK                    0x8000  /* IN3R_HPF - [15] */
+#define ARIZONA_IN3R_HPF_SHIFT                       15  /* IN3R_HPF - [15] */
+#define ARIZONA_IN3R_HPF_WIDTH                        1  /* IN3R_HPF - [15] */
 #define ARIZONA_IN3R_PGA_VOL_MASK                0x00FE  /* IN3R_PGA_VOL - [7:1] */
 #define ARIZONA_IN3R_PGA_VOL_SHIFT                    1  /* IN3R_PGA_VOL - [7:1] */
 #define ARIZONA_IN3R_PGA_VOL_WIDTH                    7  /* IN3R_PGA_VOL - [7:1] */
@@ -2496,6 +2555,9 @@
 /*
  * R808 (0x328) - IN4 Control
  */
+#define ARIZONA_IN4L_HPF_MASK                    0x8000  /* IN4L_HPF - [15] */
+#define ARIZONA_IN4L_HPF_SHIFT                       15  /* IN4L_HPF - [15] */
+#define ARIZONA_IN4L_HPF_WIDTH                        1  /* IN4L_HPF - [15] */
 #define ARIZONA_IN4_OSR_MASK                     0x6000  /* IN4_OSR - [14:13] */
 #define ARIZONA_IN4_OSR_SHIFT                        13  /* IN4_OSR - [14:13] */
 #define ARIZONA_IN4_OSR_WIDTH                         2  /* IN4_OSR - [14:13] */
@@ -2526,6 +2588,13 @@
 #define ARIZONA_IN4L_DMIC_DLY_WIDTH                   6  /* IN4L_DMIC_DLY - [5:0] */
 
 /*
+ * R812 (0x32C) - IN4R Control
+ */
+#define ARIZONA_IN4R_HPF_MASK                    0x8000  /* IN4R_HPF - [15] */
+#define ARIZONA_IN4R_HPF_SHIFT                       15  /* IN4R_HPF - [15] */
+#define ARIZONA_IN4R_HPF_WIDTH                        1  /* IN4R_HPF - [15] */
+
+/*
  * R813 (0x32D) - ADC Digital Volume 4R
  */
 #define ARIZONA_IN_VU                            0x0200  /* IN_VU */
@@ -3138,6 +3207,10 @@
 /*
  * R1088 (0x440) - DRE Enable
  */
+#define ARIZONA_DRE3R_ENA                        0x0020  /* DRE3R_ENA */
+#define ARIZONA_DRE3R_ENA_MASK                   0x0020  /* DRE3R_ENA */
+#define ARIZONA_DRE3R_ENA_SHIFT                       5  /* DRE3R_ENA */
+#define ARIZONA_DRE3R_ENA_WIDTH                       1  /* DRE3R_ENA */
 #define ARIZONA_DRE3L_ENA                        0x0010  /* DRE3L_ENA */
 #define ARIZONA_DRE3L_ENA_MASK                   0x0010  /* DRE3L_ENA */
 #define ARIZONA_DRE3L_ENA_SHIFT                       4  /* DRE3L_ENA */
@@ -3726,6 +3799,35 @@
 #define ARIZONA_AIF2TX2_SLOT_WIDTH                    6  /* AIF2TX2_SLOT - [5:0] */
 
 /*
+ * R1355 (0x54B) - AIF2 Frame Ctrl 5
+ */
+#define ARIZONA_AIF2TX3_SLOT_MASK                0x003F  /* AIF2TX3_SLOT - [5:0] */
+#define ARIZONA_AIF2TX3_SLOT_SHIFT                    0  /* AIF2TX3_SLOT - [5:0] */
+#define ARIZONA_AIF2TX3_SLOT_WIDTH                    6  /* AIF2TX3_SLOT - [5:0] */
+
+/*
+ * R1356 (0x54C) - AIF2 Frame Ctrl 6
+ */
+#define ARIZONA_AIF2TX4_SLOT_MASK                0x003F  /* AIF2TX4_SLOT - [5:0] */
+#define ARIZONA_AIF2TX4_SLOT_SHIFT                    0  /* AIF2TX4_SLOT - [5:0] */
+#define ARIZONA_AIF2TX4_SLOT_WIDTH                    6  /* AIF2TX4_SLOT - [5:0] */
+
+
+/*
+ * R1357 (0x54D) - AIF2 Frame Ctrl 7
+ */
+#define ARIZONA_AIF2TX5_SLOT_MASK                0x003F  /* AIF2TX5_SLOT - [5:0] */
+#define ARIZONA_AIF2TX5_SLOT_SHIFT                    0  /* AIF2TX5_SLOT - [5:0] */
+#define ARIZONA_AIF2TX5_SLOT_WIDTH                    6  /* AIF2TX5_SLOT - [5:0] */
+
+/*
+ * R1358 (0x54E) - AIF2 Frame Ctrl 8
+ */
+#define ARIZONA_AIF2TX6_SLOT_MASK                0x003F  /* AIF2TX6_SLOT - [5:0] */
+#define ARIZONA_AIF2TX6_SLOT_SHIFT                    0  /* AIF2TX6_SLOT - [5:0] */
+#define ARIZONA_AIF2TX6_SLOT_WIDTH                    6  /* AIF2TX6_SLOT - [5:0] */
+
+/*
  * R1361 (0x551) - AIF2 Frame Ctrl 11
  */
 #define ARIZONA_AIF2RX1_SLOT_MASK                0x003F  /* AIF2RX1_SLOT - [5:0] */
@@ -3740,8 +3842,52 @@
 #define ARIZONA_AIF2RX2_SLOT_WIDTH                    6  /* AIF2RX2_SLOT - [5:0] */
 
 /*
+ * R1363 (0x553) - AIF2 Frame Ctrl 13
+ */
+#define ARIZONA_AIF2RX3_SLOT_MASK                0x003F  /* AIF2RX3_SLOT - [5:0] */
+#define ARIZONA_AIF2RX3_SLOT_SHIFT                    0  /* AIF2RX3_SLOT - [5:0] */
+#define ARIZONA_AIF2RX3_SLOT_WIDTH                    6  /* AIF2RX3_SLOT - [5:0] */
+
+/*
+ * R1364 (0x554) - AIF2 Frame Ctrl 14
+ */
+#define ARIZONA_AIF2RX4_SLOT_MASK                0x003F  /* AIF2RX4_SLOT - [5:0] */
+#define ARIZONA_AIF2RX4_SLOT_SHIFT                    0  /* AIF2RX4_SLOT - [5:0] */
+#define ARIZONA_AIF2RX4_SLOT_WIDTH                    6  /* AIF2RX4_SLOT - [5:0] */
+
+/*
+ * R1365 (0x555) - AIF2 Frame Ctrl 15
+ */
+#define ARIZONA_AIF2RX5_SLOT_MASK                0x003F  /* AIF2RX5_SLOT - [5:0] */
+#define ARIZONA_AIF2RX5_SLOT_SHIFT                    0  /* AIF2RX5_SLOT - [5:0] */
+#define ARIZONA_AIF2RX5_SLOT_WIDTH                    6  /* AIF2RX5_SLOT - [5:0] */
+
+/*
+ * R1366 (0x556) - AIF2 Frame Ctrl 16
+ */
+#define ARIZONA_AIF2RX6_SLOT_MASK                0x003F  /* AIF2RX6_SLOT - [5:0] */
+#define ARIZONA_AIF2RX6_SLOT_SHIFT                    0  /* AIF2RX6_SLOT - [5:0] */
+#define ARIZONA_AIF2RX6_SLOT_WIDTH                    6  /* AIF2RX6_SLOT - [5:0] */
+
+/*
  * R1369 (0x559) - AIF2 Tx Enables
  */
+#define ARIZONA_AIF2TX6_ENA                      0x0020  /* AIF2TX6_ENA */
+#define ARIZONA_AIF2TX6_ENA_MASK                 0x0020  /* AIF2TX6_ENA */
+#define ARIZONA_AIF2TX6_ENA_SHIFT                     5  /* AIF2TX6_ENA */
+#define ARIZONA_AIF2TX6_ENA_WIDTH                     1  /* AIF2TX6_ENA */
+#define ARIZONA_AIF2TX5_ENA                      0x0010  /* AIF2TX5_ENA */
+#define ARIZONA_AIF2TX5_ENA_MASK                 0x0010  /* AIF2TX5_ENA */
+#define ARIZONA_AIF2TX5_ENA_SHIFT                     4  /* AIF2TX5_ENA */
+#define ARIZONA_AIF2TX5_ENA_WIDTH                     1  /* AIF2TX5_ENA */
+#define ARIZONA_AIF2TX4_ENA                      0x0008  /* AIF2TX4_ENA */
+#define ARIZONA_AIF2TX4_ENA_MASK                 0x0008  /* AIF2TX4_ENA */
+#define ARIZONA_AIF2TX4_ENA_SHIFT                     3  /* AIF2TX4_ENA */
+#define ARIZONA_AIF2TX4_ENA_WIDTH                     1  /* AIF2TX4_ENA */
+#define ARIZONA_AIF2TX3_ENA                      0x0004  /* AIF2TX3_ENA */
+#define ARIZONA_AIF2TX3_ENA_MASK                 0x0004  /* AIF2TX3_ENA */
+#define ARIZONA_AIF2TX3_ENA_SHIFT                     2  /* AIF2TX3_ENA */
+#define ARIZONA_AIF2TX3_ENA_WIDTH                     1  /* AIF2TX3_ENA */
 #define ARIZONA_AIF2TX2_ENA                      0x0002  /* AIF2TX2_ENA */
 #define ARIZONA_AIF2TX2_ENA_MASK                 0x0002  /* AIF2TX2_ENA */
 #define ARIZONA_AIF2TX2_ENA_SHIFT                     1  /* AIF2TX2_ENA */
@@ -3754,6 +3900,22 @@
 /*
  * R1370 (0x55A) - AIF2 Rx Enables
  */
+#define ARIZONA_AIF2RX6_ENA                      0x0020  /* AIF2RX6_ENA */
+#define ARIZONA_AIF2RX6_ENA_MASK                 0x0020  /* AIF2RX6_ENA */
+#define ARIZONA_AIF2RX6_ENA_SHIFT                     5  /* AIF2RX6_ENA */
+#define ARIZONA_AIF2RX6_ENA_WIDTH                     1  /* AIF2RX6_ENA */
+#define ARIZONA_AIF2RX5_ENA                      0x0010  /* AIF2RX5_ENA */
+#define ARIZONA_AIF2RX5_ENA_MASK                 0x0010  /* AIF2RX5_ENA */
+#define ARIZONA_AIF2RX5_ENA_SHIFT                     4  /* AIF2RX5_ENA */
+#define ARIZONA_AIF2RX5_ENA_WIDTH                     1  /* AIF2RX5_ENA */
+#define ARIZONA_AIF2RX4_ENA                      0x0008  /* AIF2RX4_ENA */
+#define ARIZONA_AIF2RX4_ENA_MASK                 0x0008  /* AIF2RX4_ENA */
+#define ARIZONA_AIF2RX4_ENA_SHIFT                     3  /* AIF2RX4_ENA */
+#define ARIZONA_AIF2RX4_ENA_WIDTH                     1  /* AIF2RX4_ENA */
+#define ARIZONA_AIF2RX3_ENA                      0x0004  /* AIF2RX3_ENA */
+#define ARIZONA_AIF2RX3_ENA_MASK                 0x0004  /* AIF2RX3_ENA */
+#define ARIZONA_AIF2RX3_ENA_SHIFT                     2  /* AIF2RX3_ENA */
+#define ARIZONA_AIF2RX3_ENA_WIDTH                     1  /* AIF2RX3_ENA */
 #define ARIZONA_AIF2RX2_ENA                      0x0002  /* AIF2RX2_ENA */
 #define ARIZONA_AIF2RX2_ENA_MASK                 0x0002  /* AIF2RX2_ENA */
 #define ARIZONA_AIF2RX2_ENA_SHIFT                     1  /* AIF2RX2_ENA */
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index f5096b58b20d..f015c059e159 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -55,7 +55,8 @@ extern int migrate_huge_page_move_mapping(struct address_space *mapping,
                                   struct page *newpage, struct page *page);
 extern int migrate_page_move_mapping(struct address_space *mapping,
                 struct page *newpage, struct page *page,
-                struct buffer_head *head, enum migrate_mode mode);
+                struct buffer_head *head, enum migrate_mode mode,
+                int extra_count);
 #else
 
 static inline void putback_lru_pages(struct list_head *l) {}
@@ -90,10 +91,19 @@ static inline int migrate_huge_page_move_mapping(struct address_space *mapping,
 #endif /* CONFIG_MIGRATION */
 
 #ifdef CONFIG_NUMA_BALANCING
+extern bool pmd_trans_migrating(pmd_t pmd);
+extern void wait_migrate_huge_page(struct anon_vma *anon_vma, pmd_t *pmd);
 extern int migrate_misplaced_page(struct page *page,
                                   struct vm_area_struct *vma, int node);
 extern bool migrate_ratelimited(int node);
 #else
+static inline bool pmd_trans_migrating(pmd_t pmd)
+{
+        return false;
+}
+static inline void wait_migrate_huge_page(struct anon_vma *anon_vma, pmd_t *pmd)
+{
+}
 static inline int migrate_misplaced_page(struct page *page,
                                          struct vm_area_struct *vma, int node)
 {
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1cedd000cf29..35527173cf50 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1317,7 +1317,7 @@ static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long a
 #endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
 
 #if USE_SPLIT_PTE_PTLOCKS
-#if BLOATED_SPINLOCKS
+#if ALLOC_SPLIT_PTLOCKS
 extern bool ptlock_alloc(struct page *page);
 extern void ptlock_free(struct page *page);
 
@@ -1325,7 +1325,7 @@ static inline spinlock_t *ptlock_ptr(struct page *page)
 {
         return page->ptl;
 }
-#else /* BLOATED_SPINLOCKS */
+#else /* ALLOC_SPLIT_PTLOCKS */
 static inline bool ptlock_alloc(struct page *page)
 {
         return true;
@@ -1339,7 +1339,7 @@ static inline spinlock_t *ptlock_ptr(struct page *page)
 {
         return &page->ptl;
 }
-#endif /* BLOATED_SPINLOCKS */
+#endif /* ALLOC_SPLIT_PTLOCKS */
 
 static inline spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd)
 {
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index bd299418a934..290901a8c1de 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -26,6 +26,7 @@ struct address_space;
 #define USE_SPLIT_PTE_PTLOCKS   (NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS)
 #define USE_SPLIT_PMD_PTLOCKS   (USE_SPLIT_PTE_PTLOCKS && \
                 IS_ENABLED(CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK))
+#define ALLOC_SPLIT_PTLOCKS     (SPINLOCK_SIZE > BITS_PER_LONG/8)
 
 /*
  * Each physical page in the system has a struct page associated with
@@ -155,7 +156,7 @@ struct page {
                                                  * system if PG_buddy is set.
                                                  */
 #if USE_SPLIT_PTE_PTLOCKS
-#if BLOATED_SPINLOCKS
+#if ALLOC_SPLIT_PTLOCKS
                 spinlock_t *ptl;
 #else
                 spinlock_t ptl;
@@ -443,6 +444,14 @@ struct mm_struct {
         /* numa_scan_seq prevents two threads setting pte_numa */
         int numa_scan_seq;
 #endif
+#if defined(CONFIG_NUMA_BALANCING) || defined(CONFIG_COMPACTION)
+        /*
+         * An operation with batched TLB flushing is going on. Anything that
+         * can move process memory needs to flush the TLB when moving a
+         * PROT_NONE or PROT_NUMA mapped page.
+         */
+        bool tlb_flush_pending;
+#endif
         struct uprobes_state uprobes_state;
 };
 
@@ -459,4 +468,45 @@ static inline cpumask_t *mm_cpumask(struct mm_struct *mm)
         return mm->cpu_vm_mask_var;
 }
 
+#if defined(CONFIG_NUMA_BALANCING) || defined(CONFIG_COMPACTION)
+/*
+ * Memory barriers to keep this state in sync are graciously provided by
+ * the page table locks, outside of which no page table modifications happen.
+ * The barriers below prevent the compiler from re-ordering the instructions
+ * around the memory barriers that are already present in the code.
+ */
+static inline bool mm_tlb_flush_pending(struct mm_struct *mm)
+{
+        barrier();
+        return mm->tlb_flush_pending;
+}
+static inline void set_tlb_flush_pending(struct mm_struct *mm)
+{
+        mm->tlb_flush_pending = true;
+
+        /*
+         * Guarantee that the tlb_flush_pending store does not leak into the
+         * critical section updating the page tables
+         */
+        smp_mb__before_spinlock();
+}
+/* Clearing is done after a TLB flush, which also provides a barrier. */
+static inline void clear_tlb_flush_pending(struct mm_struct *mm)
+{
+        barrier();
+        mm->tlb_flush_pending = false;
+}
+#else
+static inline bool mm_tlb_flush_pending(struct mm_struct *mm)
+{
+        return false;
+}
+static inline void set_tlb_flush_pending(struct mm_struct *mm)
+{
+}
+static inline void clear_tlb_flush_pending(struct mm_struct *mm)
+{
+}
+#endif
+
 #endif /* _LINUX_MM_TYPES_H */
diff --git a/include/linux/percpu-defs.h b/include/linux/percpu-defs.h
index 57e890abe1f0..a5fc7d01aad6 100644
--- a/include/linux/percpu-defs.h
+++ b/include/linux/percpu-defs.h
@@ -69,6 +69,7 @@
         __PCPU_DUMMY_ATTRS char __pcpu_scope_##name;                    \
         extern __PCPU_DUMMY_ATTRS char __pcpu_unique_##name;            \
         __PCPU_DUMMY_ATTRS char __pcpu_unique_##name;                   \
+        extern __PCPU_ATTRS(sec) __typeof__(type) name;                 \
         __PCPU_ATTRS(sec) PER_CPU_DEF_ATTRIBUTES __weak                 \
         __typeof__(type) name
 #else
diff --git a/include/linux/platform_data/asoc-ti-mcbsp.h b/include/linux/platform_data/asoc-ti-mcbsp.h
index c78d90b28b19..3c73c045f8da 100644
--- a/include/linux/platform_data/asoc-ti-mcbsp.h
+++ b/include/linux/platform_data/asoc-ti-mcbsp.h
@@ -1,6 +1,4 @@
 /*
- * arch/arm/plat-omap/include/mach/mcbsp.h
- *
  * Defines for Multi-Channel Buffered Serial Port
  *
  * Copyright (C) 2002 RidgeRun, Inc.
@@ -21,8 +19,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  */
-#ifndef __ASM_ARCH_OMAP_MCBSP_H
-#define __ASM_ARCH_OMAP_MCBSP_H
+#ifndef __ASOC_TI_MCBSP_H
+#define __ASOC_TI_MCBSP_H
 
 #include <linux/spinlock.h>
 #include <linux/clk.h>
diff --git a/include/linux/platform_data/davinci_asp.h b/include/linux/platform_data/davinci_asp.h
index 689a856b86f9..5245992b0367 100644
--- a/include/linux/platform_data/davinci_asp.h
+++ b/include/linux/platform_data/davinci_asp.h
@@ -92,6 +92,7 @@ enum {
         MCASP_VERSION_1 = 0,    /* DM646x */
         MCASP_VERSION_2,        /* DA8xx/OMAPL1x */
         MCASP_VERSION_3,        /* TI81xx/AM33xx */
+        MCASP_VERSION_4,        /* DRA7xxx */
 };
 
 enum mcbsp_clk_input_pin {
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index abd437d0a8a7..ece0c6bbfcc5 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -51,6 +51,7 @@ struct pstore_info {
         char            *buf;
         size_t          bufsize;
         struct mutex    read_mutex;     /* serialize open/read/close */
+        int             flags;
         int             (*open)(struct pstore_info *psi);
         int             (*close)(struct pstore_info *psi);
         ssize_t         (*read)(u64 *id, enum pstore_type_id *type,
@@ -70,6 +71,8 @@ struct pstore_info {
         void            *data;
 };
 
+#define PSTORE_FLAGS_FRAGILE    1
+
 #ifdef CONFIG_PSTORE
 extern int pstore_register(struct pstore_info *);
 extern bool pstore_cannot_block_path(enum kmsg_dump_reason reason);
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 8e00f9f6f963..9e7db9e73cc1 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -43,6 +43,7 @@ extern int unregister_reboot_notifier(struct notifier_block *);
  * Architecture-specific implementations of sys_reboot commands.
  */
 
+extern void migrate_to_reboot_cpu(void);
 extern void machine_restart(char *cmd);
 extern void machine_halt(void);
 extern void machine_power_off(void);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 768b037dfacb..53f97eb8dbc7 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -440,8 +440,6 @@ struct task_cputime {
                 .sum_exec_runtime = 0,                          \
         }
 
-#define PREEMPT_ENABLED         (PREEMPT_NEED_RESCHED)
-
 #ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_DISABLED        (1 + PREEMPT_ENABLED)
 #else
@@ -932,7 +930,8 @@ struct pipe_inode_info;
 struct uts_namespace;
 
 struct load_weight {
-        unsigned long weight, inv_weight;
+        unsigned long weight;
+        u32 inv_weight;
 };
 
 struct sched_avg {
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 979874c627ee..61e1935c91b1 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -978,7 +978,7 @@ struct ib_uobject {
 };
 
 struct ib_udata {
-        void __user *inbuf;
+        const void __user *inbuf;
         void __user *outbuf;
         size_t       inlen;
         size_t       outlen;
diff --git a/include/sound/cs42l52.h b/include/sound/cs42l52.h
index 7c2be4a51894..bbabf84bdb44 100644
--- a/include/sound/cs42l52.h
+++ b/include/sound/cs42l52.h
@@ -16,17 +16,11 @@ struct cs42l52_platform_data {
         /* MICBIAS Level. Check datasheet Pg48 */
         unsigned int micbias_lvl;
 
-        /* MICA mode selection 0=Single 1=Differential */
-        unsigned int mica_cfg;
+        /* MICA mode selection Differential or Single-ended */
+        bool mica_diff_cfg;
 
-        /* MICB mode selection 0=Single 1=Differential */
-        unsigned int micb_cfg;
-
-        /* MICA Select 0=MIC1A 1=MIC2A */
-        unsigned int mica_sel;
-
-        /* MICB Select 0=MIC2A 1=MIC2B */
-        unsigned int micb_sel;
+        /* MICB mode selection Differential or Single-ended */
+        bool micb_diff_cfg;
 
         /* Charge Pump Freq. Check datasheet Pg73 */
         unsigned int chgfreq;
diff --git a/include/sound/dmaengine_pcm.h b/include/sound/dmaengine_pcm.h
index 15017311f2e9..eb73a3a39ec2 100644
--- a/include/sound/dmaengine_pcm.h
+++ b/include/sound/dmaengine_pcm.h
@@ -114,6 +114,10 @@ void snd_dmaengine_pcm_set_config_from_dai_data(
  * @compat_filter_fn: Will be used as the filter function when requesting a
  *  channel for platforms which do not use devicetree. The filter parameter
  *  will be the DAI's DMA data.
+ * @dma_dev: If set, request DMA channel on this device rather than the DAI
+ *  device.
+ * @chan_names: If set, these custom DMA channel names will be requested at
+ *  registration time.
  * @pcm_hardware: snd_pcm_hardware struct to be used for the PCM.
  * @prealloc_buffer_size: Size of the preallocated audio buffer.
  *
@@ -130,6 +134,8 @@ struct snd_dmaengine_pcm_config {
                         struct snd_soc_pcm_runtime *rtd,
                         struct snd_pcm_substream *substream);
         dma_filter_fn compat_filter_fn;
+        struct device *dma_dev;
+        const char *chan_names[SNDRV_PCM_STREAM_LAST + 1];
 
         const struct snd_pcm_hardware *pcm_hardware;
         unsigned int prealloc_buffer_size;
@@ -140,6 +146,10 @@ int snd_dmaengine_pcm_register(struct device *dev,
         unsigned int flags);
 void snd_dmaengine_pcm_unregister(struct device *dev);
 
+int devm_snd_dmaengine_pcm_register(struct device *dev,
+        const struct snd_dmaengine_pcm_config *config,
+        unsigned int flags);
+
 int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params,
         struct dma_slave_config *slave_config);
diff --git a/include/sound/pcm_params.h b/include/sound/pcm_params.h
index 37ae12e0ab06..6b1c78f05fab 100644
--- a/include/sound/pcm_params.h
+++ b/include/sound/pcm_params.h
@@ -354,4 +354,16 @@ params_period_bytes(const struct snd_pcm_hw_params *p)
                 params_channels(p)) / 8;
 }
 
+static inline int
+params_width(const struct snd_pcm_hw_params *p)
+{
+        return snd_pcm_format_width(params_format(p));
+}
+
+static inline int
+params_physical_width(const struct snd_pcm_hw_params *p)
+{
+        return snd_pcm_format_physical_width(params_format(p));
+}
+
 #endif /* __SOUND_PCM_PARAMS_H */
diff --git a/include/sound/rcar_snd.h b/include/sound/rcar_snd.h
index 12afab18945d..e147498abe50 100644
--- a/include/sound/rcar_snd.h
+++ b/include/sound/rcar_snd.h
@@ -18,7 +18,7 @@
 #define RSND_GEN1_ADG   1
 #define RSND_GEN1_SSI   2
 
-#define RSND_GEN2_SRU   0
+#define RSND_GEN2_SCU   0
 #define RSND_GEN2_ADG   1
 #define RSND_GEN2_SSIU  2
 #define RSND_GEN2_SSI   3
@@ -58,6 +58,7 @@ struct rsnd_ssi_platform_info {
 
 struct rsnd_scu_platform_info {
         u32 flags;
+        u32 convert_rate; /* sampling rate convert */
 };
 
 /*
diff --git a/include/sound/soc-dai.h b/include/sound/soc-dai.h
index 800c101bb096..243d3b689699 100644
--- a/include/sound/soc-dai.h
+++ b/include/sound/soc-dai.h
@@ -220,6 +220,8 @@ struct snd_soc_dai_driver {
         struct snd_soc_pcm_stream capture;
         struct snd_soc_pcm_stream playback;
         unsigned int symmetric_rates:1;
+        unsigned int symmetric_channels:1;
+        unsigned int symmetric_samplebits:1;
 
         /* probe ordering - for components with runtime dependencies */
         int probe_order;
@@ -244,6 +246,8 @@ struct snd_soc_dai {
         unsigned int capture_active:1;          /* stream is in use */
         unsigned int playback_active:1;         /* stream is in use */
         unsigned int symmetric_rates:1;
+        unsigned int symmetric_channels:1;
+        unsigned int symmetric_samplebits:1;
         struct snd_pcm_runtime *runtime;
         unsigned int active;
         unsigned char probed:1;
@@ -258,6 +262,8 @@ struct snd_soc_dai {
 
         /* Symmetry data - only valid if symmetry is being enforced */
         unsigned int rate;
+        unsigned int channels;
+        unsigned int sample_bits;
 
         /* parent platform/codec */
         struct snd_soc_platform *platform;
diff --git a/include/sound/soc.h b/include/sound/soc.h
index 1f741cb24f33..5a049d969c59 100644
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -334,9 +334,7 @@ struct snd_soc_jack_pin;
 #include <sound/soc-dapm.h>
 #include <sound/soc-dpcm.h>
 
-#ifdef CONFIG_GPIOLIB
 struct snd_soc_jack_gpio;
-#endif
 
 typedef int (*hw_write_t)(void *,const char* ,int);
 
@@ -446,6 +444,17 @@ int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
                         struct snd_soc_jack_gpio *gpios);
 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
                         struct snd_soc_jack_gpio *gpios);
+#else
+static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
+                                         struct snd_soc_jack_gpio *gpios)
+{
+        return 0;
+}
+
+static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
+                                           struct snd_soc_jack_gpio *gpios)
+{
+}
 #endif
 
 /* codec register bit access */
@@ -580,7 +589,6 @@ struct snd_soc_jack_zone {
  *                     to provide more complex checks (eg, reading an
  *                     ADC).
  */
-#ifdef CONFIG_GPIOLIB
 struct snd_soc_jack_gpio {
         unsigned int gpio;
         const char *name;
@@ -594,7 +602,6 @@ struct snd_soc_jack_gpio {
 
         int (*jack_status_check)(void);
 };
-#endif
 
 struct snd_soc_jack {
         struct mutex mutex;
@@ -879,6 +886,8 @@ struct snd_soc_dai_link {
 
         /* Symmetry requirements */
         unsigned int symmetric_rates:1;
+        unsigned int symmetric_channels:1;
+        unsigned int symmetric_samplebits:1;
 
         /* Do not create a PCM for this DAI link (Backend link) */
         unsigned int no_pcm:1;
diff --git a/include/sound/spear_dma.h b/include/sound/spear_dma.h
index 1b365bfdfb37..65aca51fe255 100644
--- a/include/sound/spear_dma.h
+++ b/include/sound/spear_dma.h
@@ -29,7 +29,6 @@ struct spear_dma_data {
         dma_addr_t addr;
         u32 max_burst;
         enum dma_slave_buswidth addr_width;
-        bool (*filter)(struct dma_chan *chan, void *slave);
 };
 
 #endif /* SPEAR_DMA_H */
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index 45412a6afa69..321301c0a643 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -517,10 +517,6 @@ struct se_node_acl {
         u32                     acl_index;
 #define MAX_ACL_TAG_SIZE 64
         char                    acl_tag[MAX_ACL_TAG_SIZE];
-        u64                     num_cmds;
-        u64                     read_bytes;
-        u64                     write_bytes;
-        spinlock_t              stats_lock;
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
         atomic_t                acl_pr_ref_count;
         struct se_dev_entry     **device_list;
@@ -624,6 +620,7 @@ struct se_dev_attrib {
         u32             unmap_granularity;
         u32             unmap_granularity_alignment;
         u32             max_write_same_len;
+        u32             max_bytes_per_io;
         struct se_device *da_dev;
         struct config_group da_group;
 };
diff --git a/include/uapi/drm/vmwgfx_drm.h b/include/uapi/drm/vmwgfx_drm.h
index bcb0912afe7a..f854ca4a1372 100644
--- a/include/uapi/drm/vmwgfx_drm.h
+++ b/include/uapi/drm/vmwgfx_drm.h
@@ -75,6 +75,7 @@
 #define DRM_VMW_PARAM_FIFO_CAPS        4
 #define DRM_VMW_PARAM_MAX_FB_SIZE      5
 #define DRM_VMW_PARAM_FIFO_HW_VERSION  6
+#define DRM_VMW_PARAM_MAX_SURF_MEMORY  7
 
 /**
  * struct drm_vmw_getparam_arg
diff --git a/include/uapi/linux/perf_event.h b/include/uapi/linux/perf_event.h
index e1802d6153ae..959d454f76a1 100644
--- a/include/uapi/linux/perf_event.h
+++ b/include/uapi/linux/perf_event.h
@@ -679,6 +679,7 @@ enum perf_event_type {
          *
          *      { u64                   weight;   } && PERF_SAMPLE_WEIGHT
          *      { u64                   data_src; } && PERF_SAMPLE_DATA_SRC
+         *      { u64                   transaction; } && PERF_SAMPLE_TRANSACTION
          * };
          */
         PERF_RECORD_SAMPLE                      = 9,
diff --git a/include/xen/interface/io/blkif.h b/include/xen/interface/io/blkif.h
index 65e12099ef89..ae665ac59c36 100644
--- a/include/xen/interface/io/blkif.h
+++ b/include/xen/interface/io/blkif.h
@@ -146,7 +146,7 @@ struct blkif_request_segment_aligned {
 struct blkif_request_rw {
         uint8_t        nr_segments;  /* number of segments                   */
         blkif_vdev_t   handle;       /* only for read/write requests         */
-#ifdef CONFIG_X86_64
+#ifndef CONFIG_X86_32
         uint32_t       _pad1;        /* offsetof(blkif_request,u.rw.id) == 8 */
 #endif
         uint64_t       id;           /* private guest value, echoed in resp  */
@@ -163,7 +163,7 @@ struct blkif_request_discard {
         uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero.        */
 #define BLKIF_DISCARD_SECURE (1<<0)  /* ignored if discard-secure=0          */
         blkif_vdev_t   _pad1;        /* only for read/write requests         */
-#ifdef CONFIG_X86_64
+#ifndef CONFIG_X86_32
         uint32_t       _pad2;        /* offsetof(blkif_req..,u.discard.id)==8*/
 #endif
         uint64_t       id;           /* private guest value, echoed in resp  */
@@ -175,7 +175,7 @@ struct blkif_request_discard {
 struct blkif_request_other {
         uint8_t      _pad1;
         blkif_vdev_t _pad2;        /* only for read/write requests         */
-#ifdef CONFIG_X86_64
+#ifndef CONFIG_X86_32
         uint32_t     _pad3;        /* offsetof(blkif_req..,u.other.id)==8*/
 #endif
         uint64_t     id;           /* private guest value, echoed in resp  */
@@ -184,7 +184,7 @@ struct blkif_request_other {
 struct blkif_request_indirect {
         uint8_t        indirect_op;
         uint16_t       nr_segments;
-#ifdef CONFIG_X86_64
+#ifndef CONFIG_X86_32
         uint32_t       _pad1;        /* offsetof(blkif_...,u.indirect.id) == 8 */
 #endif
         uint64_t       id;
@@ -192,7 +192,7 @@ struct blkif_request_indirect {
         blkif_vdev_t   handle;
         uint16_t       _pad2;
         grant_ref_t    indirect_grefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST];
-#ifdef CONFIG_X86_64
+#ifndef CONFIG_X86_32
         uint32_t      _pad3;         /* make it 64 byte aligned */
 #else
         uint64_t      _pad3;         /* make it 64 byte aligned */
diff --git a/init/Kconfig b/init/Kconfig
index 79383d3aa5dc..4e5d96ab2034 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -809,6 +809,12 @@ config GENERIC_SCHED_CLOCK
 config ARCH_SUPPORTS_NUMA_BALANCING
         bool
 
+#
+# For architectures that know their GCC __int128 support is sound
+#
+config ARCH_SUPPORTS_INT128
+        bool
+
 # For architectures that (ab)use NUMA to represent different memory regions
 # all cpu-local but of different latencies, such as SuperH.
 #
diff --git a/kernel/Makefile b/kernel/Makefile
index bbaf7d59c1bb..bc010ee272b6 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -137,9 +137,10 @@ $(obj)/timeconst.h: $(obj)/hz.bc $(src)/timeconst.bc FORCE
 ###############################################################################
 ifeq ($(CONFIG_SYSTEM_TRUSTED_KEYRING),y)
 X509_CERTIFICATES-y := $(wildcard *.x509) $(wildcard $(srctree)/*.x509)
-X509_CERTIFICATES-$(CONFIG_MODULE_SIG) += signing_key.x509
-X509_CERTIFICATES := $(sort $(foreach CERT,$(X509_CERTIFICATES-y), \
+X509_CERTIFICATES-$(CONFIG_MODULE_SIG) += $(objtree)/signing_key.x509
+X509_CERTIFICATES-raw := $(sort $(foreach CERT,$(X509_CERTIFICATES-y), \
                                 $(or $(realpath $(CERT)),$(CERT))))
+X509_CERTIFICATES := $(subst $(realpath $(objtree))/,,$(X509_CERTIFICATES-raw))
 
 ifeq ($(X509_CERTIFICATES),)
 $(warning *** No X.509 certificates found ***)
@@ -164,9 +165,9 @@ $(obj)/x509_certificate_list: $(X509_CERTIFICATES) $(obj)/.x509.list
 targets += $(obj)/.x509.list
 $(obj)/.x509.list:
         @echo $(X509_CERTIFICATES) >$@
+endif
 
 clean-files := x509_certificate_list .x509.list
-endif
 
 ifeq ($(CONFIG_MODULE_SIG),y)
 ###############################################################################
diff --git a/kernel/bounds.c b/kernel/bounds.c
index 5253204afdca..9fd4246b04b8 100644
--- a/kernel/bounds.c
+++ b/kernel/bounds.c
@@ -22,6 +22,6 @@ void foo(void)
 #ifdef CONFIG_SMP
         DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS));
 #endif
-        DEFINE(BLOATED_SPINLOCKS, sizeof(spinlock_t) > sizeof(int));
+        DEFINE(SPINLOCK_SIZE, sizeof(spinlock_t));
         /* End of constants */
 }
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 8b729c278b64..bc1dcabe9217 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -890,6 +890,16 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
                 struct cgroup *cgrp = dentry->d_fsdata;
 
                 BUG_ON(!(cgroup_is_dead(cgrp)));
+
+                /*
+                 * XXX: cgrp->id is only used to look up css's.  As cgroup
+                 * and css's lifetimes will be decoupled, it should be made
+                 * per-subsystem and moved to css->id so that lookups are
+                 * successful until the target css is released.
+                 */
+                idr_remove(&cgrp->root->cgroup_idr, cgrp->id);
+                cgrp->id = -1;
+
                 call_rcu(&cgrp->rcu_head, cgroup_free_rcu);
         } else {
                 struct cfent *cfe = __d_cfe(dentry);
@@ -4268,6 +4278,7 @@ static void css_release(struct percpu_ref *ref)
         struct cgroup_subsys_state *css =
                 container_of(ref, struct cgroup_subsys_state, refcnt);
 
+        rcu_assign_pointer(css->cgroup->subsys[css->ss->subsys_id], NULL);
         call_rcu(&css->rcu_head, css_free_rcu_fn);
 }
 
@@ -4426,14 +4437,6 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
         list_add_tail_rcu(&cgrp->sibling, &cgrp->parent->children);
         root->number_of_cgroups++;
 
-        /* each css holds a ref to the cgroup's dentry and the parent css */
-        for_each_root_subsys(root, ss) {
-                struct cgroup_subsys_state *css = css_ar[ss->subsys_id];
-
-                dget(dentry);
-                css_get(css->parent);
-        }
-
         /* hold a ref to the parent's dentry */
         dget(parent->dentry);
 
@@ -4445,6 +4448,13 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
                 if (err)
                         goto err_destroy;
 
+                /* each css holds a ref to the cgroup's dentry and parent css */
+                dget(dentry);
+                css_get(css->parent);
+
+                /* mark it consumed for error path */
+                css_ar[ss->subsys_id] = NULL;
+
                 if (ss->broken_hierarchy && !ss->warned_broken_hierarchy &&
                     parent->parent) {
                         pr_warning("cgroup: %s (%d) created nested cgroup for controller \"%s\" which has incomplete hierarchy support. Nested cgroups may change behavior in the future.\n",
@@ -4491,6 +4501,14 @@ err_free_cgrp:
         return err;
 
 err_destroy:
+        for_each_root_subsys(root, ss) {
+                struct cgroup_subsys_state *css = css_ar[ss->subsys_id];
+
+                if (css) {
+                        percpu_ref_cancel_init(&css->refcnt);
+                        ss->css_free(css);
+                }
+        }
         cgroup_destroy_locked(cgrp);
         mutex_unlock(&cgroup_mutex);
         mutex_unlock(&dentry->d_inode->i_mutex);
@@ -4652,8 +4670,12 @@ static int cgroup_destroy_locked(struct cgroup *cgrp)
          * will be invoked to perform the rest of destruction once the
          * percpu refs of all css's are confirmed to be killed.
          */
-        for_each_root_subsys(cgrp->root, ss)
-                kill_css(cgroup_css(cgrp, ss));
+        for_each_root_subsys(cgrp->root, ss) {
+                struct cgroup_subsys_state *css = cgroup_css(cgrp, ss);
+
+                if (css)
+                        kill_css(css);
+        }
 
         /*
          * Mark @cgrp dead.  This prevents further task migration and child
@@ -4722,14 +4744,6 @@ static void cgroup_destroy_css_killed(struct cgroup *cgrp)
         /* delete this cgroup from parent->children */
         list_del_rcu(&cgrp->sibling);
 
-        /*
-         * We should remove the cgroup object from idr before its grace
-         * period starts, so we won't be looking up a cgroup while the
-         * cgroup is being freed.
-         */
-        idr_remove(&cgrp->root->cgroup_idr, cgrp->id);
-        cgrp->id = -1;
-
         dput(d);
 
         set_bit(CGRP_RELEASABLE, &parent->flags);
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 72348dc192c1..f5744010a8d2 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -1396,6 +1396,8 @@ event_sched_out(struct perf_event *event,
         if (event->state != PERF_EVENT_STATE_ACTIVE)
                 return;
 
+        perf_pmu_disable(event->pmu);
+
         event->state = PERF_EVENT_STATE_INACTIVE;
         if (event->pending_disable) {
                 event->pending_disable = 0;
@@ -1412,6 +1414,8 @@ event_sched_out(struct perf_event *event,
                 ctx->nr_freq--;
         if (event->attr.exclusive || !cpuctx->active_oncpu)
                 cpuctx->exclusive = 0;
+
+        perf_pmu_enable(event->pmu);
 }
 
 static void
@@ -1652,6 +1656,7 @@ event_sched_in(struct perf_event *event,
                  struct perf_event_context *ctx)
 {
         u64 tstamp = perf_event_time(event);
+        int ret = 0;
 
         if (event->state <= PERF_EVENT_STATE_OFF)
                 return 0;
@@ -1674,10 +1679,13 @@ event_sched_in(struct perf_event *event,
          */
         smp_wmb();
 
+        perf_pmu_disable(event->pmu);
+
         if (event->pmu->add(event, PERF_EF_START)) {
                 event->state = PERF_EVENT_STATE_INACTIVE;
                 event->oncpu = -1;
-                return -EAGAIN;
+                ret = -EAGAIN;
+                goto out;
         }
 
         event->tstamp_running += tstamp - event->tstamp_stopped;
@@ -1693,7 +1701,10 @@ event_sched_in(struct perf_event *event,
         if (event->attr.exclusive)
                 cpuctx->exclusive = 1;
 
-        return 0;
+out:
+        perf_pmu_enable(event->pmu);
+
+        return ret;
 }
 
 static int
@@ -2743,6 +2754,8 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
                 if (!event_filter_match(event))
                         continue;
 
+                perf_pmu_disable(event->pmu);
+
                 hwc = &event->hw;
 
                 if (hwc->interrupts == MAX_INTERRUPTS) {
@@ -2752,7 +2765,7 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
                 }
 
                 if (!event->attr.freq || !event->attr.sample_freq)
-                        continue;
+                        goto next;
 
                 /*
                  * stop the event and update event->count
@@ -2774,6 +2787,8 @@ static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
                         perf_adjust_period(event, period, delta, false);
 
                 event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
+        next:
+                perf_pmu_enable(event->pmu);
         }
 
         perf_pmu_enable(ctx->pmu);
diff --git a/kernel/fork.c b/kernel/fork.c
index 728d5be9548c..5721f0e3f2da 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -537,6 +537,7 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p)
         spin_lock_init(&mm->page_table_lock);
         mm_init_aio(mm);
         mm_init_owner(mm, p);
+        clear_tlb_flush_pending(mm);
 
         if (likely(!mm_alloc_pgd(mm))) {
                 mm->def_flags = 0;
diff --git a/kernel/freezer.c b/kernel/freezer.c
index b462fa197517..aa6a8aadb911 100644
--- a/kernel/freezer.c
+++ b/kernel/freezer.c
@@ -19,6 +19,12 @@ EXPORT_SYMBOL(system_freezing_cnt);
 bool pm_freezing;
 bool pm_nosig_freezing;
 
+/*
+ * Temporary export for the deadlock workaround in ata_scsi_hotplug().
+ * Remove once the hack becomes unnecessary.
+ */
+EXPORT_SYMBOL_GPL(pm_freezing);
+
 /* protects freezing and frozen transitions */
 static DEFINE_SPINLOCK(freezer_lock);
 
diff --git a/kernel/kexec.c b/kernel/kexec.c
index d0d8fca54065..9c970167e402 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -1680,6 +1680,7 @@ int kernel_kexec(void)
         {
                 kexec_in_progress = true;
                 kernel_restart_prepare(NULL);
+                migrate_to_reboot_cpu();
                 printk(KERN_EMERG "Starting new kernel\n");
                 machine_shutdown();
         }
diff --git a/kernel/power/console.c b/kernel/power/console.c
index 463aa6736751..eacb8bd8cab4 100644
--- a/kernel/power/console.c
+++ b/kernel/power/console.c
@@ -81,6 +81,7 @@ void pm_vt_switch_unregister(struct device *dev)
         list_for_each_entry(tmp, &pm_vt_switch_list, head) {
                 if (tmp->dev == dev) {
                         list_del(&tmp->head);
+                        kfree(tmp);
                         break;
                 }
         }
diff --git a/kernel/reboot.c b/kernel/reboot.c
index f813b3474646..662c83fc16b7 100644
--- a/kernel/reboot.c
+++ b/kernel/reboot.c
@@ -104,7 +104,7 @@ int unregister_reboot_notifier(struct notifier_block *nb)
 }
 EXPORT_SYMBOL(unregister_reboot_notifier);
 
-static void migrate_to_reboot_cpu(void)
+void migrate_to_reboot_cpu(void)
 {
         /* The boot cpu is always logical cpu 0 */
         int cpu = reboot_cpu;
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index e85cda20ab2b..a88f4a485c5e 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4902,6 +4902,7 @@ DEFINE_PER_CPU(struct sched_domain *, sd_asym);
 static void update_top_cache_domain(int cpu)
 {
         struct sched_domain *sd;
+        struct sched_domain *busy_sd = NULL;
         int id = cpu;
         int size = 1;
 
@@ -4909,9 +4910,9 @@ static void update_top_cache_domain(int cpu)
         if (sd) {
                 id = cpumask_first(sched_domain_span(sd));
                 size = cpumask_weight(sched_domain_span(sd));
-                sd = sd->parent; /* sd_busy */
+                busy_sd = sd->parent; /* sd_busy */
         }
-        rcu_assign_pointer(per_cpu(sd_busy, cpu), sd);
+        rcu_assign_pointer(per_cpu(sd_busy, cpu), busy_sd);
 
         rcu_assign_pointer(per_cpu(sd_llc, cpu), sd);
         per_cpu(sd_llc_size, cpu) = size;
@@ -5112,6 +5113,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
                  * die on a /0 trap.
                  */
                 sg->sgp->power = SCHED_POWER_SCALE * cpumask_weight(sg_span);
+                sg->sgp->power_orig = sg->sgp->power;
 
                 /*
                  * Make sure the first group of this domain contains the
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index fd773ade1a31..c7395d97e4cb 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -178,59 +178,61 @@ void sched_init_granularity(void)
         update_sysctl();
 }
 
-#if BITS_PER_LONG == 32
-# define WMULT_CONST    (~0UL)
-#else
-# define WMULT_CONST    (1UL << 32)
-#endif
-
+#define WMULT_CONST     (~0U)
 #define WMULT_SHIFT     32
 
-/*
- * Shift right and round:
- */
-#define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
+static void __update_inv_weight(struct load_weight *lw)
+{
+        unsigned long w;
+
+        if (likely(lw->inv_weight))
+                return;
+
+        w = scale_load_down(lw->weight);
+
+        if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
+                lw->inv_weight = 1;
+        else if (unlikely(!w))
+                lw->inv_weight = WMULT_CONST;
+        else
+                lw->inv_weight = WMULT_CONST / w;
+}
 
 /*
- * delta *= weight / lw
+ * delta_exec * weight / lw.weight
+ *   OR
+ * (delta_exec * (weight * lw->inv_weight)) >> WMULT_SHIFT
+ *
+ * Either weight := NICE_0_LOAD and lw \e prio_to_wmult[], in which case
+ * we're guaranteed shift stays positive because inv_weight is guaranteed to
+ * fit 32 bits, and NICE_0_LOAD gives another 10 bits; therefore shift >= 22.
+ *
+ * Or, weight =< lw.weight (because lw.weight is the runqueue weight), thus
+ * weight/lw.weight <= 1, and therefore our shift will also be positive.
  */
-static unsigned long
-calc_delta_mine(unsigned long delta_exec, unsigned long weight,
-                struct load_weight *lw)
+static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw)
 {
-        u64 tmp;
-
-        /*
-         * weight can be less than 2^SCHED_LOAD_RESOLUTION for task group sched
-         * entities since MIN_SHARES = 2. Treat weight as 1 if less than
-         * 2^SCHED_LOAD_RESOLUTION.
-         */
-        if (likely(weight > (1UL << SCHED_LOAD_RESOLUTION)))
-                tmp = (u64)delta_exec * scale_load_down(weight);
-        else
-                tmp = (u64)delta_exec;
+        u64 fact = scale_load_down(weight);
+        int shift = WMULT_SHIFT;
 
-        if (!lw->inv_weight) {
-                unsigned long w = scale_load_down(lw->weight);
+        __update_inv_weight(lw);
 
-                if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
-                        lw->inv_weight = 1;
-                else if (unlikely(!w))
-                        lw->inv_weight = WMULT_CONST;
-                else
-                        lw->inv_weight = WMULT_CONST / w;
+        if (unlikely(fact >> 32)) {
+                while (fact >> 32) {
+                        fact >>= 1;
+                        shift--;
+                }
         }
 
-        /*
-         * Check whether we'd overflow the 64-bit multiplication:
-         */
-        if (unlikely(tmp > WMULT_CONST))
-                tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
-                        WMULT_SHIFT/2);
-        else
-                tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
+        /* hint to use a 32x32->64 mul */
+        fact = (u64)(u32)fact * lw->inv_weight;
+
+        while (fact >> 32) {
+                fact >>= 1;
+                shift--;
+        }
 
-        return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
+        return mul_u64_u32_shr(delta_exec, fact, shift);
 }
 
 
@@ -443,7 +445,7 @@ find_matching_se(struct sched_entity **se, struct sched_entity **pse)
 #endif  /* CONFIG_FAIR_GROUP_SCHED */
 
 static __always_inline
-void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec);
+void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec);
 
 /**************************************************************
  * Scheduling class tree data structure manipulation methods:
@@ -612,11 +614,10 @@ int sched_proc_update_handler(struct ctl_table *table, int write,
 /*
  * delta /= w
  */
-static inline unsigned long
-calc_delta_fair(unsigned long delta, struct sched_entity *se)
+static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
 {
         if (unlikely(se->load.weight != NICE_0_LOAD))
-                delta = calc_delta_mine(delta, NICE_0_LOAD, &se->load);
+                delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
 
         return delta;
 }
@@ -665,7 +666,7 @@ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
                         update_load_add(&lw, se->load.weight);
                         load = &lw;
                 }
-                slice = calc_delta_mine(slice, se->load.weight, load);
+                slice = __calc_delta(slice, se->load.weight, load);
         }
         return slice;
 }
@@ -703,47 +704,32 @@ void init_task_runnable_average(struct task_struct *p)
 #endif
 
 /*
- * Update the current task's runtime statistics. Skip current tasks that
- * are not in our scheduling class.
+ * Update the current task's runtime statistics.
  */
-static inline void
-__update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
-              unsigned long delta_exec)
-{
-        unsigned long delta_exec_weighted;
-
-        schedstat_set(curr->statistics.exec_max,
-                      max((u64)delta_exec, curr->statistics.exec_max));
-
-        curr->sum_exec_runtime += delta_exec;
-        schedstat_add(cfs_rq, exec_clock, delta_exec);
-        delta_exec_weighted = calc_delta_fair(delta_exec, curr);
-
-        curr->vruntime += delta_exec_weighted;
-        update_min_vruntime(cfs_rq);
-}
-
 static void update_curr(struct cfs_rq *cfs_rq)
 {
         struct sched_entity *curr = cfs_rq->curr;
         u64 now = rq_clock_task(rq_of(cfs_rq));
-        unsigned long delta_exec;
+        u64 delta_exec;
 
         if (unlikely(!curr))
                 return;
 
-        /*
-         * Get the amount of time the current task was running
-         * since the last time we changed load (this cannot
-         * overflow on 32 bits):
-         */
-        delta_exec = (unsigned long)(now - curr->exec_start);
-        if (!delta_exec)
+        delta_exec = now - curr->exec_start;
+        if (unlikely((s64)delta_exec <= 0))
                 return;
 
-        __update_curr(cfs_rq, curr, delta_exec);
         curr->exec_start = now;
 
+        schedstat_set(curr->statistics.exec_max,
+                      max(delta_exec, curr->statistics.exec_max));
+
+        curr->sum_exec_runtime += delta_exec;
+        schedstat_add(cfs_rq, exec_clock, delta_exec);
+
+        curr->vruntime += calc_delta_fair(delta_exec, curr);
+        update_min_vruntime(cfs_rq);
+
         if (entity_is_task(curr)) {
                 struct task_struct *curtask = task_of(curr);
 
@@ -1752,6 +1738,13 @@ void task_numa_work(struct callback_head *work)
                     (vma->vm_file && (vma->vm_flags & (VM_READ|VM_WRITE)) == (VM_READ)))
                         continue;
 
+                /*
+                 * Skip inaccessible VMAs to avoid any confusion between
+                 * PROT_NONE and NUMA hinting ptes
+                 */
+                if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
+                        continue;
+
                 do {
                         start = max(start, vma->vm_start);
                         end = ALIGN(start + (pages << PAGE_SHIFT), HPAGE_SIZE);
@@ -3015,8 +3008,7 @@ static void expire_cfs_rq_runtime(struct cfs_rq *cfs_rq)
         }
 }
 
-static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
-                                     unsigned long delta_exec)
+static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
 {
         /* dock delta_exec before expiring quota (as it could span periods) */
         cfs_rq->runtime_remaining -= delta_exec;
@@ -3034,7 +3026,7 @@ static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
 }
 
 static __always_inline
-void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec)
+void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
 {
         if (!cfs_bandwidth_used() || !cfs_rq->runtime_enabled)
                 return;
@@ -3574,8 +3566,7 @@ static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq)
         return rq_clock_task(rq_of(cfs_rq));
 }
 
-static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq,
-                                     unsigned long delta_exec) {}
+static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec) {}
 static void check_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
 static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {}
 static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c
index 7d57275fc396..1c4065575fa2 100644
--- a/kernel/sched/rt.c
+++ b/kernel/sched/rt.c
@@ -901,6 +901,13 @@ inc_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
 {
         struct rq *rq = rq_of_rt_rq(rt_rq);
 
+#ifdef CONFIG_RT_GROUP_SCHED
+        /*
+         * Change rq's cpupri only if rt_rq is the top queue.
+         */
+        if (&rq->rt != rt_rq)
+                return;
+#endif
         if (rq->online && prio < prev_prio)
                 cpupri_set(&rq->rd->cpupri, rq->cpu, prio);
 }
@@ -910,6 +917,13 @@ dec_rt_prio_smp(struct rt_rq *rt_rq, int prio, int prev_prio)
 {
         struct rq *rq = rq_of_rt_rq(rt_rq);
 
+#ifdef CONFIG_RT_GROUP_SCHED
+        /*
+         * Change rq's cpupri only if rt_rq is the top queue.
+         */
+        if (&rq->rt != rt_rq)
+                return;
+#endif
         if (rq->online && rt_rq->highest_prio.curr != prev_prio)
                 cpupri_set(&rq->rd->cpupri, rq->cpu, rt_rq->highest_prio.curr);
 }
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 0e9f9eaade2f..72a0f81dc5a8 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -775,7 +775,7 @@ static int ftrace_profile_init(void)
         int cpu;
         int ret = 0;
 
-        for_each_online_cpu(cpu) {
+        for_each_possible_cpu(cpu) {
                 ret = ftrace_profile_init_cpu(cpu);
                 if (ret)
                         break;
diff --git a/kernel/user.c b/kernel/user.c
index a3a0dbfda329..c006131beb77 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -51,9 +51,9 @@ struct user_namespace init_user_ns = {
         .owner = GLOBAL_ROOT_UID,
         .group = GLOBAL_ROOT_GID,
         .proc_inum = PROC_USER_INIT_INO,
-#ifdef CONFIG_KEYS_KERBEROS_CACHE
-        .krb_cache_register_sem =
-        __RWSEM_INITIALIZER(init_user_ns.krb_cache_register_sem),
+#ifdef CONFIG_PERSISTENT_KEYRINGS
+        .persistent_keyring_register_sem =
+        __RWSEM_INITIALIZER(init_user_ns.persistent_keyring_register_sem),
 #endif
 };
 EXPORT_SYMBOL_GPL(init_user_ns);
diff --git a/mm/Kconfig b/mm/Kconfig
index eb69f352401d..723bbe04a0b0 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -543,7 +543,7 @@ config ZSWAP
 
 config MEM_SOFT_DIRTY
         bool "Track memory changes"
-        depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY
+        depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
         select PROC_PAGE_MONITOR
         help
           This option enables memory changes tracking by introducing a
diff --git a/mm/compaction.c b/mm/compaction.c
index 805165bcd3dd..f58bcd016f43 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -134,6 +134,10 @@ static void update_pageblock_skip(struct compact_control *cc,
                         bool migrate_scanner)
 {
         struct zone *zone = cc->zone;
+
+        if (cc->ignore_skip_hint)
+                return;
+
         if (!page)
                 return;
 
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 33a5dc492810..7de1bf85f683 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -882,6 +882,10 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
                 ret = 0;
                 goto out_unlock;
         }
+
+        /* mmap_sem prevents this happening but warn if that changes */
+        WARN_ON(pmd_trans_migrating(pmd));
+
         if (unlikely(pmd_trans_splitting(pmd))) {
                 /* split huge page running from under us */
                 spin_unlock(src_ptl);
@@ -1243,6 +1247,10 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
         if ((flags & FOLL_DUMP) && is_huge_zero_pmd(*pmd))
                 return ERR_PTR(-EFAULT);
 
+        /* Full NUMA hinting faults to serialise migration in fault paths */
+        if ((flags & FOLL_NUMA) && pmd_numa(*pmd))
+                goto out;
+
         page = pmd_page(*pmd);
         VM_BUG_ON(!PageHead(page));
         if (flags & FOLL_TOUCH) {
@@ -1295,6 +1303,17 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
         if (unlikely(!pmd_same(pmd, *pmdp)))
                 goto out_unlock;
 
+        /*
+         * If there are potential migrations, wait for completion and retry
+         * without disrupting NUMA hinting information. Do not relock and
+         * check_same as the page may no longer be mapped.
+         */
+        if (unlikely(pmd_trans_migrating(*pmdp))) {
+                spin_unlock(ptl);
+                wait_migrate_huge_page(vma->anon_vma, pmdp);
+                goto out;
+        }
+
         page = pmd_page(pmd);
         BUG_ON(is_huge_zero_page(page));
         page_nid = page_to_nid(page);
@@ -1323,23 +1342,22 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
                 /* If the page was locked, there are no parallel migrations */
                 if (page_locked)
                         goto clear_pmdnuma;
+        }
 
-                /*
-                 * Otherwise wait for potential migrations and retry. We do
-                 * relock and check_same as the page may no longer be mapped.
-                 * As the fault is being retried, do not account for it.
-                 */
+        /* Migration could have started since the pmd_trans_migrating check */
+        if (!page_locked) {
                 spin_unlock(ptl);
                 wait_on_page_locked(page);
                 page_nid = -1;
                 goto out;
         }
 
-        /* Page is misplaced, serialise migrations and parallel THP splits */
+        /*
+         * Page is misplaced. Page lock serialises migrations. Acquire anon_vma
+         * to serialises splits
+         */
         get_page(page);
         spin_unlock(ptl);
-        if (!page_locked)
-                lock_page(page);
         anon_vma = page_lock_anon_vma_read(page);
 
         /* Confirm the PMD did not change while page_table_lock was released */
@@ -1351,6 +1369,13 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
                 goto out_unlock;
         }
 
+        /* Bail if we fail to protect against THP splits for any reason */
+        if (unlikely(!anon_vma)) {
+                put_page(page);
+                page_nid = -1;
+                goto clear_pmdnuma;
+        }
+
         /*
          * Migrate the THP to the requested node, returns with page unlocked
          * and pmd_numa cleared.
@@ -1517,6 +1542,8 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                 ret = 1;
                 if (!prot_numa) {
                         entry = pmdp_get_and_clear(mm, addr, pmd);
+                        if (pmd_numa(entry))
+                                entry = pmd_mknonnuma(entry);
                         entry = pmd_modify(entry, newprot);
                         ret = HPAGE_PMD_NR;
                         BUG_ON(pmd_write(entry));
@@ -1531,7 +1558,7 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                          */
                         if (!is_huge_zero_page(page) &&
                             !pmd_numa(*pmd)) {
-                                entry = pmdp_get_and_clear(mm, addr, pmd);
+                                entry = *pmd;
                                 entry = pmd_mknuma(entry);
                                 ret = HPAGE_PMD_NR;
                         }
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index b7c171602ba1..db08af92c6fc 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -1505,10 +1505,16 @@ static int soft_offline_huge_page(struct page *page, int flags)
                 if (ret > 0)
                         ret = -EIO;
         } else {
-                set_page_hwpoison_huge_page(hpage);
-                dequeue_hwpoisoned_huge_page(hpage);
-                atomic_long_add(1 << compound_order(hpage),
-                                &num_poisoned_pages);
+                /* overcommit hugetlb page will be freed to buddy */
+                if (PageHuge(page)) {
+                        set_page_hwpoison_huge_page(hpage);
+                        dequeue_hwpoisoned_huge_page(hpage);
+                        atomic_long_add(1 << compound_order(hpage),
+                                        &num_poisoned_pages);
+                } else {
+                        SetPageHWPoison(page);
+                        atomic_long_inc(&num_poisoned_pages);
+                }
         }
         return ret;
 }
diff --git a/mm/memory.c b/mm/memory.c
index 5d9025f3b3e1..6768ce9e57d2 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -4271,7 +4271,7 @@ void copy_user_huge_page(struct page *dst, struct page *src,
 }
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE || CONFIG_HUGETLBFS */
 
-#if USE_SPLIT_PTE_PTLOCKS && BLOATED_SPINLOCKS
+#if USE_SPLIT_PTE_PTLOCKS && ALLOC_SPLIT_PTLOCKS
 bool ptlock_alloc(struct page *page)
 {
         spinlock_t *ptl;
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index eca4a3129129..0cd2c4d4e270 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1197,14 +1197,16 @@ static struct page *new_vma_page(struct page *page, unsigned long private, int *
                         break;
                 vma = vma->vm_next;
         }
+
+        if (PageHuge(page)) {
+                if (vma)
+                        return alloc_huge_page_noerr(vma, address, 1);
+                else
+                        return NULL;
+        }
         /*
-         * queue_pages_range() confirms that @page belongs to some vma,
-         * so vma shouldn't be NULL.
+         * if !vma, alloc_page_vma() will use task or system default policy
          */
-        BUG_ON(!vma);
-
-        if (PageHuge(page))
-                return alloc_huge_page_noerr(vma, address, 1);
         return alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, address);
 }
 #else
@@ -1318,7 +1320,7 @@ static long do_mbind(unsigned long start, unsigned long len,
                 if (nr_failed && (flags & MPOL_MF_STRICT))
                         err = -EIO;
         } else
-                putback_lru_pages(&pagelist);
+                putback_movable_pages(&pagelist);
 
         up_write(&mm->mmap_sem);
  mpol_out:
diff --git a/mm/migrate.c b/mm/migrate.c
index bb940045fe85..9194375b2307 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -36,6 +36,7 @@
 #include <linux/hugetlb_cgroup.h>
 #include <linux/gfp.h>
 #include <linux/balloon_compaction.h>
+#include <linux/mmu_notifier.h>
 
 #include <asm/tlbflush.h>
 
@@ -316,14 +317,15 @@ static inline bool buffer_migrate_lock_buffers(struct buffer_head *head,
  */
 int migrate_page_move_mapping(struct address_space *mapping,
                 struct page *newpage, struct page *page,
-                struct buffer_head *head, enum migrate_mode mode)
+                struct buffer_head *head, enum migrate_mode mode,
+                int extra_count)
 {
-        int expected_count = 0;
+        int expected_count = 1 + extra_count;
         void **pslot;
 
         if (!mapping) {
                 /* Anonymous page without mapping */
-                if (page_count(page) != 1)
+                if (page_count(page) != expected_count)
                         return -EAGAIN;
                 return MIGRATEPAGE_SUCCESS;
         }
@@ -333,7 +335,7 @@ int migrate_page_move_mapping(struct address_space *mapping,
         pslot = radix_tree_lookup_slot(&mapping->page_tree,
                                         page_index(page));
 
-        expected_count = 2 + page_has_private(page);
+        expected_count += 1 + page_has_private(page);
         if (page_count(page) != expected_count ||
                 radix_tree_deref_slot_protected(pslot, &mapping->tree_lock) != page) {
                 spin_unlock_irq(&mapping->tree_lock);
@@ -583,7 +585,7 @@ int migrate_page(struct address_space *mapping,
 
         BUG_ON(PageWriteback(page));    /* Writeback must be complete */
 
-        rc = migrate_page_move_mapping(mapping, newpage, page, NULL, mode);
+        rc = migrate_page_move_mapping(mapping, newpage, page, NULL, mode, 0);
 
         if (rc != MIGRATEPAGE_SUCCESS)
                 return rc;
@@ -610,7 +612,7 @@ int buffer_migrate_page(struct address_space *mapping,
 
         head = page_buffers(page);
 
-        rc = migrate_page_move_mapping(mapping, newpage, page, head, mode);
+        rc = migrate_page_move_mapping(mapping, newpage, page, head, mode, 0);
 
         if (rc != MIGRATEPAGE_SUCCESS)
                 return rc;
@@ -1654,6 +1656,18 @@ int numamigrate_isolate_page(pg_data_t *pgdat, struct page *page)
         return 1;
 }
 
+bool pmd_trans_migrating(pmd_t pmd)
+{
+        struct page *page = pmd_page(pmd);
+        return PageLocked(page);
+}
+
+void wait_migrate_huge_page(struct anon_vma *anon_vma, pmd_t *pmd)
+{
+        struct page *page = pmd_page(*pmd);
+        wait_on_page_locked(page);
+}
+
 /*
  * Attempt to migrate a misplaced page to the specified destination
  * node. Caller is expected to have an elevated reference count on
@@ -1716,12 +1730,14 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
                                 struct page *page, int node)
 {
         spinlock_t *ptl;
-        unsigned long haddr = address & HPAGE_PMD_MASK;
         pg_data_t *pgdat = NODE_DATA(node);
         int isolated = 0;
         struct page *new_page = NULL;
         struct mem_cgroup *memcg = NULL;
         int page_lru = page_is_file_cache(page);
+        unsigned long mmun_start = address & HPAGE_PMD_MASK;
+        unsigned long mmun_end = mmun_start + HPAGE_PMD_SIZE;
+        pmd_t orig_entry;
 
         /*
          * Rate-limit the amount of data that is being migrated to a node.
@@ -1744,6 +1760,9 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
                 goto out_fail;
         }
 
+        if (mm_tlb_flush_pending(mm))
+                flush_tlb_range(vma, mmun_start, mmun_end);
+
         /* Prepare a page as a migration target */
         __set_page_locked(new_page);
         SetPageSwapBacked(new_page);
@@ -1755,9 +1774,12 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
         WARN_ON(PageLRU(new_page));
 
         /* Recheck the target PMD */
+        mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end);
         ptl = pmd_lock(mm, pmd);
-        if (unlikely(!pmd_same(*pmd, entry))) {
+        if (unlikely(!pmd_same(*pmd, entry) || page_count(page) != 2)) {
+fail_putback:
                 spin_unlock(ptl);
+                mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
 
                 /* Reverse changes made by migrate_page_copy() */
                 if (TestClearPageActive(new_page))
@@ -1774,7 +1796,8 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
                 putback_lru_page(page);
                 mod_zone_page_state(page_zone(page),
                          NR_ISOLATED_ANON + page_lru, -HPAGE_PMD_NR);
-                goto out_fail;
+
+                goto out_unlock;
         }
 
         /*
@@ -1786,16 +1809,35 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
          */
         mem_cgroup_prepare_migration(page, new_page, &memcg);
 
+        orig_entry = *pmd;
         entry = mk_pmd(new_page, vma->vm_page_prot);
-        entry = pmd_mknonnuma(entry);
-        entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
         entry = pmd_mkhuge(entry);
+        entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
 
-        pmdp_clear_flush(vma, haddr, pmd);
-        set_pmd_at(mm, haddr, pmd, entry);
-        page_add_new_anon_rmap(new_page, vma, haddr);
+        /*
+         * Clear the old entry under pagetable lock and establish the new PTE.
+         * Any parallel GUP will either observe the old page blocking on the
+         * page lock, block on the page table lock or observe the new page.
+         * The SetPageUptodate on the new page and page_add_new_anon_rmap
+         * guarantee the copy is visible before the pagetable update.
+         */
+        flush_cache_range(vma, mmun_start, mmun_end);
+        page_add_new_anon_rmap(new_page, vma, mmun_start);
+        pmdp_clear_flush(vma, mmun_start, pmd);
+        set_pmd_at(mm, mmun_start, pmd, entry);
+        flush_tlb_range(vma, mmun_start, mmun_end);
         update_mmu_cache_pmd(vma, address, &entry);
+
+        if (page_count(page) != 2) {
+                set_pmd_at(mm, mmun_start, pmd, orig_entry);
+                flush_tlb_range(vma, mmun_start, mmun_end);
+                update_mmu_cache_pmd(vma, address, &entry);
+                page_remove_rmap(new_page);
+                goto fail_putback;
+        }
+
         page_remove_rmap(page);
+
         /*
          * Finish the charge transaction under the page table lock to
          * prevent split_huge_page() from dividing up the charge
@@ -1803,6 +1845,7 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
          */
         mem_cgroup_end_migration(memcg, page, new_page, true);
         spin_unlock(ptl);
+        mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
 
         unlock_page(new_page);
         unlock_page(page);
@@ -1820,10 +1863,15 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,
 out_fail:
         count_vm_events(PGMIGRATE_FAIL, HPAGE_PMD_NR);
 out_dropref:
-        entry = pmd_mknonnuma(entry);
-        set_pmd_at(mm, haddr, pmd, entry);
-        update_mmu_cache_pmd(vma, address, &entry);
+        ptl = pmd_lock(mm, pmd);
+        if (pmd_same(*pmd, entry)) {
+                entry = pmd_mknonnuma(entry);
+                set_pmd_at(mm, mmun_start, pmd, entry);
+                update_mmu_cache_pmd(vma, address, &entry);
+        }
+        spin_unlock(ptl);
 
+out_unlock:
         unlock_page(page);
         put_page(page);
         return 0;
diff --git a/mm/mprotect.c b/mm/mprotect.c
index 26667971c824..bb53a6591aea 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -52,17 +52,21 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
                         pte_t ptent;
                         bool updated = false;
 
-                        ptent = ptep_modify_prot_start(mm, addr, pte);
                         if (!prot_numa) {
+                                ptent = ptep_modify_prot_start(mm, addr, pte);
+                                if (pte_numa(ptent))
+                                        ptent = pte_mknonnuma(ptent);
                                 ptent = pte_modify(ptent, newprot);
                                 updated = true;
                         } else {
                                 struct page *page;
 
+                                ptent = *pte;
                                 page = vm_normal_page(vma, addr, oldpte);
                                 if (page) {
                                         if (!pte_numa(oldpte)) {
                                                 ptent = pte_mknuma(ptent);
+                                                set_pte_at(mm, addr, pte, ptent);
                                                 updated = true;
                                         }
                                 }
@@ -79,7 +83,10 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
 
                         if (updated)
                                 pages++;
-                        ptep_modify_prot_commit(mm, addr, pte, ptent);
+
+                        /* Only !prot_numa always clears the pte */
+                        if (!prot_numa)
+                                ptep_modify_prot_commit(mm, addr, pte, ptent);
                 } else if (IS_ENABLED(CONFIG_MIGRATION) && !pte_file(oldpte)) {
                         swp_entry_t entry = pte_to_swp_entry(oldpte);
 
@@ -181,6 +188,7 @@ static unsigned long change_protection_range(struct vm_area_struct *vma,
         BUG_ON(addr >= end);
         pgd = pgd_offset(mm, addr);
         flush_cache_range(vma, addr, end);
+        set_tlb_flush_pending(mm);
         do {
                 next = pgd_addr_end(addr, end);
                 if (pgd_none_or_clear_bad(pgd))
@@ -192,6 +200,7 @@ static unsigned long change_protection_range(struct vm_area_struct *vma,
         /* Only flush the TLB if we actually modified any entries: */
         if (pages)
                 flush_tlb_range(vma, start, end);
+        clear_tlb_flush_pending(mm);
 
         return pages;
 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 580a5f075ed0..5248fe070aa4 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1816,7 +1816,7 @@ static void zlc_clear_zones_full(struct zonelist *zonelist)
 
 static bool zone_local(struct zone *local_zone, struct zone *zone)
 {
-        return node_distance(local_zone->node, zone->node) == LOCAL_DISTANCE;
+        return local_zone->node == zone->node;
 }
 
 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
@@ -1913,18 +1913,17 @@ zonelist_scan:
                  * page was allocated in should have no effect on the
                  * time the page has in memory before being reclaimed.
                  *
-                 * When zone_reclaim_mode is enabled, try to stay in
-                 * local zones in the fastpath.  If that fails, the
-                 * slowpath is entered, which will do another pass
-                 * starting with the local zones, but ultimately fall
-                 * back to remote zones that do not partake in the
-                 * fairness round-robin cycle of this zonelist.
+                 * Try to stay in local zones in the fastpath.  If
+                 * that fails, the slowpath is entered, which will do
+                 * another pass starting with the local zones, but
+                 * ultimately fall back to remote zones that do not
+                 * partake in the fairness round-robin cycle of this
+                 * zonelist.
                  */
                 if (alloc_flags & ALLOC_WMARK_LOW) {
                         if (zone_page_state(zone, NR_ALLOC_BATCH) <= 0)
                                 continue;
-                        if (zone_reclaim_mode &&
-                            !zone_local(preferred_zone, zone))
+                        if (!zone_local(preferred_zone, zone))
                                 continue;
                 }
                 /*
@@ -2390,7 +2389,7 @@ static void prepare_slowpath(gfp_t gfp_mask, unsigned int order,
                  * thrash fairness information for zones that are not
                  * actually part of this zonelist's round-robin cycle.
                  */
-                if (zone_reclaim_mode && !zone_local(preferred_zone, zone))
+                if (!zone_local(preferred_zone, zone))
                         continue;
                 mod_zone_page_state(zone, NR_ALLOC_BATCH,
                                     high_wmark_pages(zone) -
diff --git a/mm/pgtable-generic.c b/mm/pgtable-generic.c
index cbb38545d9d6..a8b919925934 100644
--- a/mm/pgtable-generic.c
+++ b/mm/pgtable-generic.c
@@ -110,9 +110,10 @@ int pmdp_clear_flush_young(struct vm_area_struct *vma,
 pte_t ptep_clear_flush(struct vm_area_struct *vma, unsigned long address,
                        pte_t *ptep)
 {
+        struct mm_struct *mm = (vma)->vm_mm;
         pte_t pte;
-        pte = ptep_get_and_clear((vma)->vm_mm, address, ptep);
-        if (pte_accessible(pte))
+        pte = ptep_get_and_clear(mm, address, ptep);
+        if (pte_accessible(mm, pte))
                 flush_tlb_page(vma, address);
         return pte;
 }
@@ -191,6 +192,9 @@ pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp)
 void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
                      pmd_t *pmdp)
 {
+        pmd_t entry = *pmdp;
+        if (pmd_numa(entry))
+                entry = pmd_mknonnuma(entry);
         set_pmd_at(vma->vm_mm, address, pmdp, pmd_mknotpresent(*pmdp));
         flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
 }
diff --git a/mm/rmap.c b/mm/rmap.c
index 55c8b8dc9ffb..068522d8502a 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -600,7 +600,11 @@ pte_t *__page_check_address(struct page *page, struct mm_struct *mm,
         spinlock_t *ptl;
 
         if (unlikely(PageHuge(page))) {
+                /* when pud is not present, pte will be NULL */
                 pte = huge_pte_offset(mm, address);
+                if (!pte)
+                        return NULL;
+
                 ptl = huge_pte_lockptr(page_hstate(page), mm, pte);
                 goto check;
         }
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index ca15f32821fb..36b1443f9ae4 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1161,6 +1161,7 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
                                                  neigh->parms->reachable_time :
                                                  0)));
                 neigh->nud_state = new;
+                notify = 1;
         }
 
         if (lladdr != neigh->ha) {
diff --git a/net/ipv4/netfilter/ipt_SYNPROXY.c b/net/ipv4/netfilter/ipt_SYNPROXY.c
index f13bd91d9a56..a313c3fbeb46 100644
--- a/net/ipv4/netfilter/ipt_SYNPROXY.c
+++ b/net/ipv4/netfilter/ipt_SYNPROXY.c
@@ -423,6 +423,7 @@ static void synproxy_tg4_destroy(const struct xt_tgdtor_param *par)
 static struct xt_target synproxy_tg4_reg __read_mostly = {
         .name           = "SYNPROXY",
         .family         = NFPROTO_IPV4,
+        .hooks          = (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD),
         .target         = synproxy_tg4,
         .targetsize     = sizeof(struct xt_synproxy_info),
         .checkentry     = synproxy_tg4_check,
diff --git a/net/ipv4/netfilter/nft_reject_ipv4.c b/net/ipv4/netfilter/nft_reject_ipv4.c
index fff5ba1a33b7..4a5e94ac314a 100644
--- a/net/ipv4/netfilter/nft_reject_ipv4.c
+++ b/net/ipv4/netfilter/nft_reject_ipv4.c
@@ -72,7 +72,7 @@ static int nft_reject_dump(struct sk_buff *skb, const struct nft_expr *expr)
 {
         const struct nft_reject *priv = nft_expr_priv(expr);
 
-        if (nla_put_be32(skb, NFTA_REJECT_TYPE, priv->type))
+        if (nla_put_be32(skb, NFTA_REJECT_TYPE, htonl(priv->type)))
                 goto nla_put_failure;
 
         switch (priv->type) {
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 62c19fdd102d..f140048334ce 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1600,20 +1600,15 @@ static void flush_stack(struct sock **stack, unsigned int count,
 }
 
 /* For TCP sockets, sk_rx_dst is protected by socket lock
- * For UDP, we use sk_dst_lock to guard against concurrent changes.
+ * For UDP, we use xchg() to guard against concurrent changes.
  */
 static void udp_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst)
 {
         struct dst_entry *old;
 
-        spin_lock(&sk->sk_dst_lock);
-        old = sk->sk_rx_dst;
-        if (likely(old != dst)) {
-                dst_hold(dst);
-                sk->sk_rx_dst = dst;
-                dst_release(old);
-        }
-        spin_unlock(&sk->sk_dst_lock);
+        dst_hold(dst);
+        old = xchg(&sk->sk_rx_dst, dst);
+        dst_release(old);
 }
 
 /*
diff --git a/net/ipv6/netfilter/ip6t_SYNPROXY.c b/net/ipv6/netfilter/ip6t_SYNPROXY.c
index f78f41aca8e9..a0d17270117c 100644
--- a/net/ipv6/netfilter/ip6t_SYNPROXY.c
+++ b/net/ipv6/netfilter/ip6t_SYNPROXY.c
@@ -446,6 +446,7 @@ static void synproxy_tg6_destroy(const struct xt_tgdtor_param *par)
 static struct xt_target synproxy_tg6_reg __read_mostly = {
         .name           = "SYNPROXY",
         .family         = NFPROTO_IPV6,
+        .hooks          = (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD),
         .target         = synproxy_tg6,
         .targetsize     = sizeof(struct xt_synproxy_info),
         .checkentry     = synproxy_tg6_check,
diff --git a/net/sctp/probe.c b/net/sctp/probe.c
index 53c452efb40b..5e68b94ee640 100644
--- a/net/sctp/probe.c
+++ b/net/sctp/probe.c
@@ -38,6 +38,7 @@
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
 
+MODULE_SOFTDEP("pre: sctp");
 MODULE_AUTHOR("Wei Yongjun <yjwei@cn.fujitsu.com>");
 MODULE_DESCRIPTION("SCTP snooper");
 MODULE_LICENSE("GPL");
@@ -182,6 +183,20 @@ static struct jprobe sctp_recv_probe = {
         .entry  = jsctp_sf_eat_sack,
 };
 
+static __init int sctp_setup_jprobe(void)
+{
+        int ret = register_jprobe(&sctp_recv_probe);
+
+        if (ret) {
+                if (request_module("sctp"))
+                        goto out;
+                ret = register_jprobe(&sctp_recv_probe);
+        }
+
+out:
+        return ret;
+}
+
 static __init int sctpprobe_init(void)
 {
         int ret = -ENOMEM;
@@ -202,7 +217,7 @@ static __init int sctpprobe_init(void)
                          &sctpprobe_fops))
                 goto free_kfifo;
 
-        ret = register_jprobe(&sctp_recv_probe);
+        ret = sctp_setup_jprobe();
         if (ret)
                 goto remove_proc;
 
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index a0ca162e5bd5..a427623ee574 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -718,7 +718,9 @@ static int unix_autobind(struct socket *sock)
         int err;
         unsigned int retries = 0;
 
-        mutex_lock(&u->readlock);
+        err = mutex_lock_interruptible(&u->readlock);
+        if (err)
+                return err;
 
         err = 0;
         if (u->addr)
@@ -877,7 +879,9 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                 goto out;
         addr_len = err;
 
-        mutex_lock(&u->readlock);
+        err = mutex_lock_interruptible(&u->readlock);
+        if (err)
+                goto out;
 
         err = -EINVAL;
         if (u->addr)
diff --git a/scripts/link-vmlinux.sh b/scripts/link-vmlinux.sh
index 32b10f53d0b4..2dcb37736d84 100644
--- a/scripts/link-vmlinux.sh
+++ b/scripts/link-vmlinux.sh
@@ -82,7 +82,9 @@ kallsyms()
                 kallsymopt="${kallsymopt} --all-symbols"
         fi
 
-        kallsymopt="${kallsymopt} --page-offset=$CONFIG_PAGE_OFFSET"
+        if [ -n "${CONFIG_ARM}" ] && [ -n "${CONFIG_PAGE_OFFSET}" ]; then
+                kallsymopt="${kallsymopt} --page-offset=$CONFIG_PAGE_OFFSET"
+        fi
 
         local aflags="${KBUILD_AFLAGS} ${KBUILD_AFLAGS_KERNEL}               \
                       ${NOSTDINC_FLAGS} ${LINUXINCLUDE} ${KBUILD_CPPFLAGS}"
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 419491d8e7d2..6625699f497c 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -4334,8 +4334,10 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
                 }
                 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
                                    PEER__RECV, &ad);
-                if (err)
+                if (err) {
                         selinux_netlbl_err(skb, err, 0);
+                        return err;
+                }
         }
 
         if (secmark_active) {
@@ -5586,11 +5588,11 @@ static int selinux_setprocattr(struct task_struct *p,
                 /* Check for ptracing, and update the task SID if ok.
                    Otherwise, leave SID unchanged and fail. */
                 ptsid = 0;
-                task_lock(p);
+                rcu_read_lock();
                 tracer = ptrace_parent(p);
                 if (tracer)
                         ptsid = task_sid(tracer);
-                task_unlock(p);
+                rcu_read_unlock();
 
                 if (tracer) {
                         error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index 5138b8493051..d62ce483a443 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -31,8 +31,10 @@ config SND_SOC_GENERIC_DMAENGINE_PCM
         select SND_DMAENGINE_PCM
 
 # All the supported SoCs
+source "sound/soc/adi/Kconfig"
 source "sound/soc/atmel/Kconfig"
 source "sound/soc/au1x/Kconfig"
+source "sound/soc/bcm/Kconfig"
 source "sound/soc/blackfin/Kconfig"
 source "sound/soc/cirrus/Kconfig"
 source "sound/soc/davinci/Kconfig"
@@ -42,7 +44,7 @@ source "sound/soc/jz4740/Kconfig"
 source "sound/soc/nuc900/Kconfig"
 source "sound/soc/omap/Kconfig"
 source "sound/soc/kirkwood/Kconfig"
-source "sound/soc/mid-x86/Kconfig"
+source "sound/soc/intel/Kconfig"
 source "sound/soc/mxs/Kconfig"
 source "sound/soc/pxa/Kconfig"
 source "sound/soc/samsung/Kconfig"
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 8b9e70105dd2..62a1822e77bf 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -8,15 +8,17 @@ endif
 obj-$(CONFIG_SND_SOC)   += snd-soc-core.o
 obj-$(CONFIG_SND_SOC)   += codecs/
 obj-$(CONFIG_SND_SOC)   += generic/
+obj-$(CONFIG_SND_SOC)   += adi/
 obj-$(CONFIG_SND_SOC)   += atmel/
 obj-$(CONFIG_SND_SOC)   += au1x/
+obj-$(CONFIG_SND_SOC)   += bcm/
 obj-$(CONFIG_SND_SOC)   += blackfin/
 obj-$(CONFIG_SND_SOC)   += cirrus/
 obj-$(CONFIG_SND_SOC)   += davinci/
 obj-$(CONFIG_SND_SOC)   += dwc/
 obj-$(CONFIG_SND_SOC)   += fsl/
 obj-$(CONFIG_SND_SOC)   += jz4740/
-obj-$(CONFIG_SND_SOC)   += mid-x86/
+obj-$(CONFIG_SND_SOC)   += intel/
 obj-$(CONFIG_SND_SOC)   += mxs/
 obj-$(CONFIG_SND_SOC)   += nuc900/
 obj-$(CONFIG_SND_SOC)   += omap/
diff --git a/sound/soc/adi/Kconfig b/sound/soc/adi/Kconfig
new file mode 100644
index 000000000000..dd763f55edac
--- /dev/null
+++ b/sound/soc/adi/Kconfig
@@ -0,0 +1,21 @@
+config SND_SOC_ADI
+        tristate "Audio support for Analog Devices reference designs"
+        depends on MICROBLAZE || ARCH_ZYNQ || COMPILE_TEST
+        help
+          Audio support for various reference designs by Analog Devices.
+
+config SND_SOC_ADI_AXI_I2S
+        tristate "AXI-I2S support"
+        depends on SND_SOC_ADI
+        select SND_SOC_GENERIC_DMAENGINE_PCM
+        select REGMAP_MMIO
+        help
+          ASoC driver for the Analog Devices AXI-I2S softcore peripheral.
+
+config SND_SOC_ADI_AXI_SPDIF
+        tristate "AXI-SPDIF support"
+        depends on SND_SOC_ADI
+        select SND_SOC_GENERIC_DMAENGINE_PCM
+        select REGMAP_MMIO
+        help
+          ASoC driver for the Analog Devices AXI-SPDIF softcore peripheral.
diff --git a/sound/soc/adi/Makefile b/sound/soc/adi/Makefile
new file mode 100644
index 000000000000..64456c1e5347
--- /dev/null
+++ b/sound/soc/adi/Makefile
@@ -0,0 +1,5 @@
+snd-soc-adi-axi-i2s-objs := axi-i2s.o
+snd-soc-adi-axi-spdif-objs := axi-spdif.o
+
+obj-$(CONFIG_SND_SOC_ADI_AXI_I2S) += snd-soc-adi-axi-i2s.o
+obj-$(CONFIG_SND_SOC_ADI_AXI_SPDIF) += snd-soc-adi-axi-spdif.o
diff --git a/sound/soc/adi/axi-i2s.c b/sound/soc/adi/axi-i2s.c
new file mode 100644
index 000000000000..7f91a86dd734
--- /dev/null
+++ b/sound/soc/adi/axi-i2s.c
@@ -0,0 +1,277 @@
+/*
+ * Copyright (C) 2012-2013, Analog Devices Inc.
+ * Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/clk.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
+
+#define AXI_I2S_REG_RESET       0x00
+#define AXI_I2S_REG_CTRL        0x04
+#define AXI_I2S_REG_CLK_CTRL    0x08
+#define AXI_I2S_REG_STATUS      0x10
+
+#define AXI_I2S_REG_RX_FIFO     0x28
+#define AXI_I2S_REG_TX_FIFO     0x2C
+
+#define AXI_I2S_RESET_GLOBAL    BIT(0)
+#define AXI_I2S_RESET_TX_FIFO   BIT(1)
+#define AXI_I2S_RESET_RX_FIFO   BIT(2)
+
+#define AXI_I2S_CTRL_TX_EN      BIT(0)
+#define AXI_I2S_CTRL_RX_EN      BIT(1)
+
+/* The frame size is configurable, but for now we always set it 64 bit */
+#define AXI_I2S_BITS_PER_FRAME 64
+
+struct axi_i2s {
+        struct regmap *regmap;
+        struct clk *clk;
+        struct clk *clk_ref;
+
+        struct snd_soc_dai_driver dai_driver;
+
+        struct snd_dmaengine_dai_dma_data capture_dma_data;
+        struct snd_dmaengine_dai_dma_data playback_dma_data;
+
+        struct snd_ratnum ratnum;
+        struct snd_pcm_hw_constraint_ratnums rate_constraints;
+};
+
+static int axi_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
+        struct snd_soc_dai *dai)
+{
+        struct axi_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+        unsigned int mask, val;
+
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                mask = AXI_I2S_CTRL_RX_EN;
+        else
+                mask = AXI_I2S_CTRL_TX_EN;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                val = mask;
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                val = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        regmap_update_bits(i2s->regmap, AXI_I2S_REG_CTRL, mask, val);
+
+        return 0;
+}
+
+static int axi_i2s_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
+{
+        struct axi_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+        unsigned int bclk_div, word_size;
+        unsigned int bclk_rate;
+
+        bclk_rate = params_rate(params) * AXI_I2S_BITS_PER_FRAME;
+
+        word_size = AXI_I2S_BITS_PER_FRAME / 2 - 1;
+        bclk_div = DIV_ROUND_UP(clk_get_rate(i2s->clk_ref), bclk_rate) / 2 - 1;
+
+        regmap_write(i2s->regmap, AXI_I2S_REG_CLK_CTRL, (word_size << 16) |
+                bclk_div);
+
+        return 0;
+}
+
+static int axi_i2s_startup(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct axi_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+        uint32_t mask;
+        int ret;
+
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                mask = AXI_I2S_RESET_RX_FIFO;
+        else
+                mask = AXI_I2S_RESET_TX_FIFO;
+
+        regmap_write(i2s->regmap, AXI_I2S_REG_RESET, mask);
+
+        ret = snd_pcm_hw_constraint_ratnums(substream->runtime, 0,
+                           SNDRV_PCM_HW_PARAM_RATE,
+                           &i2s->rate_constraints);
+        if (ret)
+                return ret;
+
+        return clk_prepare_enable(i2s->clk_ref);
+}
+
+static void axi_i2s_shutdown(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct axi_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+
+        clk_disable_unprepare(i2s->clk_ref);
+}
+
+static int axi_i2s_dai_probe(struct snd_soc_dai *dai)
+{
+        struct axi_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+
+        snd_soc_dai_init_dma_data(dai, &i2s->playback_dma_data,
+                &i2s->capture_dma_data);
+
+        return 0;
+}
+
+static const struct snd_soc_dai_ops axi_i2s_dai_ops = {
+        .startup = axi_i2s_startup,
+        .shutdown = axi_i2s_shutdown,
+        .trigger = axi_i2s_trigger,
+        .hw_params = axi_i2s_hw_params,
+};
+
+static struct snd_soc_dai_driver axi_i2s_dai = {
+        .probe = axi_i2s_dai_probe,
+        .playback = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_KNOT,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_U32_LE,
+        },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_KNOT,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_U32_LE,
+        },
+        .ops = &axi_i2s_dai_ops,
+        .symmetric_rates = 1,
+};
+
+static const struct snd_soc_component_driver axi_i2s_component = {
+        .name = "axi-i2s",
+};
+
+static const struct regmap_config axi_i2s_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .max_register = AXI_I2S_REG_STATUS,
+};
+
+static int axi_i2s_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct axi_i2s *i2s;
+        void __iomem *base;
+        int ret;
+
+        i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
+        if (!i2s)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, i2s);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
+
+        i2s->regmap = devm_regmap_init_mmio(&pdev->dev, base,
+                &axi_i2s_regmap_config);
+        if (IS_ERR(i2s->regmap))
+                return PTR_ERR(i2s->regmap);
+
+        i2s->clk = devm_clk_get(&pdev->dev, "axi");
+        if (IS_ERR(i2s->clk))
+                return PTR_ERR(i2s->clk);
+
+        i2s->clk_ref = devm_clk_get(&pdev->dev, "ref");
+        if (IS_ERR(i2s->clk_ref))
+                return PTR_ERR(i2s->clk_ref);
+
+        ret = clk_prepare_enable(i2s->clk);
+        if (ret)
+                return ret;
+
+        i2s->playback_dma_data.addr = res->start + AXI_I2S_REG_TX_FIFO;
+        i2s->playback_dma_data.addr_width = 4;
+        i2s->playback_dma_data.maxburst = 1;
+
+        i2s->capture_dma_data.addr = res->start + AXI_I2S_REG_RX_FIFO;
+        i2s->capture_dma_data.addr_width = 4;
+        i2s->capture_dma_data.maxburst = 1;
+
+        i2s->ratnum.num = clk_get_rate(i2s->clk_ref) / 2 / AXI_I2S_BITS_PER_FRAME;
+        i2s->ratnum.den_step = 1;
+        i2s->ratnum.den_min = 1;
+        i2s->ratnum.den_max = 64;
+
+        i2s->rate_constraints.rats = &i2s->ratnum;
+        i2s->rate_constraints.nrats = 1;
+
+        regmap_write(i2s->regmap, AXI_I2S_REG_RESET, AXI_I2S_RESET_GLOBAL);
+
+        ret = devm_snd_soc_register_component(&pdev->dev, &axi_i2s_component,
+                                         &axi_i2s_dai, 1);
+        if (ret)
+                goto err_clk_disable;
+
+        ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
+                        SND_DMAENGINE_PCM_FLAG_NO_RESIDUE);
+        if (ret)
+                goto err_clk_disable;
+
+err_clk_disable:
+        clk_disable_unprepare(i2s->clk);
+        return ret;
+}
+
+static int axi_i2s_dev_remove(struct platform_device *pdev)
+{
+        struct axi_i2s *i2s = platform_get_drvdata(pdev);
+
+        clk_disable_unprepare(i2s->clk);
+
+        return 0;
+}
+
+static const struct of_device_id axi_i2s_of_match[] = {
+        { .compatible = "adi,axi-i2s-1.00.a", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, axi_i2s_of_match);
+
+static struct platform_driver axi_i2s_driver = {
+        .driver = {
+                .name = "axi-i2s",
+                .owner = THIS_MODULE,
+                .of_match_table = axi_i2s_of_match,
+        },
+        .probe = axi_i2s_probe,
+        .remove = axi_i2s_dev_remove,
+};
+module_platform_driver(axi_i2s_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("AXI I2S driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/adi/axi-spdif.c b/sound/soc/adi/axi-spdif.c
new file mode 100644
index 000000000000..8db7a9920695
--- /dev/null
+++ b/sound/soc/adi/axi-spdif.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2012-2013, Analog Devices Inc.
+ * Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/clk.h>
+#include <linux/regmap.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/initval.h>
+#include <sound/dmaengine_pcm.h>
+
+#define AXI_SPDIF_REG_CTRL      0x0
+#define AXI_SPDIF_REG_STAT      0x4
+#define AXI_SPDIF_REG_TX_FIFO   0xc
+
+#define AXI_SPDIF_CTRL_TXDATA BIT(1)
+#define AXI_SPDIF_CTRL_TXEN BIT(0)
+#define AXI_SPDIF_CTRL_CLKDIV_OFFSET 8
+#define AXI_SPDIF_CTRL_CLKDIV_MASK (0xff << 8)
+
+#define AXI_SPDIF_FREQ_44100    (0x0 << 6)
+#define AXI_SPDIF_FREQ_48000    (0x1 << 6)
+#define AXI_SPDIF_FREQ_32000    (0x2 << 6)
+#define AXI_SPDIF_FREQ_NA       (0x3 << 6)
+
+struct axi_spdif {
+        struct regmap *regmap;
+        struct clk *clk;
+        struct clk *clk_ref;
+
+        struct snd_dmaengine_dai_dma_data dma_data;
+
+        struct snd_ratnum ratnum;
+        struct snd_pcm_hw_constraint_ratnums rate_constraints;
+};
+
+static int axi_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
+        struct snd_soc_dai *dai)
+{
+        struct axi_spdif *spdif = snd_soc_dai_get_drvdata(dai);
+        unsigned int val;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                val = AXI_SPDIF_CTRL_TXDATA;
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                val = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL,
+                AXI_SPDIF_CTRL_TXDATA, val);
+
+        return 0;
+}
+
+static int axi_spdif_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
+{
+        struct axi_spdif *spdif = snd_soc_dai_get_drvdata(dai);
+        unsigned int rate = params_rate(params);
+        unsigned int clkdiv, stat;
+
+        switch (params_rate(params)) {
+        case 32000:
+                stat = AXI_SPDIF_FREQ_32000;
+                break;
+        case 44100:
+                stat = AXI_SPDIF_FREQ_44100;
+                break;
+        case 48000:
+                stat = AXI_SPDIF_FREQ_48000;
+                break;
+        default:
+                stat = AXI_SPDIF_FREQ_NA;
+                break;
+        }
+
+        clkdiv = DIV_ROUND_CLOSEST(clk_get_rate(spdif->clk_ref),
+                        rate * 64 * 2) - 1;
+        clkdiv <<= AXI_SPDIF_CTRL_CLKDIV_OFFSET;
+
+        regmap_write(spdif->regmap, AXI_SPDIF_REG_STAT, stat);
+        regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL,
+                AXI_SPDIF_CTRL_CLKDIV_MASK, clkdiv);
+
+        return 0;
+}
+
+static int axi_spdif_dai_probe(struct snd_soc_dai *dai)
+{
+        struct axi_spdif *spdif = snd_soc_dai_get_drvdata(dai);
+
+        snd_soc_dai_init_dma_data(dai, &spdif->dma_data, NULL);
+
+        return 0;
+}
+
+static int axi_spdif_startup(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct axi_spdif *spdif = snd_soc_dai_get_drvdata(dai);
+        int ret;
+
+        ret = snd_pcm_hw_constraint_ratnums(substream->runtime, 0,
+                           SNDRV_PCM_HW_PARAM_RATE,
+                           &spdif->rate_constraints);
+        if (ret)
+                return ret;
+
+        ret = clk_prepare_enable(spdif->clk_ref);
+        if (ret)
+                return ret;
+
+        regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL,
+                AXI_SPDIF_CTRL_TXEN, AXI_SPDIF_CTRL_TXEN);
+
+        return 0;
+}
+
+static void axi_spdif_shutdown(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct axi_spdif *spdif = snd_soc_dai_get_drvdata(dai);
+
+        regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL,
+                AXI_SPDIF_CTRL_TXEN, 0);
+
+        clk_disable_unprepare(spdif->clk_ref);
+}
+
+static const struct snd_soc_dai_ops axi_spdif_dai_ops = {
+        .startup = axi_spdif_startup,
+        .shutdown = axi_spdif_shutdown,
+        .trigger = axi_spdif_trigger,
+        .hw_params = axi_spdif_hw_params,
+};
+
+static struct snd_soc_dai_driver axi_spdif_dai = {
+        .probe = axi_spdif_dai_probe,
+        .playback = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_KNOT,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .ops = &axi_spdif_dai_ops,
+};
+
+static const struct snd_soc_component_driver axi_spdif_component = {
+        .name = "axi-spdif",
+};
+
+static const struct regmap_config axi_spdif_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .max_register = AXI_SPDIF_REG_STAT,
+};
+
+static int axi_spdif_probe(struct platform_device *pdev)
+{
+        struct axi_spdif *spdif;
+        struct resource *res;
+        void __iomem *base;
+        int ret;
+
+        spdif = devm_kzalloc(&pdev->dev, sizeof(*spdif), GFP_KERNEL);
+        if (!spdif)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, spdif);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
+
+        spdif->regmap = devm_regmap_init_mmio(&pdev->dev, base,
+                                            &axi_spdif_regmap_config);
+        if (IS_ERR(spdif->regmap))
+                return PTR_ERR(spdif->regmap);
+
+        spdif->clk = devm_clk_get(&pdev->dev, "axi");
+        if (IS_ERR(spdif->clk))
+                return PTR_ERR(spdif->clk);
+
+        spdif->clk_ref = devm_clk_get(&pdev->dev, "ref");
+        if (IS_ERR(spdif->clk_ref))
+                return PTR_ERR(spdif->clk_ref);
+
+        ret = clk_prepare_enable(spdif->clk);
+        if (ret)
+                return ret;
+
+        spdif->dma_data.addr = res->start + AXI_SPDIF_REG_TX_FIFO;
+        spdif->dma_data.addr_width = 4;
+        spdif->dma_data.maxburst = 1;
+
+        spdif->ratnum.num = clk_get_rate(spdif->clk_ref) / 128;
+        spdif->ratnum.den_step = 1;
+        spdif->ratnum.den_min = 1;
+        spdif->ratnum.den_max = 64;
+
+        spdif->rate_constraints.rats = &spdif->ratnum;
+        spdif->rate_constraints.nrats = 1;
+
+        ret = devm_snd_soc_register_component(&pdev->dev, &axi_spdif_component,
+                                         &axi_spdif_dai, 1);
+        if (ret)
+                goto err_clk_disable;
+
+        ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
+                        SND_DMAENGINE_PCM_FLAG_NO_RESIDUE);
+        if (ret)
+                goto err_clk_disable;
+
+        return 0;
+
+err_clk_disable:
+        clk_disable_unprepare(spdif->clk);
+        return ret;
+}
+
+static int axi_spdif_dev_remove(struct platform_device *pdev)
+{
+        struct axi_spdif *spdif = platform_get_drvdata(pdev);
+
+        clk_disable_unprepare(spdif->clk);
+
+        return 0;
+}
+
+static const struct of_device_id axi_spdif_of_match[] = {
+        { .compatible = "adi,axi-spdif-tx-1.00.a", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, axi_spdif_of_match);
+
+static struct platform_driver axi_spdif_driver = {
+        .driver = {
+                .name = "axi-spdif",
+                .owner = THIS_MODULE,
+                .of_match_table = axi_spdif_of_match,
+        },
+        .probe = axi_spdif_probe,
+        .remove = axi_spdif_dev_remove,
+};
+module_platform_driver(axi_spdif_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("AXI SPDIF driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/atmel/sam9x5_wm8731.c b/sound/soc/atmel/sam9x5_wm8731.c
index 7d6a9055874b..3188036a18f0 100644
--- a/sound/soc/atmel/sam9x5_wm8731.c
+++ b/sound/soc/atmel/sam9x5_wm8731.c
@@ -155,8 +155,6 @@ static int sam9x5_wm8731_driver_probe(struct platform_device *pdev)
         of_node_put(codec_np);
         of_node_put(cpu_np);
 
-        platform_set_drvdata(pdev, card);
-
         ret = snd_soc_register_card(card);
         if (ret) {
                 dev_err(&pdev->dev,
diff --git a/sound/soc/au1x/dbdma2.c b/sound/soc/au1x/dbdma2.c
index 3b4eafaf30d3..17a24d804734 100644
--- a/sound/soc/au1x/dbdma2.c
+++ b/sound/soc/au1x/dbdma2.c
@@ -65,19 +65,10 @@ struct au1xpsc_audio_dmadata {
 #define AU1XPSC_PERIOD_MIN_BYTES        1024
 #define AU1XPSC_BUFFER_MIN_BYTES        65536
 
-#define AU1XPSC_PCM_FMTS                                        \
-        (SNDRV_PCM_FMTBIT_S8     | SNDRV_PCM_FMTBIT_U8 |        \
-         SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |    \
-         SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE |    \
-         SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE |    \
-         SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE |    \
-         0)
-
 /* PCM hardware DMA capabilities - platform specific */
 static const struct snd_pcm_hardware au1xpsc_pcm_hardware = {
         .info             = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                             SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BATCH,
-        .formats          = AU1XPSC_PCM_FMTS,
         .period_bytes_min = AU1XPSC_PERIOD_MIN_BYTES,
         .period_bytes_max = 4096 * 1024 - 1,
         .periods_min      = 2,
diff --git a/sound/soc/au1x/dma.c b/sound/soc/au1x/dma.c
index befd1074f9bd..e920b60bf6c2 100644
--- a/sound/soc/au1x/dma.c
+++ b/sound/soc/au1x/dma.c
@@ -21,14 +21,6 @@
 
 #include "psc.h"
 
-#define ALCHEMY_PCM_FMTS                                        \
-        (SNDRV_PCM_FMTBIT_S8     | SNDRV_PCM_FMTBIT_U8 |        \
-         SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |    \
-         SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE |    \
-         SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE |    \
-         SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE |    \
-         0)
-
 struct pcm_period {
         u32 start;
         u32 relative_end;       /* relative to start of buffer */
@@ -171,12 +163,6 @@ static irqreturn_t au1000_dma_interrupt(int irq, void *ptr)
 static const struct snd_pcm_hardware alchemy_pcm_hardware = {
         .info             = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                             SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BATCH,
-        .formats          = ALCHEMY_PCM_FMTS,
-        .rates            = SNDRV_PCM_RATE_8000_192000,
-        .rate_min         = SNDRV_PCM_RATE_8000,
-        .rate_max         = SNDRV_PCM_RATE_192000,
-        .channels_min     = 2,
-        .channels_max     = 2,
         .period_bytes_min = 1024,
         .period_bytes_max = 16 * 1024 - 1,
         .periods_min      = 4,
diff --git a/sound/soc/bcm/Kconfig b/sound/soc/bcm/Kconfig
new file mode 100644
index 000000000000..3d82a29ce3a8
--- /dev/null
+++ b/sound/soc/bcm/Kconfig
@@ -0,0 +1,10 @@
+config SND_BCM2835_SOC_I2S
+        tristate "SoC Audio support for the Broadcom BCM2835 I2S module"
+        depends on ARCH_BCM2835 || COMPILE_TEST
+        select SND_SOC_DMAENGINE_PCM
+        select SND_SOC_GENERIC_DMAENGINE_PCM
+        select REGMAP_MMIO
+        help
+          Say Y or M if you want to add support for codecs attached to
+          the BCM2835 I2S interface. You will also need
+          to select the audio interfaces to support below.
diff --git a/sound/soc/bcm/Makefile b/sound/soc/bcm/Makefile
new file mode 100644
index 000000000000..bc816b71e5a4
--- /dev/null
+++ b/sound/soc/bcm/Makefile
@@ -0,0 +1,5 @@
+# BCM2835 Platform Support
+snd-soc-bcm2835-i2s-objs := bcm2835-i2s.o
+
+obj-$(CONFIG_SND_BCM2835_SOC_I2S) += snd-soc-bcm2835-i2s.o
+
diff --git a/sound/soc/bcm/bcm2835-i2s.c b/sound/soc/bcm/bcm2835-i2s.c
new file mode 100644
index 000000000000..2685fe4f8427
--- /dev/null
+++ b/sound/soc/bcm/bcm2835-i2s.c
@@ -0,0 +1,879 @@
+/*
+ * ALSA SoC I2S Audio Layer for Broadcom BCM2835 SoC
+ *
+ * Author:      Florian Meier <florian.meier@koalo.de>
+ *              Copyright 2013
+ *
+ * Based on
+ *      Raspberry Pi PCM I2S ALSA Driver
+ *      Copyright (c) by Phil Poole 2013
+ *
+ *      ALSA SoC I2S (McBSP) Audio Layer for TI DAVINCI processor
+ *      Vladimir Barinov, <vbarinov@embeddedalley.com>
+ *      Copyright (C) 2007 MontaVista Software, Inc., <source@mvista.com>
+ *
+ *      OMAP ALSA SoC DAI driver using McBSP port
+ *      Copyright (C) 2008 Nokia Corporation
+ *      Contact: Jarkko Nikula <jarkko.nikula@bitmer.com>
+ *               Peter Ujfalusi <peter.ujfalusi@ti.com>
+ *
+ *      Freescale SSI ALSA SoC Digital Audio Interface (DAI) driver
+ *      Author: Timur Tabi <timur@freescale.com>
+ *      Copyright 2007-2010 Freescale Semiconductor, 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.
+ *
+ * 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/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
+
+/* Clock registers */
+#define BCM2835_CLK_PCMCTL_REG  0x00
+#define BCM2835_CLK_PCMDIV_REG  0x04
+
+/* Clock register settings */
+#define BCM2835_CLK_PASSWD              (0x5a000000)
+#define BCM2835_CLK_PASSWD_MASK (0xff000000)
+#define BCM2835_CLK_MASH(v)             ((v) << 9)
+#define BCM2835_CLK_FLIP                BIT(8)
+#define BCM2835_CLK_BUSY                BIT(7)
+#define BCM2835_CLK_KILL                BIT(5)
+#define BCM2835_CLK_ENAB                BIT(4)
+#define BCM2835_CLK_SRC(v)              (v)
+
+#define BCM2835_CLK_SHIFT               (12)
+#define BCM2835_CLK_DIVI(v)             ((v) << BCM2835_CLK_SHIFT)
+#define BCM2835_CLK_DIVF(v)             (v)
+#define BCM2835_CLK_DIVF_MASK           (0xFFF)
+
+enum {
+        BCM2835_CLK_MASH_0 = 0,
+        BCM2835_CLK_MASH_1,
+        BCM2835_CLK_MASH_2,
+        BCM2835_CLK_MASH_3,
+};
+
+enum {
+        BCM2835_CLK_SRC_GND = 0,
+        BCM2835_CLK_SRC_OSC,
+        BCM2835_CLK_SRC_DBG0,
+        BCM2835_CLK_SRC_DBG1,
+        BCM2835_CLK_SRC_PLLA,
+        BCM2835_CLK_SRC_PLLC,
+        BCM2835_CLK_SRC_PLLD,
+        BCM2835_CLK_SRC_HDMI,
+};
+
+/* Most clocks are not useable (freq = 0) */
+static const unsigned int bcm2835_clk_freq[BCM2835_CLK_SRC_HDMI+1] = {
+        [BCM2835_CLK_SRC_GND]           = 0,
+        [BCM2835_CLK_SRC_OSC]           = 19200000,
+        [BCM2835_CLK_SRC_DBG0]          = 0,
+        [BCM2835_CLK_SRC_DBG1]          = 0,
+        [BCM2835_CLK_SRC_PLLA]          = 0,
+        [BCM2835_CLK_SRC_PLLC]          = 0,
+        [BCM2835_CLK_SRC_PLLD]          = 500000000,
+        [BCM2835_CLK_SRC_HDMI]          = 0,
+};
+
+/* I2S registers */
+#define BCM2835_I2S_CS_A_REG            0x00
+#define BCM2835_I2S_FIFO_A_REG          0x04
+#define BCM2835_I2S_MODE_A_REG          0x08
+#define BCM2835_I2S_RXC_A_REG           0x0c
+#define BCM2835_I2S_TXC_A_REG           0x10
+#define BCM2835_I2S_DREQ_A_REG          0x14
+#define BCM2835_I2S_INTEN_A_REG 0x18
+#define BCM2835_I2S_INTSTC_A_REG        0x1c
+#define BCM2835_I2S_GRAY_REG            0x20
+
+/* I2S register settings */
+#define BCM2835_I2S_STBY                BIT(25)
+#define BCM2835_I2S_SYNC                BIT(24)
+#define BCM2835_I2S_RXSEX               BIT(23)
+#define BCM2835_I2S_RXF         BIT(22)
+#define BCM2835_I2S_TXE         BIT(21)
+#define BCM2835_I2S_RXD         BIT(20)
+#define BCM2835_I2S_TXD         BIT(19)
+#define BCM2835_I2S_RXR         BIT(18)
+#define BCM2835_I2S_TXW         BIT(17)
+#define BCM2835_I2S_CS_RXERR            BIT(16)
+#define BCM2835_I2S_CS_TXERR            BIT(15)
+#define BCM2835_I2S_RXSYNC              BIT(14)
+#define BCM2835_I2S_TXSYNC              BIT(13)
+#define BCM2835_I2S_DMAEN               BIT(9)
+#define BCM2835_I2S_RXTHR(v)            ((v) << 7)
+#define BCM2835_I2S_TXTHR(v)            ((v) << 5)
+#define BCM2835_I2S_RXCLR               BIT(4)
+#define BCM2835_I2S_TXCLR               BIT(3)
+#define BCM2835_I2S_TXON                BIT(2)
+#define BCM2835_I2S_RXON                BIT(1)
+#define BCM2835_I2S_EN                  (1)
+
+#define BCM2835_I2S_CLKDIS              BIT(28)
+#define BCM2835_I2S_PDMN                BIT(27)
+#define BCM2835_I2S_PDME                BIT(26)
+#define BCM2835_I2S_FRXP                BIT(25)
+#define BCM2835_I2S_FTXP                BIT(24)
+#define BCM2835_I2S_CLKM                BIT(23)
+#define BCM2835_I2S_CLKI                BIT(22)
+#define BCM2835_I2S_FSM         BIT(21)
+#define BCM2835_I2S_FSI         BIT(20)
+#define BCM2835_I2S_FLEN(v)             ((v) << 10)
+#define BCM2835_I2S_FSLEN(v)            (v)
+
+#define BCM2835_I2S_CHWEX               BIT(15)
+#define BCM2835_I2S_CHEN                BIT(14)
+#define BCM2835_I2S_CHPOS(v)            ((v) << 4)
+#define BCM2835_I2S_CHWID(v)            (v)
+#define BCM2835_I2S_CH1(v)              ((v) << 16)
+#define BCM2835_I2S_CH2(v)              (v)
+
+#define BCM2835_I2S_TX_PANIC(v) ((v) << 24)
+#define BCM2835_I2S_RX_PANIC(v) ((v) << 16)
+#define BCM2835_I2S_TX(v)               ((v) << 8)
+#define BCM2835_I2S_RX(v)               (v)
+
+#define BCM2835_I2S_INT_RXERR           BIT(3)
+#define BCM2835_I2S_INT_TXERR           BIT(2)
+#define BCM2835_I2S_INT_RXR             BIT(1)
+#define BCM2835_I2S_INT_TXW             BIT(0)
+
+/* I2S DMA interface */
+/* FIXME: Needs IOMMU support */
+#define BCM2835_VCMMU_SHIFT             (0x7E000000 - 0x20000000)
+
+/* General device struct */
+struct bcm2835_i2s_dev {
+        struct device                           *dev;
+        struct snd_dmaengine_dai_dma_data       dma_data[2];
+        unsigned int                            fmt;
+        unsigned int                            bclk_ratio;
+
+        struct regmap *i2s_regmap;
+        struct regmap *clk_regmap;
+};
+
+static void bcm2835_i2s_start_clock(struct bcm2835_i2s_dev *dev)
+{
+        /* Start the clock if in master mode */
+        unsigned int master = dev->fmt & SND_SOC_DAIFMT_MASTER_MASK;
+
+        switch (master) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+        case SND_SOC_DAIFMT_CBS_CFM:
+                regmap_update_bits(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG,
+                        BCM2835_CLK_PASSWD_MASK | BCM2835_CLK_ENAB,
+                        BCM2835_CLK_PASSWD | BCM2835_CLK_ENAB);
+                break;
+        default:
+                break;
+        }
+}
+
+static void bcm2835_i2s_stop_clock(struct bcm2835_i2s_dev *dev)
+{
+        uint32_t clkreg;
+        int timeout = 1000;
+
+        /* Stop clock */
+        regmap_update_bits(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG,
+                        BCM2835_CLK_PASSWD_MASK | BCM2835_CLK_ENAB,
+                        BCM2835_CLK_PASSWD);
+
+        /* Wait for the BUSY flag going down */
+        while (--timeout) {
+                regmap_read(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG, &clkreg);
+                if (!(clkreg & BCM2835_CLK_BUSY))
+                        break;
+        }
+
+        if (!timeout) {
+                /* KILL the clock */
+                dev_err(dev->dev, "I2S clock didn't stop. Kill the clock!\n");
+                regmap_update_bits(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG,
+                        BCM2835_CLK_KILL | BCM2835_CLK_PASSWD_MASK,
+                        BCM2835_CLK_KILL | BCM2835_CLK_PASSWD);
+        }
+}
+
+static void bcm2835_i2s_clear_fifos(struct bcm2835_i2s_dev *dev,
+                                    bool tx, bool rx)
+{
+        int timeout = 1000;
+        uint32_t syncval;
+        uint32_t csreg;
+        uint32_t i2s_active_state;
+        uint32_t clkreg;
+        uint32_t clk_active_state;
+        uint32_t off;
+        uint32_t clr;
+
+        off =  tx ? BCM2835_I2S_TXON : 0;
+        off |= rx ? BCM2835_I2S_RXON : 0;
+
+        clr =  tx ? BCM2835_I2S_TXCLR : 0;
+        clr |= rx ? BCM2835_I2S_RXCLR : 0;
+
+        /* Backup the current state */
+        regmap_read(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, &csreg);
+        i2s_active_state = csreg & (BCM2835_I2S_RXON | BCM2835_I2S_TXON);
+
+        regmap_read(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG, &clkreg);
+        clk_active_state = clkreg & BCM2835_CLK_ENAB;
+
+        /* Start clock if not running */
+        if (!clk_active_state) {
+                regmap_update_bits(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG,
+                        BCM2835_CLK_PASSWD_MASK | BCM2835_CLK_ENAB,
+                        BCM2835_CLK_PASSWD | BCM2835_CLK_ENAB);
+        }
+
+        /* Stop I2S module */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, off, 0);
+
+        /*
+         * Clear the FIFOs
+         * Requires at least 2 PCM clock cycles to take effect
+         */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, clr, clr);
+
+        /* Wait for 2 PCM clock cycles */
+
+        /*
+         * Toggle the SYNC flag. After 2 PCM clock cycles it can be read back
+         * FIXME: This does not seem to work for slave mode!
+         */
+        regmap_read(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, &syncval);
+        syncval &= BCM2835_I2S_SYNC;
+
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_SYNC, ~syncval);
+
+        /* Wait for the SYNC flag changing it's state */
+        while (--timeout) {
+                regmap_read(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, &csreg);
+                if ((csreg & BCM2835_I2S_SYNC) != syncval)
+                        break;
+        }
+
+        if (!timeout)
+                dev_err(dev->dev, "I2S SYNC error!\n");
+
+        /* Stop clock if it was not running before */
+        if (!clk_active_state)
+                bcm2835_i2s_stop_clock(dev);
+
+        /* Restore I2S state */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_RXON | BCM2835_I2S_TXON, i2s_active_state);
+}
+
+static int bcm2835_i2s_set_dai_fmt(struct snd_soc_dai *dai,
+                                      unsigned int fmt)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+        dev->fmt = fmt;
+        return 0;
+}
+
+static int bcm2835_i2s_set_dai_bclk_ratio(struct snd_soc_dai *dai,
+                                      unsigned int ratio)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+        dev->bclk_ratio = ratio;
+        return 0;
+}
+
+static int bcm2835_i2s_hw_params(struct snd_pcm_substream *substream,
+                                 struct snd_pcm_hw_params *params,
+                                 struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+
+        unsigned int sampling_rate = params_rate(params);
+        unsigned int data_length, data_delay, bclk_ratio;
+        unsigned int ch1pos, ch2pos, mode, format;
+        unsigned int mash = BCM2835_CLK_MASH_1;
+        unsigned int divi, divf, target_frequency;
+        int clk_src = -1;
+        unsigned int master = dev->fmt & SND_SOC_DAIFMT_MASTER_MASK;
+        bool bit_master =       (master == SND_SOC_DAIFMT_CBS_CFS
+                                        || master == SND_SOC_DAIFMT_CBS_CFM);
+
+        bool frame_master =     (master == SND_SOC_DAIFMT_CBS_CFS
+                                        || master == SND_SOC_DAIFMT_CBM_CFS);
+        uint32_t csreg;
+
+        /*
+         * If a stream is already enabled,
+         * the registers are already set properly.
+         */
+        regmap_read(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, &csreg);
+
+        if (csreg & (BCM2835_I2S_TXON | BCM2835_I2S_RXON))
+                return 0;
+
+        /*
+         * Adjust the data length according to the format.
+         * We prefill the half frame length with an integer
+         * divider of 2400 as explained at the clock settings.
+         * Maybe it is overwritten there, if the Integer mode
+         * does not apply.
+         */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                data_length = 16;
+                bclk_ratio = 40;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                data_length = 32;
+                bclk_ratio = 80;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* If bclk_ratio already set, use that one. */
+        if (dev->bclk_ratio)
+                bclk_ratio = dev->bclk_ratio;
+
+        /*
+         * Clock Settings
+         *
+         * The target frequency of the bit clock is
+         *      sampling rate * frame length
+         *
+         * Integer mode:
+         * Sampling rates that are multiples of 8000 kHz
+         * can be driven by the oscillator of 19.2 MHz
+         * with an integer divider as long as the frame length
+         * is an integer divider of 19200000/8000=2400 as set up above.
+         * This is no longer possible if the sampling rate
+         * is too high (e.g. 192 kHz), because the oscillator is too slow.
+         *
+         * MASH mode:
+         * For all other sampling rates, it is not possible to
+         * have an integer divider. Approximate the clock
+         * with the MASH module that induces a slight frequency
+         * variance. To minimize that it is best to have the fastest
+         * clock here. That is PLLD with 500 MHz.
+         */
+        target_frequency = sampling_rate * bclk_ratio;
+        clk_src = BCM2835_CLK_SRC_OSC;
+        mash = BCM2835_CLK_MASH_0;
+
+        if (bcm2835_clk_freq[clk_src] % target_frequency == 0
+                        && bit_master && frame_master) {
+                divi = bcm2835_clk_freq[clk_src] / target_frequency;
+                divf = 0;
+        } else {
+                uint64_t dividend;
+
+                if (!dev->bclk_ratio) {
+                        /*
+                         * Overwrite bclk_ratio, because the
+                         * above trick is not needed or can
+                         * not be used.
+                         */
+                        bclk_ratio = 2 * data_length;
+                }
+
+                target_frequency = sampling_rate * bclk_ratio;
+
+                clk_src = BCM2835_CLK_SRC_PLLD;
+                mash = BCM2835_CLK_MASH_1;
+
+                dividend = bcm2835_clk_freq[clk_src];
+                dividend <<= BCM2835_CLK_SHIFT;
+                do_div(dividend, target_frequency);
+                divi = dividend >> BCM2835_CLK_SHIFT;
+                divf = dividend & BCM2835_CLK_DIVF_MASK;
+        }
+
+        /* Set clock divider */
+        regmap_write(dev->clk_regmap, BCM2835_CLK_PCMDIV_REG, BCM2835_CLK_PASSWD
+                        | BCM2835_CLK_DIVI(divi)
+                        | BCM2835_CLK_DIVF(divf));
+
+        /* Setup clock, but don't start it yet */
+        regmap_write(dev->clk_regmap, BCM2835_CLK_PCMCTL_REG, BCM2835_CLK_PASSWD
+                        | BCM2835_CLK_MASH(mash)
+                        | BCM2835_CLK_SRC(clk_src));
+
+        /* Setup the frame format */
+        format = BCM2835_I2S_CHEN;
+
+        if (data_length > 24)
+                format |= BCM2835_I2S_CHWEX;
+
+        format |= BCM2835_I2S_CHWID((data_length-8)&0xf);
+
+        switch (dev->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                data_delay = 1;
+                break;
+        default:
+                /*
+                 * TODO
+                 * Others are possible but are not implemented at the moment.
+                 */
+                dev_err(dev->dev, "%s:bad format\n", __func__);
+                return -EINVAL;
+        }
+
+        ch1pos = data_delay;
+        ch2pos = bclk_ratio / 2 + data_delay;
+
+        switch (params_channels(params)) {
+        case 2:
+                format = BCM2835_I2S_CH1(format) | BCM2835_I2S_CH2(format);
+                format |= BCM2835_I2S_CH1(BCM2835_I2S_CHPOS(ch1pos));
+                format |= BCM2835_I2S_CH2(BCM2835_I2S_CHPOS(ch2pos));
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /*
+         * Set format for both streams.
+         * We cannot set another frame length
+         * (and therefore word length) anyway,
+         * so the format will be the same.
+         */
+        regmap_write(dev->i2s_regmap, BCM2835_I2S_RXC_A_REG, format);
+        regmap_write(dev->i2s_regmap, BCM2835_I2S_TXC_A_REG, format);
+
+        /* Setup the I2S mode */
+        mode = 0;
+
+        if (data_length <= 16) {
+                /*
+                 * Use frame packed mode (2 channels per 32 bit word)
+                 * We cannot set another frame length in the second stream
+                 * (and therefore word length) anyway,
+                 * so the format will be the same.
+                 */
+                mode |= BCM2835_I2S_FTXP | BCM2835_I2S_FRXP;
+        }
+
+        mode |= BCM2835_I2S_FLEN(bclk_ratio - 1);
+        mode |= BCM2835_I2S_FSLEN(bclk_ratio / 2);
+
+        /* Master or slave? */
+        switch (dev->fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                /* CPU is master */
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                /*
+                 * CODEC is bit clock master
+                 * CPU is frame master
+                 */
+                mode |= BCM2835_I2S_CLKM;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+                /*
+                 * CODEC is frame master
+                 * CPU is bit clock master
+                 */
+                mode |= BCM2835_I2S_FSM;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /* CODEC is master */
+                mode |= BCM2835_I2S_CLKM;
+                mode |= BCM2835_I2S_FSM;
+                break;
+        default:
+                dev_err(dev->dev, "%s:bad master\n", __func__);
+                return -EINVAL;
+        }
+
+        /*
+         * Invert clocks?
+         *
+         * The BCM approach seems to be inverted to the classical I2S approach.
+         */
+        switch (dev->fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                /* None. Therefore, both for BCM */
+                mode |= BCM2835_I2S_CLKI;
+                mode |= BCM2835_I2S_FSI;
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                /* Both. Therefore, none for BCM */
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                /*
+                 * Invert only frame sync. Therefore,
+                 * invert only bit clock for BCM
+                 */
+                mode |= BCM2835_I2S_CLKI;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                /*
+                 * Invert only bit clock. Therefore,
+                 * invert only frame sync for BCM
+                 */
+                mode |= BCM2835_I2S_FSI;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        regmap_write(dev->i2s_regmap, BCM2835_I2S_MODE_A_REG, mode);
+
+        /* Setup the DMA parameters */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_RXTHR(1)
+                        | BCM2835_I2S_TXTHR(1)
+                        | BCM2835_I2S_DMAEN, 0xffffffff);
+
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_DREQ_A_REG,
+                          BCM2835_I2S_TX_PANIC(0x10)
+                        | BCM2835_I2S_RX_PANIC(0x30)
+                        | BCM2835_I2S_TX(0x30)
+                        | BCM2835_I2S_RX(0x20), 0xffffffff);
+
+        /* Clear FIFOs */
+        bcm2835_i2s_clear_fifos(dev, true, true);
+
+        return 0;
+}
+
+static int bcm2835_i2s_prepare(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+        uint32_t cs_reg;
+
+        bcm2835_i2s_start_clock(dev);
+
+        /*
+         * Clear both FIFOs if the one that should be started
+         * is not empty at the moment. This should only happen
+         * after overrun. Otherwise, hw_params would have cleared
+         * the FIFO.
+         */
+        regmap_read(dev->i2s_regmap, BCM2835_I2S_CS_A_REG, &cs_reg);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK
+                        && !(cs_reg & BCM2835_I2S_TXE))
+                bcm2835_i2s_clear_fifos(dev, true, false);
+        else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE
+                        && (cs_reg & BCM2835_I2S_RXD))
+                bcm2835_i2s_clear_fifos(dev, false, true);
+
+        return 0;
+}
+
+static void bcm2835_i2s_stop(struct bcm2835_i2s_dev *dev,
+                struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        uint32_t mask;
+
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                mask = BCM2835_I2S_RXON;
+        else
+                mask = BCM2835_I2S_TXON;
+
+        regmap_update_bits(dev->i2s_regmap,
+                        BCM2835_I2S_CS_A_REG, mask, 0);
+
+        /* Stop also the clock when not SND_SOC_DAIFMT_CONT */
+        if (!dai->active && !(dev->fmt & SND_SOC_DAIFMT_CONT))
+                bcm2835_i2s_stop_clock(dev);
+}
+
+static int bcm2835_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
+                               struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+        uint32_t mask;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                bcm2835_i2s_start_clock(dev);
+
+                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                        mask = BCM2835_I2S_RXON;
+                else
+                        mask = BCM2835_I2S_TXON;
+
+                regmap_update_bits(dev->i2s_regmap,
+                                BCM2835_I2S_CS_A_REG, mask, mask);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                bcm2835_i2s_stop(dev, substream, dai);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int bcm2835_i2s_startup(struct snd_pcm_substream *substream,
+                               struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+
+        if (dai->active)
+                return 0;
+
+        /* Should this still be running stop it */
+        bcm2835_i2s_stop_clock(dev);
+
+        /* Enable PCM block */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_EN, BCM2835_I2S_EN);
+
+        /*
+         * Disable STBY.
+         * Requires at least 4 PCM clock cycles to take effect.
+         */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_STBY, BCM2835_I2S_STBY);
+
+        return 0;
+}
+
+static void bcm2835_i2s_shutdown(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+
+        bcm2835_i2s_stop(dev, substream, dai);
+
+        /* If both streams are stopped, disable module and clock */
+        if (dai->active)
+                return;
+
+        /* Disable the module */
+        regmap_update_bits(dev->i2s_regmap, BCM2835_I2S_CS_A_REG,
+                        BCM2835_I2S_EN, 0);
+
+        /*
+         * Stopping clock is necessary, because stop does
+         * not stop the clock when SND_SOC_DAIFMT_CONT
+         */
+        bcm2835_i2s_stop_clock(dev);
+}
+
+static const struct snd_soc_dai_ops bcm2835_i2s_dai_ops = {
+        .startup        = bcm2835_i2s_startup,
+        .shutdown       = bcm2835_i2s_shutdown,
+        .prepare        = bcm2835_i2s_prepare,
+        .trigger        = bcm2835_i2s_trigger,
+        .hw_params      = bcm2835_i2s_hw_params,
+        .set_fmt        = bcm2835_i2s_set_dai_fmt,
+        .set_bclk_ratio = bcm2835_i2s_set_dai_bclk_ratio
+};
+
+static int bcm2835_i2s_dai_probe(struct snd_soc_dai *dai)
+{
+        struct bcm2835_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
+
+        snd_soc_dai_init_dma_data(dai,
+                        &dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK],
+                        &dev->dma_data[SNDRV_PCM_STREAM_CAPTURE]);
+
+        return 0;
+}
+
+static struct snd_soc_dai_driver bcm2835_i2s_dai = {
+        .name   = "bcm2835-i2s",
+        .probe  = bcm2835_i2s_dai_probe,
+        .playback = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates =        SNDRV_PCM_RATE_8000_192000,
+                .formats =      SNDRV_PCM_FMTBIT_S16_LE
+                                | SNDRV_PCM_FMTBIT_S32_LE
+                },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates =        SNDRV_PCM_RATE_8000_192000,
+                .formats =      SNDRV_PCM_FMTBIT_S16_LE
+                                | SNDRV_PCM_FMTBIT_S32_LE
+                },
+        .ops = &bcm2835_i2s_dai_ops,
+        .symmetric_rates = 1
+};
+
+static bool bcm2835_i2s_volatile_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case BCM2835_I2S_CS_A_REG:
+        case BCM2835_I2S_FIFO_A_REG:
+        case BCM2835_I2S_INTSTC_A_REG:
+        case BCM2835_I2S_GRAY_REG:
+                return true;
+        default:
+                return false;
+        };
+}
+
+static bool bcm2835_i2s_precious_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case BCM2835_I2S_FIFO_A_REG:
+                return true;
+        default:
+                return false;
+        };
+}
+
+static bool bcm2835_clk_volatile_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case BCM2835_CLK_PCMCTL_REG:
+                return true;
+        default:
+                return false;
+        };
+}
+
+static const struct regmap_config bcm2835_regmap_config[] = {
+        {
+                .reg_bits = 32,
+                .reg_stride = 4,
+                .val_bits = 32,
+                .max_register = BCM2835_I2S_GRAY_REG,
+                .precious_reg = bcm2835_i2s_precious_reg,
+                .volatile_reg = bcm2835_i2s_volatile_reg,
+                .cache_type = REGCACHE_RBTREE,
+        },
+        {
+                .reg_bits = 32,
+                .reg_stride = 4,
+                .val_bits = 32,
+                .max_register = BCM2835_CLK_PCMDIV_REG,
+                .volatile_reg = bcm2835_clk_volatile_reg,
+                .cache_type = REGCACHE_RBTREE,
+        },
+};
+
+static const struct snd_soc_component_driver bcm2835_i2s_component = {
+        .name           = "bcm2835-i2s-comp",
+};
+
+static int bcm2835_i2s_probe(struct platform_device *pdev)
+{
+        struct bcm2835_i2s_dev *dev;
+        int i;
+        int ret;
+        struct regmap *regmap[2];
+        struct resource *mem[2];
+
+        /* Request both ioareas */
+        for (i = 0; i <= 1; i++) {
+                void __iomem *base;
+
+                mem[i] = platform_get_resource(pdev, IORESOURCE_MEM, i);
+                base = devm_ioremap_resource(&pdev->dev, mem[i]);
+                if (IS_ERR(base))
+                        return PTR_ERR(base);
+
+                regmap[i] = devm_regmap_init_mmio(&pdev->dev, base,
+                                            &bcm2835_regmap_config[i]);
+                if (IS_ERR(regmap[i]))
+                        return PTR_ERR(regmap[i]);
+        }
+
+        dev = devm_kzalloc(&pdev->dev, sizeof(*dev),
+                           GFP_KERNEL);
+        if (!dev)
+                return -ENOMEM;
+
+        dev->i2s_regmap = regmap[0];
+        dev->clk_regmap = regmap[1];
+
+        /* Set the DMA address */
+        dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK].addr =
+                (dma_addr_t)mem[0]->start + BCM2835_I2S_FIFO_A_REG
+                                          + BCM2835_VCMMU_SHIFT;
+
+        dev->dma_data[SNDRV_PCM_STREAM_CAPTURE].addr =
+                (dma_addr_t)mem[0]->start + BCM2835_I2S_FIFO_A_REG
+                                          + BCM2835_VCMMU_SHIFT;
+
+        /* Set the bus width */
+        dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK].addr_width =
+                DMA_SLAVE_BUSWIDTH_4_BYTES;
+        dev->dma_data[SNDRV_PCM_STREAM_CAPTURE].addr_width =
+                DMA_SLAVE_BUSWIDTH_4_BYTES;
+
+        /* Set burst */
+        dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK].maxburst = 2;
+        dev->dma_data[SNDRV_PCM_STREAM_CAPTURE].maxburst = 2;
+
+        /* BCLK ratio - use default */
+        dev->bclk_ratio = 0;
+
+        /* Store the pdev */
+        dev->dev = &pdev->dev;
+        dev_set_drvdata(&pdev->dev, dev);
+
+        ret = devm_snd_soc_register_component(&pdev->dev,
+                        &bcm2835_i2s_component, &bcm2835_i2s_dai, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "Could not register DAI: %d\n", ret);
+                return ret;
+        }
+
+        ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0);
+        if (ret) {
+                dev_err(&pdev->dev, "Could not register PCM: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static const struct of_device_id bcm2835_i2s_of_match[] = {
+        { .compatible = "brcm,bcm2835-i2s", },
+        {},
+};
+
+static struct platform_driver bcm2835_i2s_driver = {
+        .probe          = bcm2835_i2s_probe,
+        .driver         = {
+                .name   = "bcm2835-i2s",
+                .owner  = THIS_MODULE,
+                .of_match_table = bcm2835_i2s_of_match,
+        },
+};
+
+module_platform_driver(bcm2835_i2s_driver);
+
+MODULE_ALIAS("platform:bcm2835-i2s");
+MODULE_DESCRIPTION("BCM2835 I2S interface");
+MODULE_AUTHOR("Florian Meier <florian.meier@koalo.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/blackfin/bf5xx-ac97-pcm.c b/sound/soc/blackfin/bf5xx-ac97-pcm.c
index 1d4c676eb6cc..cdb8ee75ded9 100644
--- a/sound/soc/blackfin/bf5xx-ac97-pcm.c
+++ b/sound/soc/blackfin/bf5xx-ac97-pcm.c
@@ -107,7 +107,6 @@ static const struct snd_pcm_hardware bf5xx_pcm_hardware = {
 #endif
                                    SNDRV_PCM_INFO_BLOCK_TRANSFER,
 
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
         .period_bytes_min       = 32,
         .period_bytes_max       = 0x10000,
         .periods_min            = 1,
diff --git a/sound/soc/blackfin/bf5xx-i2s-pcm.c b/sound/soc/blackfin/bf5xx-i2s-pcm.c
index 2a5b43417fd5..a3881c4381c9 100644
--- a/sound/soc/blackfin/bf5xx-i2s-pcm.c
+++ b/sound/soc/blackfin/bf5xx-i2s-pcm.c
@@ -52,9 +52,6 @@ static const struct snd_pcm_hardware bf5xx_pcm_hardware = {
         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
                                    SNDRV_PCM_INFO_MMAP_VALID |
                                    SNDRV_PCM_INFO_BLOCK_TRANSFER,
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE |
-                                   SNDRV_PCM_FMTBIT_S24_LE |
-                                   SNDRV_PCM_FMTBIT_S32_LE,
         .period_bytes_min       = 32,
         .period_bytes_max       = 0x10000,
         .periods_min            = 1,
diff --git a/sound/soc/cirrus/edb93xx.c b/sound/soc/cirrus/edb93xx.c
index c43fb214558a..4f900efc437c 100644
--- a/sound/soc/cirrus/edb93xx.c
+++ b/sound/soc/cirrus/edb93xx.c
@@ -63,7 +63,7 @@ static struct snd_soc_ops edb93xx_ops = {
 static struct snd_soc_dai_link edb93xx_dai = {
         .name           = "CS4271",
         .stream_name    = "CS4271 HiFi",
-        .platform_name  = "ep93xx-pcm-audio",
+        .platform_name  = "ep93xx-i2s",
         .cpu_dai_name   = "ep93xx-i2s",
         .codec_name     = "spi0.0",
         .codec_dai_name = "cs4271-hifi",
diff --git a/sound/soc/cirrus/ep93xx-ac97.c b/sound/soc/cirrus/ep93xx-ac97.c
index efa75b5086a4..f30dadf85b99 100644
--- a/sound/soc/cirrus/ep93xx-ac97.c
+++ b/sound/soc/cirrus/ep93xx-ac97.c
@@ -19,11 +19,14 @@
 #include <linux/slab.h>
 
 #include <sound/core.h>
+#include <sound/dmaengine_pcm.h>
 #include <sound/ac97_codec.h>
 #include <sound/soc.h>
 
 #include <linux/platform_data/dma-ep93xx.h>
 
+#include "ep93xx-pcm.h"
+
 /*
  * Per channel (1-4) registers.
  */
@@ -95,6 +98,8 @@ struct ep93xx_ac97_info {
         struct device           *dev;
         void __iomem            *regs;
         struct completion       done;
+        struct snd_dmaengine_dai_dma_data dma_params_rx;
+        struct snd_dmaengine_dai_dma_data dma_params_tx;
 };
 
 /* currently ALSA only supports a single AC97 device */
@@ -315,8 +320,13 @@ static int ep93xx_ac97_trigger(struct snd_pcm_substream *substream,
 
 static int ep93xx_ac97_dai_probe(struct snd_soc_dai *dai)
 {
-        dai->playback_dma_data = &ep93xx_ac97_pcm_out;
-        dai->capture_dma_data = &ep93xx_ac97_pcm_in;
+        struct ep93xx_ac97_info *info = snd_soc_dai_get_drvdata(dai);
+
+        info->dma_params_tx.filter_data = &ep93xx_ac97_pcm_out;
+        info->dma_params_rx.filter_data = &ep93xx_ac97_pcm_in;
+
+        dai->playback_dma_data = &info->dma_params_tx;
+        dai->capture_dma_data = &info->dma_params_rx;
 
         return 0;
 }
@@ -394,8 +404,14 @@ static int ep93xx_ac97_probe(struct platform_device *pdev)
         if (ret)
                 goto fail;
 
+        ret = devm_ep93xx_pcm_platform_register(&pdev->dev);
+        if (ret)
+                goto fail_unregister;
+
         return 0;
 
+fail_unregister:
+        snd_soc_unregister_component(&pdev->dev);
 fail:
         ep93xx_ac97_info = NULL;
         snd_soc_set_ac97_ops(NULL);
diff --git a/sound/soc/cirrus/ep93xx-i2s.c b/sound/soc/cirrus/ep93xx-i2s.c
index a57643d6402f..943145f9d1b6 100644
--- a/sound/soc/cirrus/ep93xx-i2s.c
+++ b/sound/soc/cirrus/ep93xx-i2s.c
@@ -21,6 +21,7 @@
 #include <linux/io.h>
 
 #include <sound/core.h>
+#include <sound/dmaengine_pcm.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/initval.h>
@@ -30,6 +31,8 @@
 #include <mach/ep93xx-regs.h>
 #include <linux/platform_data/dma-ep93xx.h>
 
+#include "ep93xx-pcm.h"
+
 #define EP93XX_I2S_TXCLKCFG             0x00
 #define EP93XX_I2S_RXCLKCFG             0x04
 #define EP93XX_I2S_GLCTRL               0x0C
@@ -61,6 +64,8 @@ struct ep93xx_i2s_info {
         struct clk                      *sclk;
         struct clk                      *lrclk;
         void __iomem                    *regs;
+        struct snd_dmaengine_dai_dma_data dma_params_rx;
+        struct snd_dmaengine_dai_dma_data dma_params_tx;
 };
 
 static struct ep93xx_dma_data ep93xx_i2s_dma_data[] = {
@@ -140,8 +145,15 @@ static void ep93xx_i2s_disable(struct ep93xx_i2s_info *info, int stream)
 
 static int ep93xx_i2s_dai_probe(struct snd_soc_dai *dai)
 {
-        dai->playback_dma_data = &ep93xx_i2s_dma_data[SNDRV_PCM_STREAM_PLAYBACK];
-        dai->capture_dma_data = &ep93xx_i2s_dma_data[SNDRV_PCM_STREAM_CAPTURE];
+        struct ep93xx_i2s_info *info = snd_soc_dai_get_drvdata(dai);
+
+        info->dma_params_tx.filter_data =
+                &ep93xx_i2s_dma_data[SNDRV_PCM_STREAM_PLAYBACK];
+        info->dma_params_rx.filter_data =
+                &ep93xx_i2s_dma_data[SNDRV_PCM_STREAM_CAPTURE];
+
+        dai->playback_dma_data = &info->dma_params_tx;
+        dai->capture_dma_data = &info->dma_params_rx;
 
         return 0;
 }
@@ -405,8 +417,14 @@ static int ep93xx_i2s_probe(struct platform_device *pdev)
         if (err)
                 goto fail_put_lrclk;
 
+        err = devm_ep93xx_pcm_platform_register(&pdev->dev);
+        if (err)
+                goto fail_unregister;
+
         return 0;
 
+fail_unregister:
+        snd_soc_unregister_component(&pdev->dev);
 fail_put_lrclk:
         clk_put(info->lrclk);
 fail_put_sclk:
diff --git a/sound/soc/cirrus/ep93xx-pcm.c b/sound/soc/cirrus/ep93xx-pcm.c
index cfe517e68009..5f664471d99e 100644
--- a/sound/soc/cirrus/ep93xx-pcm.c
+++ b/sound/soc/cirrus/ep93xx-pcm.c
@@ -23,20 +23,13 @@
 
 #include <linux/platform_data/dma-ep93xx.h>
 
+#include "ep93xx-pcm.h"
+
 static const struct snd_pcm_hardware ep93xx_pcm_hardware = {
         .info                   = (SNDRV_PCM_INFO_MMAP          |
                                    SNDRV_PCM_INFO_MMAP_VALID    |
                                    SNDRV_PCM_INFO_INTERLEAVED   |
                                    SNDRV_PCM_INFO_BLOCK_TRANSFER),
-                                   
-        .rates                  = SNDRV_PCM_RATE_8000_192000,
-        .rate_min               = SNDRV_PCM_RATE_8000,
-        .rate_max               = SNDRV_PCM_RATE_192000,
-        
-        .formats                = (SNDRV_PCM_FMTBIT_S16_LE |
-                                   SNDRV_PCM_FMTBIT_S24_LE |
-                                   SNDRV_PCM_FMTBIT_S32_LE),
-        
         .buffer_bytes_max       = 131072,
         .period_bytes_min       = 32,
         .period_bytes_max       = 32768,
@@ -57,53 +50,22 @@ static bool ep93xx_pcm_dma_filter(struct dma_chan *chan, void *filter_param)
         return false;
 }
 
-static struct dma_chan *ep93xx_compat_request_channel(
-        struct snd_soc_pcm_runtime *rtd,
-        struct snd_pcm_substream *substream)
-{
-        struct snd_dmaengine_dai_dma_data *dma_data;
-
-        dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
-
-        return snd_dmaengine_pcm_request_channel(ep93xx_pcm_dma_filter,
-                                                 dma_data);
-}
-
 static const struct snd_dmaengine_pcm_config ep93xx_dmaengine_pcm_config = {
         .pcm_hardware = &ep93xx_pcm_hardware,
         .compat_filter_fn = ep93xx_pcm_dma_filter,
-        .compat_request_channel = ep93xx_compat_request_channel,
         .prealloc_buffer_size = 131072,
 };
 
-static int ep93xx_soc_platform_probe(struct platform_device *pdev)
+int devm_ep93xx_pcm_platform_register(struct device *dev)
 {
-        return snd_dmaengine_pcm_register(&pdev->dev,
+        return devm_snd_dmaengine_pcm_register(dev,
                 &ep93xx_dmaengine_pcm_config,
                 SND_DMAENGINE_PCM_FLAG_NO_RESIDUE |
                 SND_DMAENGINE_PCM_FLAG_NO_DT |
                 SND_DMAENGINE_PCM_FLAG_COMPAT);
 }
-
-static int ep93xx_soc_platform_remove(struct platform_device *pdev)
-{
-        snd_dmaengine_pcm_unregister(&pdev->dev);
-        return 0;
-}
-
-static struct platform_driver ep93xx_pcm_driver = {
-        .driver = {
-                        .name = "ep93xx-pcm-audio",
-                        .owner = THIS_MODULE,
-        },
-
-        .probe = ep93xx_soc_platform_probe,
-        .remove = ep93xx_soc_platform_remove,
-};
-
-module_platform_driver(ep93xx_pcm_driver);
+EXPORT_SYMBOL_GPL(devm_ep93xx_pcm_platform_register);
 
 MODULE_AUTHOR("Ryan Mallon");
 MODULE_DESCRIPTION("EP93xx ALSA PCM interface");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:ep93xx-pcm-audio");
diff --git a/sound/soc/cirrus/ep93xx-pcm.h b/sound/soc/cirrus/ep93xx-pcm.h
new file mode 100644
index 000000000000..b7a12a2fae9c
--- /dev/null
+++ b/sound/soc/cirrus/ep93xx-pcm.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __EP93XX_PCM_H__
+#define __EP93XX_PCM_H__
+
+int devm_ep93xx_pcm_platform_register(struct device *dev);
+
+#endif
diff --git a/sound/soc/cirrus/simone.c b/sound/soc/cirrus/simone.c
index 4d094d00c34a..822a19a89e74 100644
--- a/sound/soc/cirrus/simone.c
+++ b/sound/soc/cirrus/simone.c
@@ -27,7 +27,7 @@ static struct snd_soc_dai_link simone_dai = {
         .cpu_dai_name   = "ep93xx-ac97",
         .codec_dai_name = "ac97-hifi",
         .codec_name     = "ac97-codec",
-        .platform_name  = "ep93xx-pcm-audio",
+        .platform_name  = "ep93xx-ac97",
 };
 
 static struct snd_soc_card snd_soc_simone = {
diff --git a/sound/soc/cirrus/snappercl15.c b/sound/soc/cirrus/snappercl15.c
index 69041074f2c1..29238a7476dd 100644
--- a/sound/soc/cirrus/snappercl15.c
+++ b/sound/soc/cirrus/snappercl15.c
@@ -83,7 +83,7 @@ static struct snd_soc_dai_link snappercl15_dai = {
         .cpu_dai_name   = "ep93xx-i2s",
         .codec_dai_name = "tlv320aic23-hifi",
         .codec_name     = "tlv320aic23-codec.0-001a",
-        .platform_name  =  "ep93xx-pcm-audio",
+        .platform_name  = "ep93xx-i2s",
         .init           = snappercl15_tlv320aic23_init,
         .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_IF |
                           SND_SOC_DAIFMT_CBS_CFS,
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index b33b45dfceec..983d087aa92a 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -163,8 +163,10 @@ config SND_SOC_WM_HUBS
 config SND_SOC_WM_ADSP
         tristate
         default y if SND_SOC_WM5102=y
+        default y if SND_SOC_WM5110=y
         default y if SND_SOC_WM2200=y
         default m if SND_SOC_WM5102=m
+        default m if SND_SOC_WM5110=m
         default m if SND_SOC_WM2200=m
 
 config SND_SOC_AB8500_CODEC
diff --git a/sound/soc/codecs/ad1836.c b/sound/soc/codecs/ad1836.c
index 9a92b7962f41..d7c983862cf0 100644
--- a/sound/soc/codecs/ad1836.c
+++ b/sound/soc/codecs/ad1836.c
@@ -179,6 +179,8 @@ static int ad1836_hw_params(struct snd_pcm_substream *substream,
         case SNDRV_PCM_FORMAT_S32_LE:
                 word_len = AD1836_WORD_LEN_24;
                 break;
+        default:
+                return -EINVAL;
         }
 
         regmap_update_bits(ad1836->regmap, AD1836_DAC_CTRL1,
diff --git a/sound/soc/codecs/ad193x.c b/sound/soc/codecs/ad193x.c
index aea7e52cf714..12c27eb363dd 100644
--- a/sound/soc/codecs/ad193x.c
+++ b/sound/soc/codecs/ad193x.c
@@ -413,7 +413,7 @@ static struct spi_driver ad193x_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 
 static const struct regmap_config ad193x_i2c_regmap_config = {
         .val_bits = 8,
@@ -470,7 +470,7 @@ static int __init ad193x_modinit(void)
 {
         int ret;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret =  i2c_add_driver(&ad193x_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register AD193X I2C driver: %d\n",
@@ -495,7 +495,7 @@ static void __exit ad193x_modexit(void)
         spi_unregister_driver(&ad193x_spi_driver);
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&ad193x_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/adav80x.c b/sound/soc/codecs/adav80x.c
index 14a7c169d004..f7bf45552749 100644
--- a/sound/soc/codecs/adav80x.c
+++ b/sound/soc/codecs/adav80x.c
@@ -939,7 +939,7 @@ static struct spi_driver adav80x_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static const struct regmap_config adav80x_i2c_regmap_config = {
         .val_bits = 8,
         .pad_bits = 1,
@@ -985,7 +985,7 @@ static int __init adav80x_init(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&adav80x_i2c_driver);
         if (ret)
                 return ret;
@@ -1001,7 +1001,7 @@ module_init(adav80x_init);
 
 static void __exit adav80x_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&adav80x_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/ak4641.c b/sound/soc/codecs/ak4641.c
index 49cc5f6d6dba..94cbe508dd37 100644
--- a/sound/soc/codecs/ak4641.c
+++ b/sound/soc/codecs/ak4641.c
@@ -17,6 +17,7 @@
 #include <linux/gpio.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -30,6 +31,7 @@
 
 /* codec private data */
 struct ak4641_priv {
+        struct regmap *regmap;
         unsigned int sysclk;
         int deemph;
         int playback_fs;
@@ -38,12 +40,12 @@ struct ak4641_priv {
 /*
  * ak4641 register cache
  */
-static const u8 ak4641_reg[AK4641_CACHEREGNUM] = {
-        0x00, 0x80, 0x00, 0x80,
-        0x02, 0x00, 0x11, 0x05,
-        0x00, 0x00, 0x36, 0x10,
-        0x00, 0x00, 0x57, 0x00,
-        0x88, 0x88, 0x08, 0x08
+static const struct reg_default ak4641_reg_defaults[] = {
+        {  0, 0x00 }, {  1, 0x80 }, {  2, 0x00 }, {  3, 0x80 },
+        {  4, 0x02 }, {  5, 0x00 }, {  6, 0x11 }, {  7, 0x05 },
+        {  8, 0x00 }, {  9, 0x00 }, { 10, 0x36 }, { 11, 0x10 },
+        { 12, 0x00 }, { 13, 0x00 }, { 14, 0x57 }, { 15, 0x00 },
+        { 16, 0x88 }, { 17, 0x88 }, { 18, 0x08 }, { 19, 0x08 }
 };
 
 static const int deemph_settings[] = {44100, 0, 48000, 32000};
@@ -396,6 +398,7 @@ static int ak4641_mute(struct snd_soc_dai *dai, int mute)
 static int ak4641_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
+        struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
         struct ak4641_platform_data *pdata = codec->dev->platform_data;
         int ret;
 
@@ -417,7 +420,7 @@ static int ak4641_set_bias_level(struct snd_soc_codec *codec,
                                 gpio_set_value(pdata->gpio_npdn, 1);
                         mdelay(1);
 
-                        ret = snd_soc_cache_sync(codec);
+                        ret = regcache_sync(ak4641->regmap);
                         if (ret) {
                                 dev_err(codec->dev,
                                         "Failed to sync cache: %d\n", ret);
@@ -433,7 +436,7 @@ static int ak4641_set_bias_level(struct snd_soc_codec *codec,
                         gpio_set_value(pdata->gpio_npdn, 0);
                 if (pdata && gpio_is_valid(pdata->gpio_power))
                         gpio_set_value(pdata->gpio_power, 0);
-                codec->cache_sync = 1;
+                regcache_mark_dirty(ak4641->regmap);
                 break;
         }
         codec->dapm.bias_level = level;
@@ -518,7 +521,7 @@ static int ak4641_probe(struct snd_soc_codec *codec)
 {
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -550,12 +553,17 @@ static struct snd_soc_codec_driver soc_codec_dev_ak4641 = {
         .dapm_routes            = ak4641_audio_map,
         .num_dapm_routes        = ARRAY_SIZE(ak4641_audio_map),
         .set_bias_level         = ak4641_set_bias_level,
-        .reg_cache_size         = ARRAY_SIZE(ak4641_reg),
-        .reg_word_size          = sizeof(u8),
-        .reg_cache_default      = ak4641_reg,
-        .reg_cache_step         = 1,
 };
 
+static const struct regmap_config ak4641_regmap = {
+        .reg_bits = 8,
+        .val_bits = 8,
+
+        .max_register = AK4641_BTIF,
+        .reg_defaults = ak4641_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(ak4641_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+};
 
 static int ak4641_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
@@ -569,6 +577,10 @@ static int ak4641_i2c_probe(struct i2c_client *i2c,
         if (!ak4641)
                 return -ENOMEM;
 
+        ak4641->regmap = devm_regmap_init_i2c(i2c, &ak4641_regmap);
+        if (IS_ERR(ak4641->regmap))
+                return PTR_ERR(ak4641->regmap);
+
         if (pdata) {
                 if (gpio_is_valid(pdata->gpio_power)) {
                         ret = gpio_request_one(pdata->gpio_power,
diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
index 090d499bb7eb..1f646c6e90c6 100644
--- a/sound/soc/codecs/ak4642.c
+++ b/sound/soc/codecs/ak4642.c
@@ -28,6 +28,7 @@
 #include <linux/slab.h>
 #include <linux/of_device.h>
 #include <linux/module.h>
+#include <linux/regmap.h>
 #include <sound/soc.h>
 #include <sound/initval.h>
 #include <sound/tlv.h>
@@ -198,30 +199,30 @@ static const struct snd_soc_dapm_route ak4642_intercon[] = {
 /*
  * ak4642 register cache
  */
-static const u8 ak4642_reg[] = {
-        0x00, 0x00, 0x01, 0x00,
-        0x02, 0x00, 0x00, 0x00,
-        0xe1, 0xe1, 0x18, 0x00,
-        0xe1, 0x18, 0x11, 0x08,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00,
+static const struct reg_default ak4642_reg[] = {
+        {  0, 0x00 }, {  1, 0x00 }, {  2, 0x01 }, {  3, 0x00 },
+        {  4, 0x02 }, {  5, 0x00 }, {  6, 0x00 }, {  7, 0x00 },
+        {  8, 0xe1 }, {  9, 0xe1 }, { 10, 0x18 }, { 11, 0x00 },
+        { 12, 0xe1 }, { 13, 0x18 }, { 14, 0x11 }, { 15, 0x08 },
+        { 16, 0x00 }, { 17, 0x00 }, { 18, 0x00 }, { 19, 0x00 },
+        { 20, 0x00 }, { 21, 0x00 }, { 22, 0x00 }, { 23, 0x00 },
+        { 24, 0x00 }, { 25, 0x00 }, { 26, 0x00 }, { 27, 0x00 },
+        { 28, 0x00 }, { 29, 0x00 }, { 30, 0x00 }, { 31, 0x00 },
+        { 32, 0x00 }, { 33, 0x00 }, { 34, 0x00 }, { 35, 0x00 },
+        { 36, 0x00 },
 };
 
-static const u8 ak4648_reg[] = {
-        0x00, 0x00, 0x01, 0x00,
-        0x02, 0x00, 0x00, 0x00,
-        0xe1, 0xe1, 0x18, 0x00,
-        0xe1, 0x18, 0x11, 0xb8,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x88, 0x88, 0x08,
+static const struct reg_default ak4648_reg[] = {
+        {  0, 0x00 }, {  1, 0x00 }, {  2, 0x01 }, {  3, 0x00 },
+        {  4, 0x02 }, {  5, 0x00 }, {  6, 0x00 }, {  7, 0x00 },
+        {  8, 0xe1 }, {  9, 0xe1 }, { 10, 0x18 }, { 11, 0x00 },
+        { 12, 0xe1 }, { 13, 0x18 }, { 14, 0x11 }, { 15, 0xb8 },
+        { 16, 0x00 }, { 17, 0x00 }, { 18, 0x00 }, { 19, 0x00 },
+        { 20, 0x00 }, { 21, 0x00 }, { 22, 0x00 }, { 23, 0x00 },
+        { 24, 0x00 }, { 25, 0x00 }, { 26, 0x00 }, { 27, 0x00 },
+        { 28, 0x00 }, { 29, 0x00 }, { 30, 0x00 }, { 31, 0x00 },
+        { 32, 0x00 }, { 33, 0x00 }, { 34, 0x00 }, { 35, 0x00 },
+        { 36, 0x00 }, { 37, 0x88 }, { 38, 0x88 }, { 39, 0x08 },
 };
 
 static int ak4642_dai_startup(struct snd_pcm_substream *substream,
@@ -454,7 +455,10 @@ static struct snd_soc_dai_driver ak4642_dai = {
 
 static int ak4642_resume(struct snd_soc_codec *codec)
 {
-        snd_soc_cache_sync(codec);
+        struct regmap *regmap = dev_get_regmap(codec->dev, NULL);
+
+        regcache_mark_dirty(regmap);
+        regcache_sync(regmap);
         return 0;
 }
 
@@ -463,15 +467,12 @@ static int ak4642_probe(struct snd_soc_codec *codec)
 {
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        snd_soc_add_codec_controls(codec, ak4642_snd_controls,
-                             ARRAY_SIZE(ak4642_snd_controls));
-
         ak4642_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         return 0;
@@ -488,55 +489,59 @@ static struct snd_soc_codec_driver soc_codec_dev_ak4642 = {
         .remove                 = ak4642_remove,
         .resume                 = ak4642_resume,
         .set_bias_level         = ak4642_set_bias_level,
-        .reg_cache_default      = ak4642_reg,                   /* ak4642 reg */
-        .reg_cache_size         = ARRAY_SIZE(ak4642_reg),       /* ak4642 reg */
-        .reg_word_size          = sizeof(u8),
+        .controls               = ak4642_snd_controls,
+        .num_controls           = ARRAY_SIZE(ak4642_snd_controls),
         .dapm_widgets           = ak4642_dapm_widgets,
         .num_dapm_widgets       = ARRAY_SIZE(ak4642_dapm_widgets),
         .dapm_routes            = ak4642_intercon,
         .num_dapm_routes        = ARRAY_SIZE(ak4642_intercon),
 };
 
-static struct snd_soc_codec_driver soc_codec_dev_ak4648 = {
-        .probe                  = ak4642_probe,
-        .remove                 = ak4642_remove,
-        .resume                 = ak4642_resume,
-        .set_bias_level         = ak4642_set_bias_level,
-        .reg_cache_default      = ak4648_reg,                   /* ak4648 reg */
-        .reg_cache_size         = ARRAY_SIZE(ak4648_reg),       /* ak4648 reg */
-        .reg_word_size          = sizeof(u8),
-        .dapm_widgets           = ak4642_dapm_widgets,
-        .num_dapm_widgets       = ARRAY_SIZE(ak4642_dapm_widgets),
-        .dapm_routes            = ak4642_intercon,
-        .num_dapm_routes        = ARRAY_SIZE(ak4642_intercon),
+static const struct regmap_config ak4642_regmap = {
+        .reg_bits               = 8,
+        .val_bits               = 8,
+        .max_register           = ARRAY_SIZE(ak4642_reg) + 1,
+        .reg_defaults           = ak4642_reg,
+        .num_reg_defaults       = ARRAY_SIZE(ak4642_reg),
+};
+
+static const struct regmap_config ak4648_regmap = {
+        .reg_bits               = 8,
+        .val_bits               = 8,
+        .max_register           = ARRAY_SIZE(ak4648_reg) + 1,
+        .reg_defaults           = ak4648_reg,
+        .num_reg_defaults       = ARRAY_SIZE(ak4648_reg),
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static struct of_device_id ak4642_of_match[];
 static int ak4642_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct device_node *np = i2c->dev.of_node;
-        const struct snd_soc_codec_driver *driver;
+        const struct regmap_config *regmap_config = NULL;
+        struct regmap *regmap;
 
-        driver = NULL;
         if (np) {
                 const struct of_device_id *of_id;
 
                 of_id = of_match_device(ak4642_of_match, &i2c->dev);
                 if (of_id)
-                        driver = of_id->data;
+                        regmap_config = of_id->data;
         } else {
-                driver = (struct snd_soc_codec_driver *)id->driver_data;
+                regmap_config = (const struct regmap_config *)id->driver_data;
         }
 
-        if (!driver) {
-                dev_err(&i2c->dev, "no driver\n");
+        if (!regmap_config) {
+                dev_err(&i2c->dev, "Unknown device type\n");
                 return -EINVAL;
         }
 
+        regmap = devm_regmap_init_i2c(i2c, regmap_config);
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+
         return snd_soc_register_codec(&i2c->dev,
-                                      driver, &ak4642_dai, 1);
+                                      &soc_codec_dev_ak4642, &ak4642_dai, 1);
 }
 
 static int ak4642_i2c_remove(struct i2c_client *client)
@@ -546,17 +551,17 @@ static int ak4642_i2c_remove(struct i2c_client *client)
 }
 
 static struct of_device_id ak4642_of_match[] = {
-        { .compatible = "asahi-kasei,ak4642",   .data = &soc_codec_dev_ak4642},
-        { .compatible = "asahi-kasei,ak4643",   .data = &soc_codec_dev_ak4642},
-        { .compatible = "asahi-kasei,ak4648",   .data = &soc_codec_dev_ak4648},
+        { .compatible = "asahi-kasei,ak4642",   .data = &ak4642_regmap},
+        { .compatible = "asahi-kasei,ak4643",   .data = &ak4642_regmap},
+        { .compatible = "asahi-kasei,ak4648",   .data = &ak4648_regmap},
         {},
 };
 MODULE_DEVICE_TABLE(of, ak4642_of_match);
 
 static const struct i2c_device_id ak4642_i2c_id[] = {
-        { "ak4642", (kernel_ulong_t)&soc_codec_dev_ak4642 },
-        { "ak4643", (kernel_ulong_t)&soc_codec_dev_ak4642 },
-        { "ak4648", (kernel_ulong_t)&soc_codec_dev_ak4648 },
+        { "ak4642", (kernel_ulong_t)&ak4642_regmap },
+        { "ak4643", (kernel_ulong_t)&ak4642_regmap },
+        { "ak4648", (kernel_ulong_t)&ak4648_regmap },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, ak4642_i2c_id);
@@ -571,27 +576,8 @@ static struct i2c_driver ak4642_i2c_driver = {
         .remove         = ak4642_i2c_remove,
         .id_table       = ak4642_i2c_id,
 };
-#endif
-
-static int __init ak4642_modinit(void)
-{
-        int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        ret = i2c_add_driver(&ak4642_i2c_driver);
-#endif
-        return ret;
 
-}
-module_init(ak4642_modinit);
-
-static void __exit ak4642_exit(void)
-{
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        i2c_del_driver(&ak4642_i2c_driver);
-#endif
-
-}
-module_exit(ak4642_exit);
+module_i2c_driver(ak4642_i2c_driver);
 
 MODULE_DESCRIPTION("Soc AK4642 driver");
 MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
diff --git a/sound/soc/codecs/arizona.c b/sound/soc/codecs/arizona.c
index fea991031be1..e4295fee8f13 100644
--- a/sound/soc/codecs/arizona.c
+++ b/sound/soc/codecs/arizona.c
@@ -93,7 +93,7 @@ static int arizona_spk_ev(struct snd_soc_dapm_widget *w,
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 if (!priv->spk_ena && manual_ena) {
-                        snd_soc_write(codec, 0x4f5, 0x25a);
+                        regmap_write_async(arizona->regmap, 0x4f5, 0x25a);
                         priv->spk_ena_pending = true;
                 }
                 break;
@@ -105,12 +105,13 @@ static int arizona_spk_ev(struct snd_soc_dapm_widget *w,
                         return -EBUSY;
                 }
 
-                snd_soc_update_bits(codec, ARIZONA_OUTPUT_ENABLES_1,
-                                    1 << w->shift, 1 << w->shift);
+                regmap_update_bits_async(arizona->regmap,
+                                         ARIZONA_OUTPUT_ENABLES_1,
+                                         1 << w->shift, 1 << w->shift);
 
                 if (priv->spk_ena_pending) {
                         msleep(75);
-                        snd_soc_write(codec, 0x4f5, 0xda);
+                        regmap_write_async(arizona->regmap, 0x4f5, 0xda);
                         priv->spk_ena_pending = false;
                         priv->spk_ena++;
                 }
@@ -119,16 +120,19 @@ static int arizona_spk_ev(struct snd_soc_dapm_widget *w,
                 if (manual_ena) {
                         priv->spk_ena--;
                         if (!priv->spk_ena)
-                                snd_soc_write(codec, 0x4f5, 0x25a);
+                                regmap_write_async(arizona->regmap,
+                                                   0x4f5, 0x25a);
                 }
 
-                snd_soc_update_bits(codec, ARIZONA_OUTPUT_ENABLES_1,
-                                    1 << w->shift, 0);
+                regmap_update_bits_async(arizona->regmap,
+                                         ARIZONA_OUTPUT_ENABLES_1,
+                                         1 << w->shift, 0);
                 break;
         case SND_SOC_DAPM_POST_PMD:
                 if (manual_ena) {
                         if (!priv->spk_ena)
-                                snd_soc_write(codec, 0x4f5, 0x0da);
+                                regmap_write_async(arizona->regmap,
+                                                   0x4f5, 0x0da);
                 }
                 break;
         }
@@ -292,6 +296,10 @@ const char *arizona_mixer_texts[ARIZONA_NUM_MIXER_INPUTS] = {
         "AIF1RX8",
         "AIF2RX1",
         "AIF2RX2",
+        "AIF2RX3",
+        "AIF2RX4",
+        "AIF2RX5",
+        "AIF2RX6",
         "AIF3RX1",
         "AIF3RX2",
         "SLIMRX1",
@@ -395,6 +403,10 @@ int arizona_mixer_values[ARIZONA_NUM_MIXER_INPUTS] = {
         0x27,
         0x28,  /* AIF2RX1 */
         0x29,
+        0x2a,
+        0x2b,
+        0x2c,
+        0x2d,
         0x30,  /* AIF3RX1 */
         0x31,
         0x38,  /* SLIMRX1 */
@@ -486,6 +498,22 @@ const int arizona_rate_val[ARIZONA_RATE_ENUM_SIZE] = {
 EXPORT_SYMBOL_GPL(arizona_rate_val);
 
 
+const struct soc_enum arizona_isrc_fsh[] = {
+        SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_1_CTRL_1,
+                              ARIZONA_ISRC1_FSH_SHIFT, 0xf,
+                              ARIZONA_RATE_ENUM_SIZE,
+                              arizona_rate_text, arizona_rate_val),
+        SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_2_CTRL_1,
+                              ARIZONA_ISRC2_FSH_SHIFT, 0xf,
+                              ARIZONA_RATE_ENUM_SIZE,
+                              arizona_rate_text, arizona_rate_val),
+        SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_3_CTRL_1,
+                              ARIZONA_ISRC3_FSH_SHIFT, 0xf,
+                              ARIZONA_RATE_ENUM_SIZE,
+                              arizona_rate_text, arizona_rate_val),
+};
+EXPORT_SYMBOL_GPL(arizona_isrc_fsh);
+
 const struct soc_enum arizona_isrc_fsl[] = {
         SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_1_CTRL_2,
                               ARIZONA_ISRC1_FSL_SHIFT, 0xf,
@@ -502,6 +530,13 @@ const struct soc_enum arizona_isrc_fsl[] = {
 };
 EXPORT_SYMBOL_GPL(arizona_isrc_fsl);
 
+const struct soc_enum arizona_asrc_rate1 =
+        SOC_VALUE_ENUM_SINGLE(ARIZONA_ASRC_RATE1,
+                              ARIZONA_ASRC_RATE1_SHIFT, 0xf,
+                              ARIZONA_RATE_ENUM_SIZE - 1,
+                              arizona_rate_text, arizona_rate_val);
+EXPORT_SYMBOL_GPL(arizona_asrc_rate1);
+
 static const char *arizona_vol_ramp_text[] = {
         "0ms/6dB", "0.5ms/6dB", "1ms/6dB", "2ms/6dB", "4ms/6dB", "8ms/6dB",
         "15ms/6dB", "30ms/6dB",
@@ -560,6 +595,16 @@ const struct soc_enum arizona_ng_hold =
                         4, arizona_ng_hold_text);
 EXPORT_SYMBOL_GPL(arizona_ng_hold);
 
+static const char * const arizona_in_hpf_cut_text[] = {
+        "2.5Hz", "5Hz", "10Hz", "20Hz", "40Hz"
+};
+
+const struct soc_enum arizona_in_hpf_cut_enum =
+        SOC_ENUM_SINGLE(ARIZONA_HPF_CONTROL, ARIZONA_IN_HPF_CUT_SHIFT,
+                        ARRAY_SIZE(arizona_in_hpf_cut_text),
+                        arizona_in_hpf_cut_text);
+EXPORT_SYMBOL_GPL(arizona_in_hpf_cut_enum);
+
 static const char * const arizona_in_dmic_osr_text[] = {
         "1.536MHz", "3.072MHz", "6.144MHz",
 };
@@ -669,6 +714,7 @@ int arizona_hp_ev(struct snd_soc_dapm_widget *w,
                    int event)
 {
         struct arizona_priv *priv = snd_soc_codec_get_drvdata(w->codec);
+        struct arizona *arizona = priv->arizona;
         unsigned int mask = 1 << w->shift;
         unsigned int val;
 
@@ -691,7 +737,8 @@ int arizona_hp_ev(struct snd_soc_dapm_widget *w,
         if (priv->arizona->hpdet_magic)
                 val = 0;
 
-        snd_soc_update_bits(w->codec, ARIZONA_OUTPUT_ENABLES_1, mask, val);
+        regmap_update_bits_async(arizona->regmap, ARIZONA_OUTPUT_ENABLES_1,
+                                 mask, val);
 
         return arizona_out_ev(w, kcontrol, event);
 }
@@ -846,6 +893,8 @@ EXPORT_SYMBOL_GPL(arizona_set_sysclk);
 static int arizona_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 {
         struct snd_soc_codec *codec = dai->codec;
+        struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
+        struct arizona *arizona = priv->arizona;
         int lrclk, bclk, mode, base;
 
         base = dai->driver->base;
@@ -902,17 +951,19 @@ static int arizona_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
                 return -EINVAL;
         }
 
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_BCLK_CTRL,
-                            ARIZONA_AIF1_BCLK_INV | ARIZONA_AIF1_BCLK_MSTR,
-                            bclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_TX_PIN_CTRL,
-                            ARIZONA_AIF1TX_LRCLK_INV |
-                            ARIZONA_AIF1TX_LRCLK_MSTR, lrclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_RX_PIN_CTRL,
-                            ARIZONA_AIF1RX_LRCLK_INV |
-                            ARIZONA_AIF1RX_LRCLK_MSTR, lrclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_FORMAT,
-                            ARIZONA_AIF1_FMT_MASK, mode);
+        regmap_update_bits_async(arizona->regmap, base + ARIZONA_AIF_BCLK_CTRL,
+                                 ARIZONA_AIF1_BCLK_INV |
+                                 ARIZONA_AIF1_BCLK_MSTR,
+                                 bclk);
+        regmap_update_bits_async(arizona->regmap, base + ARIZONA_AIF_TX_PIN_CTRL,
+                                 ARIZONA_AIF1TX_LRCLK_INV |
+                                 ARIZONA_AIF1TX_LRCLK_MSTR, lrclk);
+        regmap_update_bits_async(arizona->regmap,
+                                 base + ARIZONA_AIF_RX_PIN_CTRL,
+                                 ARIZONA_AIF1RX_LRCLK_INV |
+                                 ARIZONA_AIF1RX_LRCLK_MSTR, lrclk);
+        regmap_update_bits(arizona->regmap, base + ARIZONA_AIF_FORMAT,
+                           ARIZONA_AIF1_FMT_MASK, mode);
 
         return 0;
 }
@@ -1164,18 +1215,22 @@ static int arizona_hw_params(struct snd_pcm_substream *substream,
         if (ret != 0)
                 return ret;
 
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_BCLK_CTRL,
-                            ARIZONA_AIF1_BCLK_FREQ_MASK, bclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_TX_BCLK_RATE,
-                            ARIZONA_AIF1TX_BCPF_MASK, lrclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_RX_BCLK_RATE,
-                            ARIZONA_AIF1RX_BCPF_MASK, lrclk);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_FRAME_CTRL_1,
-                            ARIZONA_AIF1TX_WL_MASK |
-                            ARIZONA_AIF1TX_SLOT_LEN_MASK, frame);
-        snd_soc_update_bits(codec, base + ARIZONA_AIF_FRAME_CTRL_2,
-                            ARIZONA_AIF1RX_WL_MASK |
-                            ARIZONA_AIF1RX_SLOT_LEN_MASK, frame);
+        regmap_update_bits_async(arizona->regmap,
+                                 base + ARIZONA_AIF_BCLK_CTRL,
+                                 ARIZONA_AIF1_BCLK_FREQ_MASK, bclk);
+        regmap_update_bits_async(arizona->regmap,
+                                 base + ARIZONA_AIF_TX_BCLK_RATE,
+                                 ARIZONA_AIF1TX_BCPF_MASK, lrclk);
+        regmap_update_bits_async(arizona->regmap,
+                                 base + ARIZONA_AIF_RX_BCLK_RATE,
+                                 ARIZONA_AIF1RX_BCPF_MASK, lrclk);
+        regmap_update_bits_async(arizona->regmap,
+                                 base + ARIZONA_AIF_FRAME_CTRL_1,
+                                 ARIZONA_AIF1TX_WL_MASK |
+                                 ARIZONA_AIF1TX_SLOT_LEN_MASK, frame);
+        regmap_update_bits(arizona->regmap, base + ARIZONA_AIF_FRAME_CTRL_2,
+                           ARIZONA_AIF1RX_WL_MASK |
+                           ARIZONA_AIF1RX_SLOT_LEN_MASK, frame);
 
         return 0;
 }
@@ -1428,31 +1483,31 @@ static void arizona_apply_fll(struct arizona *arizona, unsigned int base,
                               struct arizona_fll_cfg *cfg, int source,
                               bool sync)
 {
-        regmap_update_bits(arizona->regmap, base + 3,
-                           ARIZONA_FLL1_THETA_MASK, cfg->theta);
-        regmap_update_bits(arizona->regmap, base + 4,
-                           ARIZONA_FLL1_LAMBDA_MASK, cfg->lambda);
-        regmap_update_bits(arizona->regmap, base + 5,
-                           ARIZONA_FLL1_FRATIO_MASK,
-                           cfg->fratio << ARIZONA_FLL1_FRATIO_SHIFT);
-        regmap_update_bits(arizona->regmap, base + 6,
-                           ARIZONA_FLL1_CLK_REF_DIV_MASK |
-                           ARIZONA_FLL1_CLK_REF_SRC_MASK,
-                           cfg->refdiv << ARIZONA_FLL1_CLK_REF_DIV_SHIFT |
-                           source << ARIZONA_FLL1_CLK_REF_SRC_SHIFT);
+        regmap_update_bits_async(arizona->regmap, base + 3,
+                                 ARIZONA_FLL1_THETA_MASK, cfg->theta);
+        regmap_update_bits_async(arizona->regmap, base + 4,
+                                 ARIZONA_FLL1_LAMBDA_MASK, cfg->lambda);
+        regmap_update_bits_async(arizona->regmap, base + 5,
+                                 ARIZONA_FLL1_FRATIO_MASK,
+                                 cfg->fratio << ARIZONA_FLL1_FRATIO_SHIFT);
+        regmap_update_bits_async(arizona->regmap, base + 6,
+                                 ARIZONA_FLL1_CLK_REF_DIV_MASK |
+                                 ARIZONA_FLL1_CLK_REF_SRC_MASK,
+                                 cfg->refdiv << ARIZONA_FLL1_CLK_REF_DIV_SHIFT |
+                                 source << ARIZONA_FLL1_CLK_REF_SRC_SHIFT);
 
         if (sync)
-                regmap_update_bits(arizona->regmap, base + 0x7,
-                                   ARIZONA_FLL1_GAIN_MASK,
-                                   cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
+                regmap_update_bits_async(arizona->regmap, base + 0x7,
+                                         ARIZONA_FLL1_GAIN_MASK,
+                                         cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
         else
-                regmap_update_bits(arizona->regmap, base + 0x9,
-                                   ARIZONA_FLL1_GAIN_MASK,
-                                   cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
+                regmap_update_bits_async(arizona->regmap, base + 0x9,
+                                         ARIZONA_FLL1_GAIN_MASK,
+                                         cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
 
-        regmap_update_bits(arizona->regmap, base + 2,
-                           ARIZONA_FLL1_CTRL_UPD | ARIZONA_FLL1_N_MASK,
-                           ARIZONA_FLL1_CTRL_UPD | cfg->n);
+        regmap_update_bits_async(arizona->regmap, base + 2,
+                                 ARIZONA_FLL1_CTRL_UPD | ARIZONA_FLL1_N_MASK,
+                                 ARIZONA_FLL1_CTRL_UPD | cfg->n);
 }
 
 static bool arizona_is_enabled_fll(struct arizona_fll *fll)
@@ -1485,9 +1540,9 @@ static void arizona_enable_fll(struct arizona_fll *fll,
          */
         if (fll->ref_src >= 0 && fll->ref_freq &&
             fll->ref_src != fll->sync_src) {
-                regmap_update_bits(arizona->regmap, fll->base + 5,
-                                   ARIZONA_FLL1_OUTDIV_MASK,
-                                   ref->outdiv << ARIZONA_FLL1_OUTDIV_SHIFT);
+                regmap_update_bits_async(arizona->regmap, fll->base + 5,
+                                         ARIZONA_FLL1_OUTDIV_MASK,
+                                         ref->outdiv << ARIZONA_FLL1_OUTDIV_SHIFT);
 
                 arizona_apply_fll(arizona, fll->base, ref, fll->ref_src,
                                   false);
@@ -1497,15 +1552,15 @@ static void arizona_enable_fll(struct arizona_fll *fll,
                         use_sync = true;
                 }
         } else if (fll->sync_src >= 0) {
-                regmap_update_bits(arizona->regmap, fll->base + 5,
-                                   ARIZONA_FLL1_OUTDIV_MASK,
-                                   sync->outdiv << ARIZONA_FLL1_OUTDIV_SHIFT);
+                regmap_update_bits_async(arizona->regmap, fll->base + 5,
+                                         ARIZONA_FLL1_OUTDIV_MASK,
+                                         sync->outdiv << ARIZONA_FLL1_OUTDIV_SHIFT);
 
                 arizona_apply_fll(arizona, fll->base, sync,
                                   fll->sync_src, false);
 
-                regmap_update_bits(arizona->regmap, fll->base + 0x11,
-                                   ARIZONA_FLL1_SYNC_ENA, 0);
+                regmap_update_bits_async(arizona->regmap, fll->base + 0x11,
+                                         ARIZONA_FLL1_SYNC_ENA, 0);
         } else {
                 arizona_fll_err(fll, "No clocks provided\n");
                 return;
@@ -1516,11 +1571,12 @@ static void arizona_enable_fll(struct arizona_fll *fll,
          * sync source.
          */
         if (use_sync && fll->sync_freq > 100000)
-                regmap_update_bits(arizona->regmap, fll->base + 0x17,
-                                   ARIZONA_FLL1_SYNC_BW, 0);
+                regmap_update_bits_async(arizona->regmap, fll->base + 0x17,
+                                         ARIZONA_FLL1_SYNC_BW, 0);
         else
-                regmap_update_bits(arizona->regmap, fll->base + 0x17,
-                                   ARIZONA_FLL1_SYNC_BW, ARIZONA_FLL1_SYNC_BW);
+                regmap_update_bits_async(arizona->regmap, fll->base + 0x17,
+                                         ARIZONA_FLL1_SYNC_BW,
+                                         ARIZONA_FLL1_SYNC_BW);
 
         if (!arizona_is_enabled_fll(fll))
                 pm_runtime_get(arizona->dev);
@@ -1528,14 +1584,14 @@ static void arizona_enable_fll(struct arizona_fll *fll,
         /* Clear any pending completions */
         try_wait_for_completion(&fll->ok);
 
-        regmap_update_bits(arizona->regmap, fll->base + 1,
-                           ARIZONA_FLL1_FREERUN, 0);
-        regmap_update_bits(arizona->regmap, fll->base + 1,
-                           ARIZONA_FLL1_ENA, ARIZONA_FLL1_ENA);
+        regmap_update_bits_async(arizona->regmap, fll->base + 1,
+                                 ARIZONA_FLL1_FREERUN, 0);
+        regmap_update_bits_async(arizona->regmap, fll->base + 1,
+                                 ARIZONA_FLL1_ENA, ARIZONA_FLL1_ENA);
         if (use_sync)
-                regmap_update_bits(arizona->regmap, fll->base + 0x11,
-                                   ARIZONA_FLL1_SYNC_ENA,
-                                   ARIZONA_FLL1_SYNC_ENA);
+                regmap_update_bits_async(arizona->regmap, fll->base + 0x11,
+                                         ARIZONA_FLL1_SYNC_ENA,
+                                         ARIZONA_FLL1_SYNC_ENA);
 
         ret = wait_for_completion_timeout(&fll->ok,
                                           msecs_to_jiffies(250));
@@ -1548,8 +1604,8 @@ static void arizona_disable_fll(struct arizona_fll *fll)
         struct arizona *arizona = fll->arizona;
         bool change;
 
-        regmap_update_bits(arizona->regmap, fll->base + 1,
-                           ARIZONA_FLL1_FREERUN, ARIZONA_FLL1_FREERUN);
+        regmap_update_bits_async(arizona->regmap, fll->base + 1,
+                                 ARIZONA_FLL1_FREERUN, ARIZONA_FLL1_FREERUN);
         regmap_update_bits_check(arizona->regmap, fll->base + 1,
                                  ARIZONA_FLL1_ENA, 0, &change);
         regmap_update_bits(arizona->regmap, fll->base + 0x11,
diff --git a/sound/soc/codecs/arizona.h b/sound/soc/codecs/arizona.h
index 9e81b6392692..10b398477203 100644
--- a/sound/soc/codecs/arizona.h
+++ b/sound/soc/codecs/arizona.h
@@ -81,7 +81,7 @@ struct arizona_priv {
         unsigned int spk_ena_pending:1;
 };
 
-#define ARIZONA_NUM_MIXER_INPUTS 99
+#define ARIZONA_NUM_MIXER_INPUTS 103
 
 extern const unsigned int arizona_mixer_tlv[];
 extern const char *arizona_mixer_texts[ARIZONA_NUM_MIXER_INPUTS];
@@ -186,6 +186,8 @@ extern const char *arizona_rate_text[ARIZONA_RATE_ENUM_SIZE];
 extern const int arizona_rate_val[ARIZONA_RATE_ENUM_SIZE];
 
 extern const struct soc_enum arizona_isrc_fsl[];
+extern const struct soc_enum arizona_isrc_fsh[];
+extern const struct soc_enum arizona_asrc_rate1;
 
 extern const struct soc_enum arizona_in_vi_ramp;
 extern const struct soc_enum arizona_in_vd_ramp;
@@ -199,6 +201,7 @@ extern const struct soc_enum arizona_lhpf3_mode;
 extern const struct soc_enum arizona_lhpf4_mode;
 
 extern const struct soc_enum arizona_ng_hold;
+extern const struct soc_enum arizona_in_hpf_cut_enum;
 extern const struct soc_enum arizona_in_dmic_osr[];
 
 extern int arizona_in_ev(struct snd_soc_dapm_widget *w,
diff --git a/sound/soc/codecs/cs4271.c b/sound/soc/codecs/cs4271.c
index f6e953454bc0..ce05fd93dc74 100644
--- a/sound/soc/codecs/cs4271.c
+++ b/sound/soc/codecs/cs4271.c
@@ -675,7 +675,7 @@ static struct spi_driver cs4271_spi_driver = {
 };
 #endif /* defined(CONFIG_SPI_MASTER) */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static const struct i2c_device_id cs4271_i2c_id[] = {
         {"cs4271", 0},
         {}
@@ -728,7 +728,7 @@ static struct i2c_driver cs4271_i2c_driver = {
         .probe          = cs4271_i2c_probe,
         .remove         = cs4271_i2c_remove,
 };
-#endif /* defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) */
+#endif /* IS_ENABLED(CONFIG_I2C) */
 
 /*
  * We only register our serial bus driver here without
@@ -741,7 +741,7 @@ static int __init cs4271_modinit(void)
 {
         int ret;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&cs4271_i2c_driver);
         if (ret) {
                 pr_err("Failed to register CS4271 I2C driver: %d\n", ret);
@@ -767,7 +767,7 @@ static void __exit cs4271_modexit(void)
         spi_unregister_driver(&cs4271_spi_driver);
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&cs4271_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/cs42l52.c b/sound/soc/codecs/cs42l52.c
index 8b427c977083..0bac6d5a4ac8 100644
--- a/sound/soc/codecs/cs42l52.c
+++ b/sound/soc/codecs/cs42l52.c
@@ -17,7 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/gpio.h>
+#include <linux/of_gpio.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/input.h>
@@ -50,7 +50,7 @@ struct  cs42l52_private {
         u8 mclksel;
         u32 mclk;
         u8 flags;
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         struct input_dev *beep;
         struct work_struct beep_work;
         int beep_rate;
@@ -233,7 +233,7 @@ static const struct soc_enum mic_bias_level_enum =
         SOC_ENUM_SINGLE(CS42L52_IFACE_CTL2, 0,
                         ARRAY_SIZE(mic_bias_level_text), mic_bias_level_text);
 
-static const char * const cs42l52_mic_text[] = { "Single", "Differential" };
+static const char * const cs42l52_mic_text[] = { "MIC1", "MIC2" };
 
 static const struct soc_enum mica_enum =
         SOC_ENUM_SINGLE(CS42L52_MICA_CTL, 5,
@@ -243,12 +243,6 @@ static const struct soc_enum micb_enum =
         SOC_ENUM_SINGLE(CS42L52_MICB_CTL, 5,
                         ARRAY_SIZE(cs42l52_mic_text), cs42l52_mic_text);
 
-static const struct snd_kcontrol_new mica_mux =
-        SOC_DAPM_ENUM("Left Mic Input Capture Mux", mica_enum);
-
-static const struct snd_kcontrol_new micb_mux =
-        SOC_DAPM_ENUM("Right Mic Input Capture Mux", micb_enum);
-
 static const char * const digital_output_mux_text[] = {"ADC", "DSP"};
 
 static const struct soc_enum digital_output_mux_enum =
@@ -531,6 +525,30 @@ static const struct snd_kcontrol_new cs42l52_snd_controls[] = {
 
 };
 
+static const struct snd_kcontrol_new cs42l52_mica_controls[] = {
+        SOC_ENUM("MICA Select", mica_enum),
+};
+
+static const struct snd_kcontrol_new cs42l52_micb_controls[] = {
+        SOC_ENUM("MICB Select", micb_enum),
+};
+
+static int cs42l52_add_mic_controls(struct snd_soc_codec *codec)
+{
+        struct cs42l52_private *cs42l52 = snd_soc_codec_get_drvdata(codec);
+        struct cs42l52_platform_data *pdata = &cs42l52->pdata;
+
+        if (!pdata->mica_diff_cfg)
+                snd_soc_add_codec_controls(codec, cs42l52_mica_controls,
+                                     ARRAY_SIZE(cs42l52_mica_controls));
+
+        if (!pdata->micb_diff_cfg)
+                snd_soc_add_codec_controls(codec, cs42l52_micb_controls,
+                                     ARRAY_SIZE(cs42l52_micb_controls));
+
+        return 0;
+}
+
 static const struct snd_soc_dapm_widget cs42l52_dapm_widgets[] = {
 
         SND_SOC_DAPM_INPUT("AIN1L"),
@@ -550,9 +568,6 @@ static const struct snd_soc_dapm_widget cs42l52_dapm_widgets[] = {
         SND_SOC_DAPM_AIF_OUT("AIFOUTR", NULL,  0,
                         SND_SOC_NOPM, 0, 0),
 
-        SND_SOC_DAPM_MUX("MICA Mux", SND_SOC_NOPM, 0, 0, &mica_mux),
-        SND_SOC_DAPM_MUX("MICB Mux", SND_SOC_NOPM, 0, 0, &micb_mux),
-
         SND_SOC_DAPM_ADC("ADC Left", NULL, CS42L52_PWRCTL1, 1, 1),
         SND_SOC_DAPM_ADC("ADC Right", NULL, CS42L52_PWRCTL1, 2, 1),
         SND_SOC_DAPM_PGA("PGA Left", CS42L52_PWRCTL1, 3, 1, NULL, 0),
@@ -953,7 +968,7 @@ static int cs42l52_resume(struct snd_soc_codec *codec)
         return 0;
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int beep_rates[] = {
         261, 522, 585, 667, 706, 774, 889, 1000,
         1043, 1200, 1333, 1412, 1600, 1714, 2000, 2182
@@ -1110,6 +1125,8 @@ static int cs42l52_probe(struct snd_soc_codec *codec)
         }
         regcache_cache_only(cs42l52->regmap, true);
 
+        cs42l52_add_mic_controls(codec);
+
         cs42l52_init_beep(codec);
 
         cs42l52_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
@@ -1176,6 +1193,7 @@ static int cs42l52_i2c_probe(struct i2c_client *i2c_client,
         int ret;
         unsigned int devid = 0;
         unsigned int reg;
+        u32 val32;
 
         cs42l52 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l52_private),
                                GFP_KERNEL);
@@ -1189,9 +1207,39 @@ static int cs42l52_i2c_probe(struct i2c_client *i2c_client,
                 dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret);
                 return ret;
         }
-
-        if (pdata)
+        if (pdata) {
+                cs42l52->pdata = *pdata;
+        } else {
+                pdata = devm_kzalloc(&i2c_client->dev,
+                                     sizeof(struct cs42l52_platform_data),
+                                GFP_KERNEL);
+                if (!pdata) {
+                        dev_err(&i2c_client->dev, "could not allocate pdata\n");
+                        return -ENOMEM;
+                }
+                if (i2c_client->dev.of_node) {
+                        if (of_property_read_bool(i2c_client->dev.of_node,
+                                "cirrus,mica-differential-cfg"))
+                                pdata->mica_diff_cfg = true;
+
+                        if (of_property_read_bool(i2c_client->dev.of_node,
+                                "cirrus,micb-differential-cfg"))
+                                pdata->micb_diff_cfg = true;
+
+                        if (of_property_read_u32(i2c_client->dev.of_node,
+                                "cirrus,micbias-lvl", &val32) >= 0)
+                                pdata->micbias_lvl = val32;
+
+                        if (of_property_read_u32(i2c_client->dev.of_node,
+                                "cirrus,chgfreq-divisor", &val32) >= 0)
+                                pdata->chgfreq = val32;
+
+                        pdata->reset_gpio =
+                                of_get_named_gpio(i2c_client->dev.of_node,
+                                                "cirrus,reset-gpio", 0);
+                }
                 cs42l52->pdata = *pdata;
+        }
 
         if (cs42l52->pdata.reset_gpio) {
                 ret = gpio_request_one(cs42l52->pdata.reset_gpio,
@@ -1227,29 +1275,18 @@ static int cs42l52_i2c_probe(struct i2c_client *i2c_client,
                         reg & 0xFF);
 
         /* Set Platform Data */
-        if (cs42l52->pdata.mica_cfg)
+        if (cs42l52->pdata.mica_diff_cfg)
                 regmap_update_bits(cs42l52->regmap, CS42L52_MICA_CTL,
                                    CS42L52_MIC_CTL_TYPE_MASK,
-                                cs42l52->pdata.mica_cfg <<
+                                cs42l52->pdata.mica_diff_cfg <<
                                 CS42L52_MIC_CTL_TYPE_SHIFT);
 
-        if (cs42l52->pdata.micb_cfg)
+        if (cs42l52->pdata.micb_diff_cfg)
                 regmap_update_bits(cs42l52->regmap, CS42L52_MICB_CTL,
                                    CS42L52_MIC_CTL_TYPE_MASK,
-                                cs42l52->pdata.micb_cfg <<
+                                cs42l52->pdata.micb_diff_cfg <<
                                 CS42L52_MIC_CTL_TYPE_SHIFT);
 
-        if (cs42l52->pdata.mica_sel)
-                regmap_update_bits(cs42l52->regmap, CS42L52_MICA_CTL,
-                                   CS42L52_MIC_CTL_MIC_SEL_MASK,
-                                cs42l52->pdata.mica_sel <<
-                                CS42L52_MIC_CTL_MIC_SEL_SHIFT);
-        if (cs42l52->pdata.micb_sel)
-                regmap_update_bits(cs42l52->regmap, CS42L52_MICB_CTL,
-                                   CS42L52_MIC_CTL_MIC_SEL_MASK,
-                                cs42l52->pdata.micb_sel <<
-                                CS42L52_MIC_CTL_MIC_SEL_SHIFT);
-
         if (cs42l52->pdata.chgfreq)
                 regmap_update_bits(cs42l52->regmap, CS42L52_CHARGE_PUMP,
                                    CS42L52_CHARGE_PUMP_MASK,
@@ -1274,6 +1311,13 @@ static int cs42l52_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
+static const struct of_device_id cs42l52_of_match[] = {
+        { .compatible = "cirrus,cs42l52", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, cs42l52_of_match);
+
+
 static const struct i2c_device_id cs42l52_id[] = {
         { "cs42l52", 0 },
         { }
@@ -1284,6 +1328,7 @@ static struct i2c_driver cs42l52_i2c_driver = {
         .driver = {
                 .name = "cs42l52",
                 .owner = THIS_MODULE,
+                .of_match_table = cs42l52_of_match,
         },
         .id_table = cs42l52_id,
         .probe =    cs42l52_i2c_probe,
diff --git a/sound/soc/codecs/da7210.c b/sound/soc/codecs/da7210.c
index 9c1231456502..8166dcb2e4a3 100644
--- a/sound/soc/codecs/da7210.c
+++ b/sound/soc/codecs/da7210.c
@@ -1188,7 +1188,7 @@ static struct snd_soc_codec_driver soc_codec_dev_da7210 = {
         .num_dapm_routes        = ARRAY_SIZE(da7210_audio_map),
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 
 static struct reg_default da7210_regmap_i2c_patch[] = {
 
@@ -1362,7 +1362,7 @@ static struct spi_driver da7210_spi_driver = {
 static int __init da7210_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&da7210_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
@@ -1378,7 +1378,7 @@ module_init(da7210_modinit);
 
 static void __exit da7210_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&da7210_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/hdmi.c b/sound/soc/codecs/hdmi.c
index 68342b121c96..9cb1c7d3e1dc 100644
--- a/sound/soc/codecs/hdmi.c
+++ b/sound/soc/codecs/hdmi.c
@@ -20,6 +20,7 @@
  */
 #include <linux/module.h>
 #include <sound/soc.h>
+#include <linux/of_device.h>
 
 #define DRV_NAME "hdmi-audio-codec"
 
@@ -44,7 +45,7 @@ static struct snd_soc_dai_driver hdmi_codec_dai = {
                         SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
                         SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000,
                 .formats = SNDRV_PCM_FMTBIT_S16_LE |
-                        SNDRV_PCM_FMTBIT_S24_LE,
+                        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE,
         },
         .capture = {
                 .stream_name = "Capture",
@@ -60,6 +61,14 @@ static struct snd_soc_dai_driver hdmi_codec_dai = {
 
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id hdmi_audio_codec_ids[] = {
+        { .compatible = "linux,hdmi-audio", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, hdmi_audio_codec_ids);
+#endif
+
 static struct snd_soc_codec_driver hdmi_codec = {
         .dapm_widgets = hdmi_widgets,
         .num_dapm_widgets = ARRAY_SIZE(hdmi_widgets),
@@ -83,6 +92,7 @@ static struct platform_driver hdmi_codec_driver = {
         .driver         = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(hdmi_audio_codec_ids),
         },
 
         .probe          = hdmi_codec_probe,
diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c
index 1f4093f3f3a1..0fcbe90f3ef2 100644
--- a/sound/soc/codecs/sgtl5000.c
+++ b/sound/soc/codecs/sgtl5000.c
@@ -115,6 +115,7 @@ struct sgtl5000_priv {
         struct ldo_regulator *ldo;
         struct regmap *regmap;
         struct clk *mclk;
+        int revision;
 };
 
 /*
@@ -1285,41 +1286,45 @@ static int sgtl5000_replace_vddd_with_ldo(struct snd_soc_codec *codec)
 
         sgtl5000->supplies[VDDD].supply = LDO_CONSUMER_NAME;
 
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
-                        sgtl5000->supplies);
-
-        if (ret) {
-                ldo_regulator_remove(codec);
-                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
-                return ret;
-        }
-
         dev_info(codec->dev, "Using internal LDO instead of VDDD\n");
         return 0;
 }
 
 static int sgtl5000_enable_regulators(struct snd_soc_codec *codec)
 {
-        int reg;
         int ret;
-        int rev;
         int i;
         int external_vddd = 0;
         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
+        struct regulator *vddd;
 
         for (i = 0; i < ARRAY_SIZE(sgtl5000->supplies); i++)
                 sgtl5000->supplies[i].supply = supply_names[i];
 
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
-                                sgtl5000->supplies);
-        if (!ret)
-                external_vddd = 1;
-        else {
+        /* External VDDD only works before revision 0x11 */
+        if (sgtl5000->revision < 0x11) {
+                vddd = regulator_get_optional(codec->dev, "VDDD");
+                if (IS_ERR(vddd)) {
+                        /* See if it's just not registered yet */
+                        if (PTR_ERR(vddd) == -EPROBE_DEFER)
+                                return -EPROBE_DEFER;
+                } else {
+                        external_vddd = 1;
+                        regulator_put(vddd);
+                }
+        }
+
+        if (!external_vddd) {
                 ret = sgtl5000_replace_vddd_with_ldo(codec);
                 if (ret)
                         return ret;
         }
 
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
+                                 sgtl5000->supplies);
+        if (ret)
+                goto err_ldo_remove;
+
         ret = regulator_bulk_enable(ARRAY_SIZE(sgtl5000->supplies),
                                         sgtl5000->supplies);
         if (ret)
@@ -1328,47 +1333,13 @@ static int sgtl5000_enable_regulators(struct snd_soc_codec *codec)
         /* wait for all power rails bring up */
         udelay(10);
 
-        /*
-         * workaround for revision 0x11 and later,
-         * roll back to use internal LDO
-         */
-
-        ret = regmap_read(sgtl5000->regmap, SGTL5000_CHIP_ID, &reg);
-        if (ret)
-                goto err_regulator_disable;
-
-        rev = (reg & SGTL5000_REVID_MASK) >> SGTL5000_REVID_SHIFT;
-
-        if (external_vddd && rev >= 0x11) {
-                /* disable all regulator first */
-                regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
-                                        sgtl5000->supplies);
-                /* free VDDD regulator */
-                regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
-                                        sgtl5000->supplies);
-
-                ret = sgtl5000_replace_vddd_with_ldo(codec);
-                if (ret)
-                        return ret;
-
-                ret = regulator_bulk_enable(ARRAY_SIZE(sgtl5000->supplies),
-                                                sgtl5000->supplies);
-                if (ret)
-                        goto err_regulator_free;
-
-                /* wait for all power rails bring up */
-                udelay(10);
-        }
-
         return 0;
 
-err_regulator_disable:
-        regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
-                                sgtl5000->supplies);
 err_regulator_free:
         regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
                                 sgtl5000->supplies);
-        if (external_vddd)
+err_ldo_remove:
+        if (!external_vddd)
                 ldo_regulator_remove(codec);
         return ret;
 
@@ -1566,6 +1537,7 @@ static int sgtl5000_i2c_probe(struct i2c_client *client,
 
         rev = (reg & SGTL5000_REVID_MASK) >> SGTL5000_REVID_SHIFT;
         dev_info(&client->dev, "sgtl5000 revision 0x%x\n", rev);
+        sgtl5000->revision = rev;
 
         i2c_set_clientdata(client, sgtl5000);
 
diff --git a/sound/soc/codecs/ssm2518.c b/sound/soc/codecs/ssm2518.c
index 95aed552139a..cc8debce752f 100644
--- a/sound/soc/codecs/ssm2518.c
+++ b/sound/soc/codecs/ssm2518.c
@@ -549,13 +549,13 @@ static int ssm2518_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
                 right_slot = 0;
         } else {
                 /* We assume the left channel < right channel */
-                left_slot = ffs(tx_mask);
-                tx_mask &= ~(1 << tx_mask);
+                left_slot = __ffs(tx_mask);
+                tx_mask &= ~(1 << left_slot);
                 if (tx_mask == 0) {
                         right_slot = left_slot;
                 } else {
-                        right_slot = ffs(tx_mask);
-                        tx_mask &= ~(1 << tx_mask);
+                        right_slot = __ffs(tx_mask);
+                        tx_mask &= ~(1 << right_slot);
                 }
         }
 
diff --git a/sound/soc/codecs/ssm2602.c b/sound/soc/codecs/ssm2602.c
index 492644e67ace..c6dd48561884 100644
--- a/sound/soc/codecs/ssm2602.c
+++ b/sound/soc/codecs/ssm2602.c
@@ -53,8 +53,6 @@ enum ssm2602_type {
 struct ssm2602_priv {
         unsigned int sysclk;
         struct snd_pcm_hw_constraint_list *sysclk_constraints;
-        struct snd_pcm_substream *master_substream;
-        struct snd_pcm_substream *slave_substream;
 
         struct regmap *regmap;
 
@@ -277,11 +275,6 @@ static int ssm2602_hw_params(struct snd_pcm_substream *substream,
         int srate = ssm2602_get_coeff(ssm2602->sysclk, params_rate(params));
         unsigned int iface;
 
-        if (substream == ssm2602->slave_substream) {
-                dev_dbg(codec->dev, "Ignoring hw_params for slave substream\n");
-                return 0;
-        }
-
         if (srate < 0)
                 return srate;
 
@@ -314,33 +307,6 @@ static int ssm2602_startup(struct snd_pcm_substream *substream,
 {
         struct snd_soc_codec *codec = dai->codec;
         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
-        struct snd_pcm_runtime *master_runtime;
-
-        /* The DAI has shared clocks so if we already have a playback or
-         * capture going then constrain this substream to match it.
-         * TODO: the ssm2602 allows pairs of non-matching PB/REC rates
-         */
-        if (ssm2602->master_substream) {
-                master_runtime = ssm2602->master_substream->runtime;
-                dev_dbg(codec->dev, "Constraining to %d bits at %dHz\n",
-                        master_runtime->sample_bits,
-                        master_runtime->rate);
-
-                if (master_runtime->rate != 0)
-                        snd_pcm_hw_constraint_minmax(substream->runtime,
-                                                     SNDRV_PCM_HW_PARAM_RATE,
-                                                     master_runtime->rate,
-                                                     master_runtime->rate);
-
-                if (master_runtime->sample_bits != 0)
-                        snd_pcm_hw_constraint_minmax(substream->runtime,
-                                                     SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
-                                                     master_runtime->sample_bits,
-                                                     master_runtime->sample_bits);
-
-                ssm2602->slave_substream = substream;
-        } else
-                ssm2602->master_substream = substream;
 
         if (ssm2602->sysclk_constraints) {
                 snd_pcm_hw_constraint_list(substream->runtime, 0,
@@ -351,19 +317,6 @@ static int ssm2602_startup(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static void ssm2602_shutdown(struct snd_pcm_substream *substream,
-                             struct snd_soc_dai *dai)
-{
-        struct snd_soc_codec *codec = dai->codec;
-        struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
-
-        if (ssm2602->master_substream == substream)
-                ssm2602->master_substream = ssm2602->slave_substream;
-
-        ssm2602->slave_substream = NULL;
-}
-
-
 static int ssm2602_mute(struct snd_soc_dai *dai, int mute)
 {
         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(dai->codec);
@@ -530,7 +483,6 @@ static int ssm2602_set_bias_level(struct snd_soc_codec *codec,
 static const struct snd_soc_dai_ops ssm2602_dai_ops = {
         .startup        = ssm2602_startup,
         .hw_params      = ssm2602_hw_params,
-        .shutdown       = ssm2602_shutdown,
         .digital_mute   = ssm2602_mute,
         .set_sysclk     = ssm2602_set_dai_sysclk,
         .set_fmt        = ssm2602_set_dai_fmt,
@@ -551,6 +503,8 @@ static struct snd_soc_dai_driver ssm2602_dai = {
                 .rates = SSM2602_RATES,
                 .formats = SSM2602_FORMATS,},
         .ops = &ssm2602_dai_ops,
+        .symmetric_rates = 1,
+        .symmetric_samplebits = 1,
 };
 
 static int ssm2602_suspend(struct snd_soc_codec *codec)
@@ -730,7 +684,7 @@ static struct spi_driver ssm2602_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 /*
  * ssm2602 2 wire address is determined by GPIO5
  * state during powerup.
@@ -797,7 +751,7 @@ static int __init ssm2602_modinit(void)
                 return ret;
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&ssm2602_i2c_driver);
         if (ret)
                 return ret;
@@ -813,7 +767,7 @@ static void __exit ssm2602_exit(void)
         spi_unregister_driver(&ssm2602_spi_driver);
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&ssm2602_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
index 546d16b7d38f..470fbfb4b386 100644
--- a/sound/soc/codecs/tlv320aic3x.c
+++ b/sound/soc/codecs/tlv320aic3x.c
@@ -350,16 +350,6 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
                          DACL1_2_LLOPM_VOL, DACR1_2_RLOPM_VOL,
                          0, 118, 1, output_stage_tlv),
 
-        SOC_DOUBLE_R_TLV("Mono Line2 Bypass Volume",
-                         LINE2L_2_MONOLOPM_VOL, LINE2R_2_MONOLOPM_VOL,
-                         0, 118, 1, output_stage_tlv),
-        SOC_DOUBLE_R_TLV("Mono PGA Bypass Volume",
-                         PGAL_2_MONOLOPM_VOL, PGAR_2_MONOLOPM_VOL,
-                         0, 118, 1, output_stage_tlv),
-        SOC_DOUBLE_R_TLV("Mono DAC Playback Volume",
-                         DACL1_2_MONOLOPM_VOL, DACR1_2_MONOLOPM_VOL,
-                         0, 118, 1, output_stage_tlv),
-
         SOC_DOUBLE_R_TLV("HP Line2 Bypass Volume",
                          LINE2L_2_HPLOUT_VOL, LINE2R_2_HPROUT_VOL,
                          0, 118, 1, output_stage_tlv),
@@ -383,7 +373,6 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
         /* Output pin mute controls */
         SOC_DOUBLE_R("Line Playback Switch", LLOPM_CTRL, RLOPM_CTRL, 3,
                      0x01, 0),
-        SOC_SINGLE("Mono Playback Switch", MONOLOPM_CTRL, 3, 0x01, 0),
         SOC_DOUBLE_R("HP Playback Switch", HPLOUT_CTRL, HPROUT_CTRL, 3,
                      0x01, 0),
         SOC_DOUBLE_R("HPCOM Playback Switch", HPLCOM_CTRL, HPRCOM_CTRL, 3,
@@ -412,6 +401,20 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
         SOC_ENUM("ADC HPF Cut-off", aic3x_enum[ADC_HPF_ENUM]),
 };
 
+static const struct snd_kcontrol_new aic3x_mono_controls[] = {
+        SOC_DOUBLE_R_TLV("Mono Line2 Bypass Volume",
+                         LINE2L_2_MONOLOPM_VOL, LINE2R_2_MONOLOPM_VOL,
+                         0, 118, 1, output_stage_tlv),
+        SOC_DOUBLE_R_TLV("Mono PGA Bypass Volume",
+                         PGAL_2_MONOLOPM_VOL, PGAR_2_MONOLOPM_VOL,
+                         0, 118, 1, output_stage_tlv),
+        SOC_DOUBLE_R_TLV("Mono DAC Playback Volume",
+                         DACL1_2_MONOLOPM_VOL, DACR1_2_MONOLOPM_VOL,
+                         0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE("Mono Playback Switch", MONOLOPM_CTRL, 3, 0x01, 0),
+};
+
 /*
  * Class-D amplifier gain. From 0 to 18 dB in 6 dB steps
  */
@@ -565,9 +568,6 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
         SND_SOC_DAPM_PGA("Right HP Out", HPROUT_CTRL, 0, 0, NULL, 0),
         SND_SOC_DAPM_PGA("Right HP Com", HPRCOM_CTRL, 0, 0, NULL, 0),
 
-        /* Mono Output */
-        SND_SOC_DAPM_PGA("Mono Out", MONOLOPM_CTRL, 0, 0, NULL, 0),
-
         /* Inputs to Left ADC */
         SND_SOC_DAPM_ADC("Left ADC", "Left Capture", LINE1L_2_LADC_CTRL, 2, 0),
         SND_SOC_DAPM_MIXER("Left PGA Mixer", SND_SOC_NOPM, 0, 0,
@@ -626,9 +626,6 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
         SND_SOC_DAPM_MIXER("Right Line Mixer", SND_SOC_NOPM, 0, 0,
                            &aic3x_right_line_mixer_controls[0],
                            ARRAY_SIZE(aic3x_right_line_mixer_controls)),
-        SND_SOC_DAPM_MIXER("Mono Mixer", SND_SOC_NOPM, 0, 0,
-                           &aic3x_mono_mixer_controls[0],
-                           ARRAY_SIZE(aic3x_mono_mixer_controls)),
         SND_SOC_DAPM_MIXER("Left HP Mixer", SND_SOC_NOPM, 0, 0,
                            &aic3x_left_hp_mixer_controls[0],
                            ARRAY_SIZE(aic3x_left_hp_mixer_controls)),
@@ -644,7 +641,6 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
 
         SND_SOC_DAPM_OUTPUT("LLOUT"),
         SND_SOC_DAPM_OUTPUT("RLOUT"),
-        SND_SOC_DAPM_OUTPUT("MONO_LOUT"),
         SND_SOC_DAPM_OUTPUT("HPLOUT"),
         SND_SOC_DAPM_OUTPUT("HPROUT"),
         SND_SOC_DAPM_OUTPUT("HPLCOM"),
@@ -666,6 +662,17 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("Detection"),
 };
 
+static const struct snd_soc_dapm_widget aic3x_dapm_mono_widgets[] = {
+        /* Mono Output */
+        SND_SOC_DAPM_PGA("Mono Out", MONOLOPM_CTRL, 0, 0, NULL, 0),
+
+        SND_SOC_DAPM_MIXER("Mono Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_mono_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_mono_mixer_controls)),
+
+        SND_SOC_DAPM_OUTPUT("MONO_LOUT"),
+};
+
 static const struct snd_soc_dapm_widget aic3007_dapm_widgets[] = {
         /* Class-D outputs */
         SND_SOC_DAPM_PGA("Left Class-D Out", CLASSD_CTRL, 3, 0, NULL, 0),
@@ -754,17 +761,6 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Right Line Out", NULL, "Right DAC Mux"},
         {"RLOUT", NULL, "Right Line Out"},
 
-        /* Mono Output */
-        {"Mono Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
-        {"Mono Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
-        {"Mono Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Mono Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
-        {"Mono Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
-        {"Mono Mixer", "DACR1 Switch", "Right DAC Mux"},
-
-        {"Mono Out", NULL, "Mono Mixer"},
-        {"MONO_LOUT", NULL, "Mono Out"},
-
         /* Left HP Output */
         {"Left HP Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Left HP Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
@@ -820,6 +816,18 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HPRCOM", NULL, "Right HP Com"},
 };
 
+static const struct snd_soc_dapm_route intercon_mono[] = {
+        /* Mono Output */
+        {"Mono Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Mono Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
+        {"Mono Mixer", "DACL1 Switch", "Left DAC Mux"},
+        {"Mono Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+        {"Mono Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
+        {"Mono Mixer", "DACR1 Switch", "Right DAC Mux"},
+        {"Mono Out", NULL, "Mono Mixer"},
+        {"MONO_LOUT", NULL, "Mono Out"},
+};
+
 static const struct snd_soc_dapm_route intercon_3007[] = {
         /* Class-D outputs */
         {"Left Class-D Out", NULL, "Left Line Out"},
@@ -833,11 +841,20 @@ static int aic3x_add_widgets(struct snd_soc_codec *codec)
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
         struct snd_soc_dapm_context *dapm = &codec->dapm;
 
-        if (aic3x->model == AIC3X_MODEL_3007) {
+        switch (aic3x->model) {
+        case AIC3X_MODEL_3X:
+        case AIC3X_MODEL_33:
+                snd_soc_dapm_new_controls(dapm, aic3x_dapm_mono_widgets,
+                        ARRAY_SIZE(aic3x_dapm_mono_widgets));
+                snd_soc_dapm_add_routes(dapm, intercon_mono,
+                                        ARRAY_SIZE(intercon_mono));
+                break;
+        case AIC3X_MODEL_3007:
                 snd_soc_dapm_new_controls(dapm, aic3007_dapm_widgets,
                         ARRAY_SIZE(aic3007_dapm_widgets));
                 snd_soc_dapm_add_routes(dapm, intercon_3007,
                                         ARRAY_SIZE(intercon_3007));
+                break;
         }
 
         return 0;
@@ -1218,6 +1235,24 @@ static int aic3x_resume(struct snd_soc_codec *codec)
         return 0;
 }
 
+static void aic3x_mono_init(struct snd_soc_codec *codec)
+{
+        /* DAC to Mono Line Out default volume and route to Output mixer */
+        snd_soc_write(codec, DACL1_2_MONOLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
+        snd_soc_write(codec, DACR1_2_MONOLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
+
+        /* unmute all outputs */
+        snd_soc_update_bits(codec, MONOLOPM_CTRL, UNMUTE, UNMUTE);
+
+        /* PGA to Mono Line Out default volume, disconnect from Output Mixer */
+        snd_soc_write(codec, PGAL_2_MONOLOPM_VOL, DEFAULT_VOL);
+        snd_soc_write(codec, PGAR_2_MONOLOPM_VOL, DEFAULT_VOL);
+
+        /* Line2 to Mono Out default volume, disconnect from Output Mixer */
+        snd_soc_write(codec, LINE2L_2_MONOLOPM_VOL, DEFAULT_VOL);
+        snd_soc_write(codec, LINE2R_2_MONOLOPM_VOL, DEFAULT_VOL);
+}
+
 /*
  * initialise the AIC3X driver
  * register the mixer and dsp interfaces with the kernel
@@ -1241,14 +1276,10 @@ static int aic3x_init(struct snd_soc_codec *codec)
         /* DAC to Line Out default volume and route to Output mixer */
         snd_soc_write(codec, DACL1_2_LLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
         snd_soc_write(codec, DACR1_2_RLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
-        /* DAC to Mono Line Out default volume and route to Output mixer */
-        snd_soc_write(codec, DACL1_2_MONOLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
-        snd_soc_write(codec, DACR1_2_MONOLOPM_VOL, DEFAULT_VOL | ROUTE_ON);
 
         /* unmute all outputs */
         snd_soc_update_bits(codec, LLOPM_CTRL, UNMUTE, UNMUTE);
         snd_soc_update_bits(codec, RLOPM_CTRL, UNMUTE, UNMUTE);
-        snd_soc_update_bits(codec, MONOLOPM_CTRL, UNMUTE, UNMUTE);
         snd_soc_update_bits(codec, HPLOUT_CTRL, UNMUTE, UNMUTE);
         snd_soc_update_bits(codec, HPROUT_CTRL, UNMUTE, UNMUTE);
         snd_soc_update_bits(codec, HPLCOM_CTRL, UNMUTE, UNMUTE);
@@ -1269,9 +1300,6 @@ static int aic3x_init(struct snd_soc_codec *codec)
         /* PGA to Line Out default volume, disconnect from Output Mixer */
         snd_soc_write(codec, PGAL_2_LLOPM_VOL, DEFAULT_VOL);
         snd_soc_write(codec, PGAR_2_RLOPM_VOL, DEFAULT_VOL);
-        /* PGA to Mono Line Out default volume, disconnect from Output Mixer */
-        snd_soc_write(codec, PGAL_2_MONOLOPM_VOL, DEFAULT_VOL);
-        snd_soc_write(codec, PGAR_2_MONOLOPM_VOL, DEFAULT_VOL);
 
         /* Line2 to HP Bypass default volume, disconnect from Output Mixer */
         snd_soc_write(codec, LINE2L_2_HPLOUT_VOL, DEFAULT_VOL);
@@ -1281,12 +1309,15 @@ static int aic3x_init(struct snd_soc_codec *codec)
         /* Line2 Line Out default volume, disconnect from Output Mixer */
         snd_soc_write(codec, LINE2L_2_LLOPM_VOL, DEFAULT_VOL);
         snd_soc_write(codec, LINE2R_2_RLOPM_VOL, DEFAULT_VOL);
-        /* Line2 to Mono Out default volume, disconnect from Output Mixer */
-        snd_soc_write(codec, LINE2L_2_MONOLOPM_VOL, DEFAULT_VOL);
-        snd_soc_write(codec, LINE2R_2_MONOLOPM_VOL, DEFAULT_VOL);
 
-        if (aic3x->model == AIC3X_MODEL_3007) {
+        switch (aic3x->model) {
+        case AIC3X_MODEL_3X:
+        case AIC3X_MODEL_33:
+                aic3x_mono_init(codec);
+                break;
+        case AIC3X_MODEL_3007:
                 snd_soc_write(codec, CLASSD_CTRL, 0);
+                break;
         }
 
         return 0;
@@ -1343,8 +1374,17 @@ static int aic3x_probe(struct snd_soc_codec *codec)
                               (aic3x->setup->gpio_func[1] & 0xf) << 4);
         }
 
-        if (aic3x->model == AIC3X_MODEL_3007)
-                snd_soc_add_codec_controls(codec, &aic3x_classd_amp_gain_ctrl, 1);
+        switch (aic3x->model) {
+        case AIC3X_MODEL_3X:
+        case AIC3X_MODEL_33:
+                snd_soc_add_codec_controls(codec, aic3x_mono_controls,
+                                ARRAY_SIZE(aic3x_mono_controls));
+                break;
+        case AIC3X_MODEL_3007:
+                snd_soc_add_codec_controls(codec,
+                                &aic3x_classd_amp_gain_ctrl, 1);
+                break;
+        }
 
         /* set mic bias voltage */
         switch (aic3x->micbias_vg) {
diff --git a/sound/soc/codecs/twl6040.c b/sound/soc/codecs/twl6040.c
index f2f4bcb2ff71..0afe8bef6765 100644
--- a/sound/soc/codecs/twl6040.c
+++ b/sound/soc/codecs/twl6040.c
@@ -72,6 +72,7 @@ struct twl6040_data {
         int hs_power_mode_locked;
         bool dl1_unmuted;
         bool dl2_unmuted;
+        u8 dl12_cache[TWL6040_REG_HFRCTL - TWL6040_REG_HSLCTL + 1];
         unsigned int clk_in;
         unsigned int sysclk;
         struct twl6040_jack_data hs_jack;
@@ -79,75 +80,6 @@ struct twl6040_data {
         struct mutex mutex;
 };
 
-/*
- * twl6040 register cache & default register settings
- */
-static const u8 twl6040_reg[TWL6040_CACHEREGNUM] = {
-        0x00, /* not used       0x00    */
-        0x4B, /* REG_ASICID     0x01 (ro) */
-        0x00, /* REG_ASICREV    0x02 (ro) */
-        0x00, /* REG_INTID      0x03    */
-        0x00, /* REG_INTMR      0x04    */
-        0x00, /* REG_NCPCTRL    0x05    */
-        0x00, /* REG_LDOCTL     0x06    */
-        0x60, /* REG_HPPLLCTL   0x07    */
-        0x00, /* REG_LPPLLCTL   0x08    */
-        0x4A, /* REG_LPPLLDIV   0x09    */
-        0x00, /* REG_AMICBCTL   0x0A    */
-        0x00, /* REG_DMICBCTL   0x0B    */
-        0x00, /* REG_MICLCTL    0x0C    */
-        0x00, /* REG_MICRCTL    0x0D    */
-        0x00, /* REG_MICGAIN    0x0E    */
-        0x1B, /* REG_LINEGAIN   0x0F    */
-        0x00, /* REG_HSLCTL     0x10    */
-        0x00, /* REG_HSRCTL     0x11    */
-        0x00, /* REG_HSGAIN     0x12    */
-        0x00, /* REG_EARCTL     0x13    */
-        0x00, /* REG_HFLCTL     0x14    */
-        0x00, /* REG_HFLGAIN    0x15    */
-        0x00, /* REG_HFRCTL     0x16    */
-        0x00, /* REG_HFRGAIN    0x17    */
-        0x00, /* REG_VIBCTLL    0x18    */
-        0x00, /* REG_VIBDATL    0x19    */
-        0x00, /* REG_VIBCTLR    0x1A    */
-        0x00, /* REG_VIBDATR    0x1B    */
-        0x00, /* REG_HKCTL1     0x1C    */
-        0x00, /* REG_HKCTL2     0x1D    */
-        0x00, /* REG_GPOCTL     0x1E    */
-        0x00, /* REG_ALB        0x1F    */
-        0x00, /* REG_DLB        0x20    */
-        0x00, /* not used       0x21    */
-        0x00, /* not used       0x22    */
-        0x00, /* not used       0x23    */
-        0x00, /* not used       0x24    */
-        0x00, /* not used       0x25    */
-        0x00, /* not used       0x26    */
-        0x00, /* not used       0x27    */
-        0x00, /* REG_TRIM1      0x28    */
-        0x00, /* REG_TRIM2      0x29    */
-        0x00, /* REG_TRIM3      0x2A    */
-        0x00, /* REG_HSOTRIM    0x2B    */
-        0x00, /* REG_HFOTRIM    0x2C    */
-        0x09, /* REG_ACCCTL     0x2D    */
-        0x00, /* REG_STATUS     0x2E (ro) */
-};
-
-/* List of registers to be restored after power up */
-static const int twl6040_restore_list[] = {
-        TWL6040_REG_MICLCTL,
-        TWL6040_REG_MICRCTL,
-        TWL6040_REG_MICGAIN,
-        TWL6040_REG_LINEGAIN,
-        TWL6040_REG_HSLCTL,
-        TWL6040_REG_HSRCTL,
-        TWL6040_REG_HSGAIN,
-        TWL6040_REG_EARCTL,
-        TWL6040_REG_HFLCTL,
-        TWL6040_REG_HFLGAIN,
-        TWL6040_REG_HFRCTL,
-        TWL6040_REG_HFRGAIN,
-};
-
 /* set of rates for each pll: low-power and high-performance */
 static unsigned int lp_rates[] = {
         8000,
@@ -174,53 +106,33 @@ static struct snd_pcm_hw_constraint_list sysclk_constraints[] = {
         { .count = ARRAY_SIZE(hp_rates), .list = hp_rates, },
 };
 
-/*
- * read twl6040 register cache
- */
-static inline unsigned int twl6040_read_reg_cache(struct snd_soc_codec *codec,
-                                                unsigned int reg)
-{
-        u8 *cache = codec->reg_cache;
-
-        if (reg >= TWL6040_CACHEREGNUM)
-                return -EIO;
-
-        return cache[reg];
-}
-
-/*
- * write twl6040 register cache
- */
-static inline void twl6040_write_reg_cache(struct snd_soc_codec *codec,
-                                                u8 reg, u8 value)
-{
-        u8 *cache = codec->reg_cache;
-
-        if (reg >= TWL6040_CACHEREGNUM)
-                return;
-        cache[reg] = value;
-}
-
-/*
- * read from twl6040 hardware register
- */
-static int twl6040_read_reg_volatile(struct snd_soc_codec *codec,
-                        unsigned int reg)
+static unsigned int twl6040_read(struct snd_soc_codec *codec, unsigned int reg)
 {
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
         struct twl6040 *twl6040 = codec->control_data;
         u8 value;
 
         if (reg >= TWL6040_CACHEREGNUM)
                 return -EIO;
 
-        value = twl6040_reg_read(twl6040, reg);
-        twl6040_write_reg_cache(codec, reg, value);
+        switch (reg) {
+        case TWL6040_REG_HSLCTL:
+        case TWL6040_REG_HSRCTL:
+        case TWL6040_REG_EARCTL:
+        case TWL6040_REG_HFLCTL:
+        case TWL6040_REG_HFRCTL:
+                value = priv->dl12_cache[reg - TWL6040_REG_HSLCTL];
+                break;
+        default:
+                value = twl6040_reg_read(twl6040, reg);
+                break;
+        }
 
         return value;
 }
 
-static bool twl6040_is_path_unmuted(struct snd_soc_codec *codec,
-                                    unsigned int reg)
+static bool twl6040_can_write_to_chip(struct snd_soc_codec *codec,
+                                  unsigned int reg)
 {
         struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
@@ -238,9 +150,24 @@ static bool twl6040_is_path_unmuted(struct snd_soc_codec *codec,
         }
 }
 
-/*
- * write to the twl6040 register space
- */
+static inline void twl6040_update_dl12_cache(struct snd_soc_codec *codec,
+                                             u8 reg, u8 value)
+{
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+
+        switch (reg) {
+        case TWL6040_REG_HSLCTL:
+        case TWL6040_REG_HSRCTL:
+        case TWL6040_REG_EARCTL:
+        case TWL6040_REG_HFLCTL:
+        case TWL6040_REG_HFRCTL:
+                priv->dl12_cache[reg - TWL6040_REG_HSLCTL] = value;
+                break;
+        default:
+                break;
+        }
+}
+
 static int twl6040_write(struct snd_soc_codec *codec,
                         unsigned int reg, unsigned int value)
 {
@@ -249,8 +176,8 @@ static int twl6040_write(struct snd_soc_codec *codec,
         if (reg >= TWL6040_CACHEREGNUM)
                 return -EIO;
 
-        twl6040_write_reg_cache(codec, reg, value);
-        if (twl6040_is_path_unmuted(codec, reg))
+        twl6040_update_dl12_cache(codec, reg, value);
+        if (twl6040_can_write_to_chip(codec, reg))
                 return twl6040_reg_write(twl6040, reg, value);
         else
                 return 0;
@@ -258,45 +185,27 @@ static int twl6040_write(struct snd_soc_codec *codec,
 
 static void twl6040_init_chip(struct snd_soc_codec *codec)
 {
-        struct twl6040 *twl6040 = codec->control_data;
-        u8 val;
-
-        /* Update reg_cache: ASICREV, and TRIM values */
-        val = twl6040_get_revid(twl6040);
-        twl6040_write_reg_cache(codec, TWL6040_REG_ASICREV, val);
-
-        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM1);
-        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM2);
-        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM3);
-        twl6040_read_reg_volatile(codec, TWL6040_REG_HSOTRIM);
-        twl6040_read_reg_volatile(codec, TWL6040_REG_HFOTRIM);
+        twl6040_read(codec, TWL6040_REG_TRIM1);
+        twl6040_read(codec, TWL6040_REG_TRIM2);
+        twl6040_read(codec, TWL6040_REG_TRIM3);
+        twl6040_read(codec, TWL6040_REG_HSOTRIM);
+        twl6040_read(codec, TWL6040_REG_HFOTRIM);
 
         /* Change chip defaults */
         /* No imput selected for microphone amplifiers */
-        twl6040_write_reg_cache(codec, TWL6040_REG_MICLCTL, 0x18);
-        twl6040_write_reg_cache(codec, TWL6040_REG_MICRCTL, 0x18);
+        twl6040_write(codec, TWL6040_REG_MICLCTL, 0x18);
+        twl6040_write(codec, TWL6040_REG_MICRCTL, 0x18);
 
         /*
          * We need to lower the default gain values, so the ramp code
          * can work correctly for the first playback.
          * This reduces the pop noise heard at the first playback.
          */
-        twl6040_write_reg_cache(codec, TWL6040_REG_HSGAIN, 0xff);
-        twl6040_write_reg_cache(codec, TWL6040_REG_EARCTL, 0x1e);
-        twl6040_write_reg_cache(codec, TWL6040_REG_HFLGAIN, 0x1d);
-        twl6040_write_reg_cache(codec, TWL6040_REG_HFRGAIN, 0x1d);
-        twl6040_write_reg_cache(codec, TWL6040_REG_LINEGAIN, 0);
-}
-
-static void twl6040_restore_regs(struct snd_soc_codec *codec)
-{
-        u8 *cache = codec->reg_cache;
-        int reg, i;
-
-        for (i = 0; i < ARRAY_SIZE(twl6040_restore_list); i++) {
-                reg = twl6040_restore_list[i];
-                twl6040_write(codec, reg, cache[reg]);
-        }
+        twl6040_write(codec, TWL6040_REG_HSGAIN, 0xff);
+        twl6040_write(codec, TWL6040_REG_EARCTL, 0x1e);
+        twl6040_write(codec, TWL6040_REG_HFLGAIN, 0x1d);
+        twl6040_write(codec, TWL6040_REG_HFRGAIN, 0x1d);
+        twl6040_write(codec, TWL6040_REG_LINEGAIN, 0);
 }
 
 /* set headset dac and driver power mode */
@@ -305,8 +214,8 @@ static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
         int hslctl, hsrctl;
         int mask = TWL6040_HSDRVMODE | TWL6040_HSDACMODE;
 
-        hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
-        hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
+        hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL);
+        hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL);
 
         if (high_perf) {
                 hslctl &= ~mask;
@@ -333,8 +242,8 @@ static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
          * Both HS DAC need to be turned on (before the HS driver) and off at
          * the same time.
          */
-        hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
-        hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
+        hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL);
+        hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL);
         if (SND_SOC_DAPM_EVENT_ON(event)) {
                 hslctl |= TWL6040_HSDACENA;
                 hsrctl |= TWL6040_HSDACENA;
@@ -379,7 +288,7 @@ static void twl6040_hs_jack_report(struct snd_soc_codec *codec,
         mutex_lock(&priv->mutex);
 
         /* Sync status */
-        status = twl6040_read_reg_volatile(codec, TWL6040_REG_STATUS);
+        status = twl6040_read(codec, TWL6040_REG_STATUS);
         if (status & TWL6040_PLUGCOMP)
                 snd_soc_jack_report(jack, report, report);
         else
@@ -431,7 +340,7 @@ static int twl6040_soc_dapm_put_vibra_enum(struct snd_kcontrol *kcontrol,
         unsigned int val;
 
         /* Do not allow changes while Input/FF efect is running */
-        val = twl6040_read_reg_volatile(codec, e->reg);
+        val = twl6040_read(codec, e->reg);
         if (val & TWL6040_VIBENA && !(val & TWL6040_VIBSEL))
                 return -EBUSY;
 
@@ -656,7 +565,7 @@ int twl6040_get_trim_value(struct snd_soc_codec *codec, enum twl6040_trim trim)
         if (unlikely(trim >= TWL6040_TRIM_INVAL))
                 return -EINVAL;
 
-        return twl6040_read_reg_cache(codec, TWL6040_REG_TRIM1 + trim);
+        return twl6040_read(codec, TWL6040_REG_TRIM1 + trim);
 }
 EXPORT_SYMBOL_GPL(twl6040_get_trim_value);
 
@@ -931,8 +840,6 @@ static int twl6040_set_bias_level(struct snd_soc_codec *codec,
 
                 priv->codec_powered = 1;
 
-                twl6040_restore_regs(codec);
-
                 /* Set external boost GPO */
                 twl6040_write(codec, TWL6040_REG_GPOCTL, 0x02);
                 break;
@@ -1053,9 +960,9 @@ static void twl6040_mute_path(struct snd_soc_codec *codec, enum twl6040_dai_id i
 
         switch (id) {
         case TWL6040_DAI_DL1:
-                hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
-                hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
-                earctl = twl6040_read_reg_cache(codec, TWL6040_REG_EARCTL);
+                hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL);
+                hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL);
+                earctl = twl6040_read(codec, TWL6040_REG_EARCTL);
 
                 if (mute) {
                         /* Power down drivers and DACs */
@@ -1071,8 +978,8 @@ static void twl6040_mute_path(struct snd_soc_codec *codec, enum twl6040_dai_id i
                 priv->dl1_unmuted = !mute;
                 break;
         case TWL6040_DAI_DL2:
-                hflctl = twl6040_read_reg_cache(codec, TWL6040_REG_HFLCTL);
-                hfrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HFRCTL);
+                hflctl = twl6040_read(codec, TWL6040_REG_HFLCTL);
+                hfrctl = twl6040_read(codec, TWL6040_REG_HFRCTL);
 
                 if (mute) {
                         /* Power down drivers and DACs */
@@ -1209,6 +1116,7 @@ static int twl6040_resume(struct snd_soc_codec *codec)
 static int twl6040_probe(struct snd_soc_codec *codec)
 {
         struct twl6040_data *priv;
+        struct twl6040 *twl6040 = dev_get_drvdata(codec->dev->parent);
         struct platform_device *pdev = container_of(codec->dev,
                                                    struct platform_device, dev);
         int ret = 0;
@@ -1220,7 +1128,7 @@ static int twl6040_probe(struct snd_soc_codec *codec)
         snd_soc_codec_set_drvdata(codec, priv);
 
         priv->codec = codec;
-        codec->control_data = dev_get_drvdata(codec->dev->parent);
+        codec->control_data = twl6040;
 
         priv->plug_irq = platform_get_irq(pdev, 0);
         if (priv->plug_irq < 0) {
@@ -1240,10 +1148,10 @@ static int twl6040_probe(struct snd_soc_codec *codec)
                 return ret;
         }
 
+        twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         twl6040_init_chip(codec);
 
-        /* power on device */
-        return twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        return 0;
 }
 
 static int twl6040_remove(struct snd_soc_codec *codec)
@@ -1261,12 +1169,9 @@ static struct snd_soc_codec_driver soc_codec_dev_twl6040 = {
         .remove = twl6040_remove,
         .suspend = twl6040_suspend,
         .resume = twl6040_resume,
-        .read = twl6040_read_reg_cache,
+        .read = twl6040_read,
         .write = twl6040_write,
         .set_bias_level = twl6040_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(twl6040_reg),
-        .reg_word_size = sizeof(u8),
-        .reg_cache_default = twl6040_reg,
         .ignore_pmdown_time = true,
 
         .controls = twl6040_snd_controls,
diff --git a/sound/soc/codecs/uda1380.c b/sound/soc/codecs/uda1380.c
index fd0a314bc209..726df6d43c2b 100644
--- a/sound/soc/codecs/uda1380.c
+++ b/sound/soc/codecs/uda1380.c
@@ -794,7 +794,7 @@ static struct snd_soc_codec_driver soc_codec_dev_uda1380 = {
         .num_dapm_routes = ARRAY_SIZE(uda1380_dapm_routes),
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int uda1380_i2c_probe(struct i2c_client *i2c,
                              const struct i2c_device_id *id)
 {
@@ -840,7 +840,7 @@ static struct i2c_driver uda1380_i2c_driver = {
 static int __init uda1380_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&uda1380_i2c_driver);
         if (ret != 0)
                 pr_err("Failed to register UDA1380 I2C driver: %d\n", ret);
@@ -851,7 +851,7 @@ module_init(uda1380_modinit);
 
 static void __exit uda1380_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&uda1380_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c
index a08e8bf6d07c..ce9c8e14d4bd 100644
--- a/sound/soc/codecs/wm5102.c
+++ b/sound/soc/codecs/wm5102.c
@@ -601,8 +601,8 @@ static int wm5102_sysclk_ev(struct snd_soc_dapm_widget *w,
         case SND_SOC_DAPM_POST_PMU:
                 if (patch)
                         for (i = 0; i < patch_size; i++)
-                                regmap_write(regmap, patch[i].reg,
-                                             patch[i].def);
+                                regmap_write_async(regmap, patch[i].reg,
+                                                   patch[i].def);
                 break;
 
         default:
diff --git a/sound/soc/codecs/wm5110.c b/sound/soc/codecs/wm5110.c
index 0ab2dc296474..22bd7dd80bba 100644
--- a/sound/soc/codecs/wm5110.c
+++ b/sound/soc/codecs/wm5110.c
@@ -30,13 +30,51 @@
 #include <linux/mfd/arizona/registers.h>
 
 #include "arizona.h"
+#include "wm_adsp.h"
 #include "wm5110.h"
 
+#define WM5110_NUM_ADSP 4
+
 struct wm5110_priv {
         struct arizona_priv core;
         struct arizona_fll fll[2];
 };
 
+static const struct wm_adsp_region wm5110_dsp1_regions[] = {
+        { .type = WMFW_ADSP2_PM, .base = 0x100000 },
+        { .type = WMFW_ADSP2_ZM, .base = 0x180000 },
+        { .type = WMFW_ADSP2_XM, .base = 0x190000 },
+        { .type = WMFW_ADSP2_YM, .base = 0x1a8000 },
+};
+
+static const struct wm_adsp_region wm5110_dsp2_regions[] = {
+        { .type = WMFW_ADSP2_PM, .base = 0x200000 },
+        { .type = WMFW_ADSP2_ZM, .base = 0x280000 },
+        { .type = WMFW_ADSP2_XM, .base = 0x290000 },
+        { .type = WMFW_ADSP2_YM, .base = 0x2a8000 },
+};
+
+static const struct wm_adsp_region wm5110_dsp3_regions[] = {
+        { .type = WMFW_ADSP2_PM, .base = 0x300000 },
+        { .type = WMFW_ADSP2_ZM, .base = 0x380000 },
+        { .type = WMFW_ADSP2_XM, .base = 0x390000 },
+        { .type = WMFW_ADSP2_YM, .base = 0x3a8000 },
+};
+
+static const struct wm_adsp_region wm5110_dsp4_regions[] = {
+        { .type = WMFW_ADSP2_PM, .base = 0x400000 },
+        { .type = WMFW_ADSP2_ZM, .base = 0x480000 },
+        { .type = WMFW_ADSP2_XM, .base = 0x490000 },
+        { .type = WMFW_ADSP2_YM, .base = 0x4a8000 },
+};
+
+static const struct wm_adsp_region *wm5110_dsp_regions[] = {
+        wm5110_dsp1_regions,
+        wm5110_dsp2_regions,
+        wm5110_dsp3_regions,
+        wm5110_dsp4_regions,
+};
+
 static const struct reg_default wm5110_sysclk_revd_patch[] = {
         { 0x3093, 0x1001 },
         { 0x30E3, 0x1301 },
@@ -67,8 +105,8 @@ static int wm5110_sysclk_ev(struct snd_soc_dapm_widget *w,
         case SND_SOC_DAPM_POST_PMU:
                 if (patch)
                         for (i = 0; i < patch_size; i++)
-                                regmap_write(regmap, patch[i].reg,
-                                             patch[i].def);
+                                regmap_write_async(regmap, patch[i].reg,
+                                                   patch[i].def);
                 break;
 
         default:
@@ -117,6 +155,25 @@ SOC_SINGLE_RANGE_TLV("IN3L Volume", ARIZONA_IN3L_CONTROL,
 SOC_SINGLE_RANGE_TLV("IN3R Volume", ARIZONA_IN3R_CONTROL,
                      ARIZONA_IN3R_PGA_VOL_SHIFT, 0x40, 0x5f, 0, ana_tlv),
 
+SOC_ENUM("IN HPF Cutoff Frequency", arizona_in_hpf_cut_enum),
+
+SOC_SINGLE("IN1L HPF Switch", ARIZONA_IN1L_CONTROL,
+           ARIZONA_IN1L_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN1R HPF Switch", ARIZONA_IN1R_CONTROL,
+           ARIZONA_IN1R_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN2L HPF Switch", ARIZONA_IN2L_CONTROL,
+           ARIZONA_IN2L_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN2R HPF Switch", ARIZONA_IN2R_CONTROL,
+           ARIZONA_IN2R_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN3L HPF Switch", ARIZONA_IN3L_CONTROL,
+           ARIZONA_IN3L_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN3R HPF Switch", ARIZONA_IN3R_CONTROL,
+           ARIZONA_IN3R_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN4L HPF Switch", ARIZONA_IN4L_CONTROL,
+           ARIZONA_IN4L_HPF_SHIFT, 1, 0),
+SOC_SINGLE("IN4R HPF Switch", ARIZONA_IN4R_CONTROL,
+           ARIZONA_IN4R_HPF_SHIFT, 1, 0),
+
 SOC_SINGLE_TLV("IN1L Digital Volume", ARIZONA_ADC_DIGITAL_VOLUME_1L,
                ARIZONA_IN1L_DIG_VOL_SHIFT, 0xbf, 0, digital_tlv),
 SOC_SINGLE_TLV("IN1R Digital Volume", ARIZONA_ADC_DIGITAL_VOLUME_1R,
@@ -220,6 +277,14 @@ SOC_ENUM("LHPF2 Mode", arizona_lhpf2_mode),
 SOC_ENUM("LHPF3 Mode", arizona_lhpf3_mode),
 SOC_ENUM("LHPF4 Mode", arizona_lhpf4_mode),
 
+SOC_VALUE_ENUM("ISRC1 FSL", arizona_isrc_fsl[0]),
+SOC_VALUE_ENUM("ISRC2 FSL", arizona_isrc_fsl[1]),
+SOC_VALUE_ENUM("ISRC3 FSL", arizona_isrc_fsl[2]),
+SOC_VALUE_ENUM("ISRC1 FSH", arizona_isrc_fsh[0]),
+SOC_VALUE_ENUM("ISRC2 FSH", arizona_isrc_fsh[1]),
+SOC_VALUE_ENUM("ISRC3 FSH", arizona_isrc_fsh[2]),
+SOC_VALUE_ENUM("ASRC RATE 1", arizona_asrc_rate1),
+
 ARIZONA_MIXER_CONTROLS("DSP1L", ARIZONA_DSP1LMIX_INPUT_1_SOURCE),
 ARIZONA_MIXER_CONTROLS("DSP1R", ARIZONA_DSP1RMIX_INPUT_1_SOURCE),
 ARIZONA_MIXER_CONTROLS("DSP2L", ARIZONA_DSP2LMIX_INPUT_1_SOURCE),
@@ -285,6 +350,13 @@ SOC_DOUBLE("SPKDAT1 Switch", ARIZONA_PDM_SPK1_CTRL_1, ARIZONA_SPK1L_MUTE_SHIFT,
 SOC_DOUBLE("SPKDAT2 Switch", ARIZONA_PDM_SPK2_CTRL_1, ARIZONA_SPK2L_MUTE_SHIFT,
            ARIZONA_SPK2R_MUTE_SHIFT, 1, 1),
 
+SOC_DOUBLE("HPOUT1 DRE Switch", ARIZONA_DRE_ENABLE,
+           ARIZONA_DRE1L_ENA_SHIFT, ARIZONA_DRE1R_ENA_SHIFT, 1, 0),
+SOC_DOUBLE("HPOUT2 DRE Switch", ARIZONA_DRE_ENABLE,
+           ARIZONA_DRE2L_ENA_SHIFT, ARIZONA_DRE2R_ENA_SHIFT, 1, 0),
+SOC_DOUBLE("HPOUT3 DRE Switch", ARIZONA_DRE_ENABLE,
+           ARIZONA_DRE3L_ENA_SHIFT, ARIZONA_DRE3R_ENA_SHIFT, 1, 0),
+
 SOC_ENUM("Output Ramp Up", arizona_out_vi_ramp),
 SOC_ENUM("Output Ramp Down", arizona_out_vd_ramp),
 
@@ -318,6 +390,10 @@ ARIZONA_MIXER_CONTROLS("AIF1TX8", ARIZONA_AIF1TX8MIX_INPUT_1_SOURCE),
 
 ARIZONA_MIXER_CONTROLS("AIF2TX1", ARIZONA_AIF2TX1MIX_INPUT_1_SOURCE),
 ARIZONA_MIXER_CONTROLS("AIF2TX2", ARIZONA_AIF2TX2MIX_INPUT_1_SOURCE),
+ARIZONA_MIXER_CONTROLS("AIF2TX3", ARIZONA_AIF2TX3MIX_INPUT_1_SOURCE),
+ARIZONA_MIXER_CONTROLS("AIF2TX4", ARIZONA_AIF2TX4MIX_INPUT_1_SOURCE),
+ARIZONA_MIXER_CONTROLS("AIF2TX5", ARIZONA_AIF2TX5MIX_INPUT_1_SOURCE),
+ARIZONA_MIXER_CONTROLS("AIF2TX6", ARIZONA_AIF2TX6MIX_INPUT_1_SOURCE),
 
 ARIZONA_MIXER_CONTROLS("AIF3TX1", ARIZONA_AIF3TX1MIX_INPUT_1_SOURCE),
 ARIZONA_MIXER_CONTROLS("AIF3TX2", ARIZONA_AIF3TX2MIX_INPUT_1_SOURCE),
@@ -347,6 +423,22 @@ ARIZONA_MIXER_ENUMS(LHPF2, ARIZONA_HPLP2MIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(LHPF3, ARIZONA_HPLP3MIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(LHPF4, ARIZONA_HPLP4MIX_INPUT_1_SOURCE);
 
+ARIZONA_MIXER_ENUMS(DSP1L, ARIZONA_DSP1LMIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(DSP1R, ARIZONA_DSP1RMIX_INPUT_1_SOURCE);
+ARIZONA_DSP_AUX_ENUMS(DSP1, ARIZONA_DSP1AUX1MIX_INPUT_1_SOURCE);
+
+ARIZONA_MIXER_ENUMS(DSP2L, ARIZONA_DSP2LMIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(DSP2R, ARIZONA_DSP2RMIX_INPUT_1_SOURCE);
+ARIZONA_DSP_AUX_ENUMS(DSP2, ARIZONA_DSP2AUX1MIX_INPUT_1_SOURCE);
+
+ARIZONA_MIXER_ENUMS(DSP3L, ARIZONA_DSP3LMIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(DSP3R, ARIZONA_DSP3RMIX_INPUT_1_SOURCE);
+ARIZONA_DSP_AUX_ENUMS(DSP3, ARIZONA_DSP3AUX1MIX_INPUT_1_SOURCE);
+
+ARIZONA_MIXER_ENUMS(DSP4L, ARIZONA_DSP4LMIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(DSP4R, ARIZONA_DSP4RMIX_INPUT_1_SOURCE);
+ARIZONA_DSP_AUX_ENUMS(DSP4, ARIZONA_DSP4AUX1MIX_INPUT_1_SOURCE);
+
 ARIZONA_MIXER_ENUMS(Mic, ARIZONA_MICMIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(Noise, ARIZONA_NOISEMIX_INPUT_1_SOURCE);
 
@@ -377,6 +469,10 @@ ARIZONA_MIXER_ENUMS(AIF1TX8, ARIZONA_AIF1TX8MIX_INPUT_1_SOURCE);
 
 ARIZONA_MIXER_ENUMS(AIF2TX1, ARIZONA_AIF2TX1MIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(AIF2TX2, ARIZONA_AIF2TX2MIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(AIF2TX3, ARIZONA_AIF2TX3MIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(AIF2TX4, ARIZONA_AIF2TX4MIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(AIF2TX5, ARIZONA_AIF2TX5MIX_INPUT_1_SOURCE);
+ARIZONA_MIXER_ENUMS(AIF2TX6, ARIZONA_AIF2TX6MIX_INPUT_1_SOURCE);
 
 ARIZONA_MIXER_ENUMS(AIF3TX1, ARIZONA_AIF3TX1MIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(AIF3TX2, ARIZONA_AIF3TX2MIX_INPUT_1_SOURCE);
@@ -395,6 +491,36 @@ ARIZONA_MUX_ENUMS(ASRC1R, ARIZONA_ASRC1RMIX_INPUT_1_SOURCE);
 ARIZONA_MUX_ENUMS(ASRC2L, ARIZONA_ASRC2LMIX_INPUT_1_SOURCE);
 ARIZONA_MUX_ENUMS(ASRC2R, ARIZONA_ASRC2RMIX_INPUT_1_SOURCE);
 
+ARIZONA_MUX_ENUMS(ISRC1INT1, ARIZONA_ISRC1INT1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1INT2, ARIZONA_ISRC1INT2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1INT3, ARIZONA_ISRC1INT3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1INT4, ARIZONA_ISRC1INT4MIX_INPUT_1_SOURCE);
+
+ARIZONA_MUX_ENUMS(ISRC1DEC1, ARIZONA_ISRC1DEC1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1DEC2, ARIZONA_ISRC1DEC2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1DEC3, ARIZONA_ISRC1DEC3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC1DEC4, ARIZONA_ISRC1DEC4MIX_INPUT_1_SOURCE);
+
+ARIZONA_MUX_ENUMS(ISRC2INT1, ARIZONA_ISRC2INT1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2INT2, ARIZONA_ISRC2INT2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2INT3, ARIZONA_ISRC2INT3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2INT4, ARIZONA_ISRC2INT4MIX_INPUT_1_SOURCE);
+
+ARIZONA_MUX_ENUMS(ISRC2DEC1, ARIZONA_ISRC2DEC1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2DEC2, ARIZONA_ISRC2DEC2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2DEC3, ARIZONA_ISRC2DEC3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC2DEC4, ARIZONA_ISRC2DEC4MIX_INPUT_1_SOURCE);
+
+ARIZONA_MUX_ENUMS(ISRC3INT1, ARIZONA_ISRC3INT1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3INT2, ARIZONA_ISRC3INT2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3INT3, ARIZONA_ISRC3INT3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3INT4, ARIZONA_ISRC3INT4MIX_INPUT_1_SOURCE);
+
+ARIZONA_MUX_ENUMS(ISRC3DEC1, ARIZONA_ISRC3DEC1MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3DEC2, ARIZONA_ISRC3DEC2MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3DEC3, ARIZONA_ISRC3DEC3MIX_INPUT_1_SOURCE);
+ARIZONA_MUX_ENUMS(ISRC3DEC4, ARIZONA_ISRC3DEC4MIX_INPUT_1_SOURCE);
+
 static const char *wm5110_aec_loopback_texts[] = {
         "HPOUT1L", "HPOUT1R", "HPOUT2L", "HPOUT2R", "HPOUT3L", "HPOUT3R",
         "SPKOUTL", "SPKOUTR", "SPKDAT1L", "SPKDAT1R", "SPKDAT2L", "SPKDAT2R",
@@ -535,6 +661,65 @@ SND_SOC_DAPM_PGA("ASRC2L", ARIZONA_ASRC_ENABLE, ARIZONA_ASRC2L_ENA_SHIFT, 0,
 SND_SOC_DAPM_PGA("ASRC2R", ARIZONA_ASRC_ENABLE, ARIZONA_ASRC2R_ENA_SHIFT, 0,
                  NULL, 0),
 
+WM_ADSP2("DSP1", 0),
+WM_ADSP2("DSP2", 1),
+WM_ADSP2("DSP3", 2),
+WM_ADSP2("DSP4", 3),
+
+SND_SOC_DAPM_PGA("ISRC1INT1", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_INT0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1INT2", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_INT1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1INT3", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_INT2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1INT4", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_INT3_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("ISRC1DEC1", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_DEC0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1DEC2", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_DEC1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1DEC3", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_DEC2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC1DEC4", ARIZONA_ISRC_1_CTRL_3,
+                 ARIZONA_ISRC1_DEC3_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("ISRC2INT1", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_INT0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2INT2", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_INT1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2INT3", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_INT2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2INT4", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_INT3_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("ISRC2DEC1", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_DEC0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2DEC2", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_DEC1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2DEC3", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_DEC2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC2DEC4", ARIZONA_ISRC_2_CTRL_3,
+                 ARIZONA_ISRC2_DEC3_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("ISRC3INT1", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_INT0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3INT2", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_INT1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3INT3", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_INT2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3INT4", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_INT3_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("ISRC3DEC1", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_DEC0_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3DEC2", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_DEC1_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3DEC3", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_DEC2_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ISRC3DEC4", ARIZONA_ISRC_3_CTRL_3,
+                 ARIZONA_ISRC3_DEC3_ENA_SHIFT, 0, NULL, 0),
+
 SND_SOC_DAPM_VALUE_MUX("AEC Loopback", ARIZONA_DAC_AEC_CONTROL_1,
                        ARIZONA_AEC_LOOPBACK_ENA_SHIFT, 0,
                        &wm5110_aec_loopback_mux),
@@ -577,11 +762,27 @@ SND_SOC_DAPM_AIF_OUT("AIF2TX1", NULL, 0,
                      ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX1_ENA_SHIFT, 0),
 SND_SOC_DAPM_AIF_OUT("AIF2TX2", NULL, 0,
                      ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX2_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2TX3", NULL, 0,
+                     ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX3_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2TX4", NULL, 0,
+                     ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX4_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2TX5", NULL, 0,
+                     ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX5_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2TX6", NULL, 0,
+                     ARIZONA_AIF2_TX_ENABLES, ARIZONA_AIF2TX6_ENA_SHIFT, 0),
 
 SND_SOC_DAPM_AIF_IN("AIF2RX1", NULL, 0,
                     ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX1_ENA_SHIFT, 0),
 SND_SOC_DAPM_AIF_IN("AIF2RX2", NULL, 0,
                     ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX2_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_IN("AIF2RX3", NULL, 0,
+                    ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX3_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_IN("AIF2RX4", NULL, 0,
+                    ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX4_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_IN("AIF2RX5", NULL, 0,
+                    ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX5_ENA_SHIFT, 0),
+SND_SOC_DAPM_AIF_IN("AIF2RX6", NULL, 0,
+                    ARIZONA_AIF2_RX_ENABLES, ARIZONA_AIF2RX6_ENA_SHIFT, 0),
 
 SND_SOC_DAPM_AIF_IN("SLIMRX1", NULL, 0,
                     ARIZONA_SLIMBUS_RX_CHANNEL_ENABLE,
@@ -719,6 +920,10 @@ ARIZONA_MIXER_WIDGETS(AIF1TX8, "AIF1TX8"),
 
 ARIZONA_MIXER_WIDGETS(AIF2TX1, "AIF2TX1"),
 ARIZONA_MIXER_WIDGETS(AIF2TX2, "AIF2TX2"),
+ARIZONA_MIXER_WIDGETS(AIF2TX3, "AIF2TX3"),
+ARIZONA_MIXER_WIDGETS(AIF2TX4, "AIF2TX4"),
+ARIZONA_MIXER_WIDGETS(AIF2TX5, "AIF2TX5"),
+ARIZONA_MIXER_WIDGETS(AIF2TX6, "AIF2TX6"),
 
 ARIZONA_MIXER_WIDGETS(AIF3TX1, "AIF3TX1"),
 ARIZONA_MIXER_WIDGETS(AIF3TX2, "AIF3TX2"),
@@ -737,6 +942,41 @@ ARIZONA_MUX_WIDGETS(ASRC1R, "ASRC1R"),
 ARIZONA_MUX_WIDGETS(ASRC2L, "ASRC2L"),
 ARIZONA_MUX_WIDGETS(ASRC2R, "ASRC2R"),
 
+ARIZONA_DSP_WIDGETS(DSP1, "DSP1"),
+ARIZONA_DSP_WIDGETS(DSP2, "DSP2"),
+ARIZONA_DSP_WIDGETS(DSP3, "DSP3"),
+ARIZONA_DSP_WIDGETS(DSP4, "DSP4"),
+
+ARIZONA_MUX_WIDGETS(ISRC1DEC1, "ISRC1DEC1"),
+ARIZONA_MUX_WIDGETS(ISRC1DEC2, "ISRC1DEC2"),
+ARIZONA_MUX_WIDGETS(ISRC1DEC3, "ISRC1DEC3"),
+ARIZONA_MUX_WIDGETS(ISRC1DEC4, "ISRC1DEC4"),
+
+ARIZONA_MUX_WIDGETS(ISRC1INT1, "ISRC1INT1"),
+ARIZONA_MUX_WIDGETS(ISRC1INT2, "ISRC1INT2"),
+ARIZONA_MUX_WIDGETS(ISRC1INT3, "ISRC1INT3"),
+ARIZONA_MUX_WIDGETS(ISRC1INT4, "ISRC1INT4"),
+
+ARIZONA_MUX_WIDGETS(ISRC2DEC1, "ISRC2DEC1"),
+ARIZONA_MUX_WIDGETS(ISRC2DEC2, "ISRC2DEC2"),
+ARIZONA_MUX_WIDGETS(ISRC2DEC3, "ISRC2DEC3"),
+ARIZONA_MUX_WIDGETS(ISRC2DEC4, "ISRC2DEC4"),
+
+ARIZONA_MUX_WIDGETS(ISRC2INT1, "ISRC2INT1"),
+ARIZONA_MUX_WIDGETS(ISRC2INT2, "ISRC2INT2"),
+ARIZONA_MUX_WIDGETS(ISRC2INT3, "ISRC2INT3"),
+ARIZONA_MUX_WIDGETS(ISRC2INT4, "ISRC2INT4"),
+
+ARIZONA_MUX_WIDGETS(ISRC3DEC1, "ISRC3DEC1"),
+ARIZONA_MUX_WIDGETS(ISRC3DEC2, "ISRC3DEC2"),
+ARIZONA_MUX_WIDGETS(ISRC3DEC3, "ISRC3DEC3"),
+ARIZONA_MUX_WIDGETS(ISRC3DEC4, "ISRC3DEC4"),
+
+ARIZONA_MUX_WIDGETS(ISRC3INT1, "ISRC3INT1"),
+ARIZONA_MUX_WIDGETS(ISRC3INT2, "ISRC3INT2"),
+ARIZONA_MUX_WIDGETS(ISRC3INT3, "ISRC3INT3"),
+ARIZONA_MUX_WIDGETS(ISRC3INT4, "ISRC3INT4"),
+
 SND_SOC_DAPM_OUTPUT("HPOUT1L"),
 SND_SOC_DAPM_OUTPUT("HPOUT1R"),
 SND_SOC_DAPM_OUTPUT("HPOUT2L"),
@@ -780,6 +1020,10 @@ SND_SOC_DAPM_OUTPUT("MICSUPP"),
         { name, "AIF1RX8", "AIF1RX8" }, \
         { name, "AIF2RX1", "AIF2RX1" }, \
         { name, "AIF2RX2", "AIF2RX2" }, \
+        { name, "AIF2RX3", "AIF2RX3" }, \
+        { name, "AIF2RX4", "AIF2RX4" }, \
+        { name, "AIF2RX5", "AIF2RX5" }, \
+        { name, "AIF2RX6", "AIF2RX6" }, \
         { name, "AIF3RX1", "AIF3RX1" }, \
         { name, "AIF3RX2", "AIF3RX2" }, \
         { name, "SLIMRX1", "SLIMRX1" }, \
@@ -805,7 +1049,55 @@ SND_SOC_DAPM_OUTPUT("MICSUPP"),
         { name, "ASRC1L", "ASRC1L" }, \
         { name, "ASRC1R", "ASRC1R" }, \
         { name, "ASRC2L", "ASRC2L" }, \
-        { name, "ASRC2R", "ASRC2R" }
+        { name, "ASRC2R", "ASRC2R" }, \
+        { name, "ISRC1DEC1", "ISRC1DEC1" }, \
+        { name, "ISRC1DEC2", "ISRC1DEC2" }, \
+        { name, "ISRC1DEC3", "ISRC1DEC3" }, \
+        { name, "ISRC1DEC4", "ISRC1DEC4" }, \
+        { name, "ISRC1INT1", "ISRC1INT1" }, \
+        { name, "ISRC1INT2", "ISRC1INT2" }, \
+        { name, "ISRC1INT3", "ISRC1INT3" }, \
+        { name, "ISRC1INT4", "ISRC1INT4" }, \
+        { name, "ISRC2DEC1", "ISRC2DEC1" }, \
+        { name, "ISRC2DEC2", "ISRC2DEC2" }, \
+        { name, "ISRC2DEC3", "ISRC2DEC3" }, \
+        { name, "ISRC2DEC4", "ISRC2DEC4" }, \
+        { name, "ISRC2INT1", "ISRC2INT1" }, \
+        { name, "ISRC2INT2", "ISRC2INT2" }, \
+        { name, "ISRC2INT3", "ISRC2INT3" }, \
+        { name, "ISRC2INT4", "ISRC2INT4" }, \
+        { name, "ISRC3DEC1", "ISRC3DEC1" }, \
+        { name, "ISRC3DEC2", "ISRC3DEC2" }, \
+        { name, "ISRC3DEC3", "ISRC3DEC3" }, \
+        { name, "ISRC3DEC4", "ISRC3DEC4" }, \
+        { name, "ISRC3INT1", "ISRC3INT1" }, \
+        { name, "ISRC3INT2", "ISRC3INT2" }, \
+        { name, "ISRC3INT3", "ISRC3INT3" }, \
+        { name, "ISRC3INT4", "ISRC3INT4" }, \
+        { name, "DSP1.1", "DSP1" }, \
+        { name, "DSP1.2", "DSP1" }, \
+        { name, "DSP1.3", "DSP1" }, \
+        { name, "DSP1.4", "DSP1" }, \
+        { name, "DSP1.5", "DSP1" }, \
+        { name, "DSP1.6", "DSP1" }, \
+        { name, "DSP2.1", "DSP2" }, \
+        { name, "DSP2.2", "DSP2" }, \
+        { name, "DSP2.3", "DSP2" }, \
+        { name, "DSP2.4", "DSP2" }, \
+        { name, "DSP2.5", "DSP2" }, \
+        { name, "DSP2.6", "DSP2" }, \
+        { name, "DSP3.1", "DSP3" }, \
+        { name, "DSP3.2", "DSP3" }, \
+        { name, "DSP3.3", "DSP3" }, \
+        { name, "DSP3.4", "DSP3" }, \
+        { name, "DSP3.5", "DSP3" }, \
+        { name, "DSP3.6", "DSP3" }, \
+        { name, "DSP4.1", "DSP4" }, \
+        { name, "DSP4.2", "DSP4" }, \
+        { name, "DSP4.3", "DSP4" }, \
+        { name, "DSP4.4", "DSP4" }, \
+        { name, "DSP4.5", "DSP4" }, \
+        { name, "DSP4.6", "DSP4" }
 
 static const struct snd_soc_dapm_route wm5110_dapm_routes[] = {
         { "AIF2 Capture", NULL, "DBVDD2" },
@@ -877,9 +1169,17 @@ static const struct snd_soc_dapm_route wm5110_dapm_routes[] = {
 
         { "AIF2 Capture", NULL, "AIF2TX1" },
         { "AIF2 Capture", NULL, "AIF2TX2" },
+        { "AIF2 Capture", NULL, "AIF2TX3" },
+        { "AIF2 Capture", NULL, "AIF2TX4" },
+        { "AIF2 Capture", NULL, "AIF2TX5" },
+        { "AIF2 Capture", NULL, "AIF2TX6" },
 
         { "AIF2RX1", NULL, "AIF2 Playback" },
         { "AIF2RX2", NULL, "AIF2 Playback" },
+        { "AIF2RX3", NULL, "AIF2 Playback" },
+        { "AIF2RX4", NULL, "AIF2 Playback" },
+        { "AIF2RX5", NULL, "AIF2 Playback" },
+        { "AIF2RX6", NULL, "AIF2 Playback" },
 
         { "AIF3 Capture", NULL, "AIF3TX1" },
         { "AIF3 Capture", NULL, "AIF3TX2" },
@@ -963,6 +1263,10 @@ static const struct snd_soc_dapm_route wm5110_dapm_routes[] = {
 
         ARIZONA_MIXER_ROUTES("AIF2TX1", "AIF2TX1"),
         ARIZONA_MIXER_ROUTES("AIF2TX2", "AIF2TX2"),
+        ARIZONA_MIXER_ROUTES("AIF2TX3", "AIF2TX3"),
+        ARIZONA_MIXER_ROUTES("AIF2TX4", "AIF2TX4"),
+        ARIZONA_MIXER_ROUTES("AIF2TX5", "AIF2TX5"),
+        ARIZONA_MIXER_ROUTES("AIF2TX6", "AIF2TX6"),
 
         ARIZONA_MIXER_ROUTES("AIF3TX1", "AIF3TX1"),
         ARIZONA_MIXER_ROUTES("AIF3TX2", "AIF3TX2"),
@@ -999,6 +1303,41 @@ static const struct snd_soc_dapm_route wm5110_dapm_routes[] = {
         ARIZONA_MUX_ROUTES("ASRC2L", "ASRC2L"),
         ARIZONA_MUX_ROUTES("ASRC2R", "ASRC2R"),
 
+        ARIZONA_DSP_ROUTES("DSP1"),
+        ARIZONA_DSP_ROUTES("DSP2"),
+        ARIZONA_DSP_ROUTES("DSP3"),
+        ARIZONA_DSP_ROUTES("DSP4"),
+
+        ARIZONA_MUX_ROUTES("ISRC1INT1", "ISRC1INT1"),
+        ARIZONA_MUX_ROUTES("ISRC1INT2", "ISRC1INT2"),
+        ARIZONA_MUX_ROUTES("ISRC1INT3", "ISRC1INT3"),
+        ARIZONA_MUX_ROUTES("ISRC1INT4", "ISRC1INT4"),
+
+        ARIZONA_MUX_ROUTES("ISRC1DEC1", "ISRC1DEC1"),
+        ARIZONA_MUX_ROUTES("ISRC1DEC2", "ISRC1DEC2"),
+        ARIZONA_MUX_ROUTES("ISRC1DEC3", "ISRC1DEC3"),
+        ARIZONA_MUX_ROUTES("ISRC1DEC4", "ISRC1DEC4"),
+
+        ARIZONA_MUX_ROUTES("ISRC2INT1", "ISRC2INT1"),
+        ARIZONA_MUX_ROUTES("ISRC2INT2", "ISRC2INT2"),
+        ARIZONA_MUX_ROUTES("ISRC2INT3", "ISRC2INT3"),
+        ARIZONA_MUX_ROUTES("ISRC2INT4", "ISRC2INT4"),
+
+        ARIZONA_MUX_ROUTES("ISRC2DEC1", "ISRC2DEC1"),
+        ARIZONA_MUX_ROUTES("ISRC2DEC2", "ISRC2DEC2"),
+        ARIZONA_MUX_ROUTES("ISRC2DEC3", "ISRC2DEC3"),
+        ARIZONA_MUX_ROUTES("ISRC2DEC4", "ISRC2DEC4"),
+
+        ARIZONA_MUX_ROUTES("ISRC3INT1", "ISRC3INT1"),
+        ARIZONA_MUX_ROUTES("ISRC3INT2", "ISRC3INT2"),
+        ARIZONA_MUX_ROUTES("ISRC3INT3", "ISRC3INT3"),
+        ARIZONA_MUX_ROUTES("ISRC3INT4", "ISRC3INT4"),
+
+        ARIZONA_MUX_ROUTES("ISRC3DEC1", "ISRC3DEC1"),
+        ARIZONA_MUX_ROUTES("ISRC3DEC2", "ISRC3DEC2"),
+        ARIZONA_MUX_ROUTES("ISRC3DEC3", "ISRC3DEC3"),
+        ARIZONA_MUX_ROUTES("ISRC3DEC4", "ISRC3DEC4"),
+
         { "AEC Loopback", "HPOUT1L", "OUT1L" },
         { "AEC Loopback", "HPOUT1R", "OUT1R" },
         { "HPOUT1L", NULL, "OUT1L" },
@@ -1095,14 +1434,14 @@ static struct snd_soc_dai_driver wm5110_dai[] = {
                 .playback = {
                         .stream_name = "AIF2 Playback",
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 6,
                         .rates = WM5110_RATES,
                         .formats = WM5110_FORMATS,
                 },
                 .capture = {
                          .stream_name = "AIF2 Capture",
                          .channels_min = 1,
-                         .channels_max = 2,
+                         .channels_max = 6,
                          .rates = WM5110_RATES,
                          .formats = WM5110_FORMATS,
                  },
@@ -1204,6 +1543,10 @@ static int wm5110_codec_probe(struct snd_soc_codec *codec)
         arizona_init_spk(codec);
         arizona_init_gpio(codec);
 
+        ret = snd_soc_add_codec_controls(codec, wm_adsp2_fw_controls, 8);
+        if (ret != 0)
+                return ret;
+
         snd_soc_dapm_disable_pin(&codec->dapm, "HAPTICS");
 
         priv->core.arizona->dapm = &codec->dapm;
@@ -1258,7 +1601,7 @@ static int wm5110_probe(struct platform_device *pdev)
 {
         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
         struct wm5110_priv *wm5110;
-        int i;
+        int i, ret;
 
         wm5110 = devm_kzalloc(&pdev->dev, sizeof(struct wm5110_priv),
                               GFP_KERNEL);
@@ -1269,6 +1612,24 @@ static int wm5110_probe(struct platform_device *pdev)
         wm5110->core.arizona = arizona;
         wm5110->core.num_inputs = 8;
 
+        for (i = 0; i < WM5110_NUM_ADSP; i++) {
+                wm5110->core.adsp[i].part = "wm5110";
+                wm5110->core.adsp[i].num = i + 1;
+                wm5110->core.adsp[i].type = WMFW_ADSP2;
+                wm5110->core.adsp[i].dev = arizona->dev;
+                wm5110->core.adsp[i].regmap = arizona->regmap;
+
+                wm5110->core.adsp[i].base = ARIZONA_DSP1_CONTROL_1
+                        + (0x100 * i);
+                wm5110->core.adsp[i].mem = wm5110_dsp_regions[i];
+                wm5110->core.adsp[i].num_mems
+                        = ARRAY_SIZE(wm5110_dsp1_regions);
+
+                ret = wm_adsp2_init(&wm5110->core.adsp[i], false);
+                if (ret != 0)
+                        return ret;
+        }
+
         for (i = 0; i < ARRAY_SIZE(wm5110->fll); i++)
                 wm5110->fll[i].vco_mult = 3;
 
@@ -1279,6 +1640,12 @@ static int wm5110_probe(struct platform_device *pdev)
                          ARIZONA_IRQ_FLL2_LOCK, ARIZONA_IRQ_FLL2_CLOCK_OK,
                          &wm5110->fll[1]);
 
+        /* SR2 fixed at 8kHz, SR3 fixed at 16kHz */
+        regmap_update_bits(arizona->regmap, ARIZONA_SAMPLE_RATE_2,
+                           ARIZONA_SAMPLE_RATE_2_MASK, 0x11);
+        regmap_update_bits(arizona->regmap, ARIZONA_SAMPLE_RATE_3,
+                           ARIZONA_SAMPLE_RATE_3_MASK, 0x12);
+
         for (i = 0; i < ARRAY_SIZE(wm5110_dai); i++)
                 arizona_init_dai(&wm5110->core, i);
 
diff --git a/sound/soc/codecs/wm8510.c b/sound/soc/codecs/wm8510.c
index 6ed5433943ea..7df7d4572755 100644
--- a/sound/soc/codecs/wm8510.c
+++ b/sound/soc/codecs/wm8510.c
@@ -684,7 +684,7 @@ static struct spi_driver wm8510_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8510_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -735,7 +735,7 @@ static struct i2c_driver wm8510_i2c_driver = {
 static int __init wm8510_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8510_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register WM8510 I2C driver: %d\n",
@@ -755,7 +755,7 @@ module_init(wm8510_modinit);
 
 static void __exit wm8510_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8510_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8523.c b/sound/soc/codecs/wm8523.c
index 139bf9ac9407..74d106dc7667 100644
--- a/sound/soc/codecs/wm8523.c
+++ b/sound/soc/codecs/wm8523.c
@@ -452,7 +452,7 @@ static const struct regmap_config wm8523_regmap = {
         .volatile_reg = wm8523_volatile_register,
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8523_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -555,7 +555,7 @@ static struct i2c_driver wm8523_i2c_driver = {
 static int __init wm8523_modinit(void)
 {
         int ret;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8523_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register WM8523 I2C driver: %d\n",
@@ -568,7 +568,7 @@ module_init(wm8523_modinit);
 
 static void __exit wm8523_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8523_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c
index 08a414b57b1e..318989acbbe5 100644
--- a/sound/soc/codecs/wm8580.c
+++ b/sound/soc/codecs/wm8580.c
@@ -941,7 +941,7 @@ static const struct regmap_config wm8580_regmap = {
         .volatile_reg = wm8580_volatile,
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8580_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -1003,7 +1003,7 @@ static int __init wm8580_modinit(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8580_i2c_driver);
         if (ret != 0) {
                 pr_err("Failed to register WM8580 I2C driver: %d\n", ret);
@@ -1016,7 +1016,7 @@ module_init(wm8580_modinit);
 
 static void __exit wm8580_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8580_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c
index 5b428b060d41..d99f948c513c 100644
--- a/sound/soc/codecs/wm8711.c
+++ b/sound/soc/codecs/wm8711.c
@@ -469,7 +469,7 @@ static struct spi_driver wm8711_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8711_i2c_probe(struct i2c_client *client,
                             const struct i2c_device_id *id)
 {
@@ -520,7 +520,7 @@ static struct i2c_driver wm8711_i2c_driver = {
 static int __init wm8711_modinit(void)
 {
         int ret;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8711_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register WM8711 I2C driver: %d\n",
@@ -540,7 +540,7 @@ module_init(wm8711_modinit);
 
 static void __exit wm8711_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8711_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8728.c b/sound/soc/codecs/wm8728.c
index c6a292dcded0..cd89033e84c0 100644
--- a/sound/soc/codecs/wm8728.c
+++ b/sound/soc/codecs/wm8728.c
@@ -320,7 +320,7 @@ static struct spi_driver wm8728_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8728_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -371,7 +371,7 @@ static struct i2c_driver wm8728_i2c_driver = {
 static int __init wm8728_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8728_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register wm8728 I2C driver: %d\n",
@@ -391,7 +391,7 @@ module_init(wm8728_modinit);
 
 static void __exit wm8728_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8728_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index bc7472c968e3..029720366ff8 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -732,7 +732,7 @@ static struct spi_driver wm8731_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8731_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -791,7 +791,7 @@ static struct i2c_driver wm8731_i2c_driver = {
 static int __init wm8731_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8731_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n",
@@ -811,7 +811,7 @@ module_init(wm8731_modinit);
 
 static void __exit wm8731_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8731_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8741.c b/sound/soc/codecs/wm8741.c
index b18813cc7ba9..2895c8d3b5e4 100644
--- a/sound/soc/codecs/wm8741.c
+++ b/sound/soc/codecs/wm8741.c
@@ -500,7 +500,7 @@ static const struct regmap_config wm8741_regmap = {
         .readable_reg = wm8741_readable,
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8741_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -617,7 +617,7 @@ static int __init wm8741_modinit(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8741_i2c_driver);
         if (ret != 0)
                 pr_err("Failed to register WM8741 I2C driver: %d\n", ret);
@@ -639,7 +639,7 @@ static void __exit wm8741_exit(void)
 #if defined(CONFIG_SPI_MASTER)
         spi_unregister_driver(&wm8741_spi_driver);
 #endif
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8741_i2c_driver);
 #endif
 }
diff --git a/sound/soc/codecs/wm8750.c b/sound/soc/codecs/wm8750.c
index 50d5ff616232..78616a638a55 100644
--- a/sound/soc/codecs/wm8750.c
+++ b/sound/soc/codecs/wm8750.c
@@ -816,7 +816,7 @@ static struct spi_driver wm8750_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8750_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -868,7 +868,7 @@ static struct i2c_driver wm8750_i2c_driver = {
 static int __init wm8750_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8750_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register wm8750 I2C driver: %d\n",
@@ -888,7 +888,7 @@ module_init(wm8750_modinit);
 
 static void __exit wm8750_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8750_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index d96ebf52d953..be85da93a268 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -1596,7 +1596,7 @@ static struct spi_driver wm8753_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8753_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -1653,7 +1653,7 @@ static struct i2c_driver wm8753_i2c_driver = {
 static int __init wm8753_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8753_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register wm8753 I2C driver: %d\n",
@@ -1673,7 +1673,7 @@ module_init(wm8753_modinit);
 
 static void __exit wm8753_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8753_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8776.c b/sound/soc/codecs/wm8776.c
index 942d58e455f3..ef8246725232 100644
--- a/sound/soc/codecs/wm8776.c
+++ b/sound/soc/codecs/wm8776.c
@@ -532,7 +532,7 @@ static struct spi_driver wm8776_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8776_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -584,7 +584,7 @@ static struct i2c_driver wm8776_i2c_driver = {
 static int __init wm8776_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8776_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register wm8776 I2C driver: %d\n",
@@ -604,7 +604,7 @@ module_init(wm8776_modinit);
 
 static void __exit wm8776_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8776_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8804.c b/sound/soc/codecs/wm8804.c
index 1704b1e119cb..9bc8206a6807 100644
--- a/sound/soc/codecs/wm8804.c
+++ b/sound/soc/codecs/wm8804.c
@@ -739,7 +739,7 @@ static struct spi_driver wm8804_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8804_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -791,7 +791,7 @@ static int __init wm8804_modinit(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8804_i2c_driver);
         if (ret) {
                 printk(KERN_ERR "Failed to register wm8804 I2C driver: %d\n",
@@ -811,7 +811,7 @@ module_init(wm8804_modinit);
 
 static void __exit wm8804_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8804_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index 734209e252c3..e98bc7038a08 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -1288,7 +1288,7 @@ static struct spi_driver wm8900_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8900_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -1338,7 +1338,7 @@ static struct i2c_driver wm8900_i2c_driver = {
 static int __init wm8900_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8900_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register wm8900 I2C driver: %d\n",
@@ -1358,7 +1358,7 @@ module_init(wm8900_modinit);
 
 static void __exit wm8900_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8900_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8940.c b/sound/soc/codecs/wm8940.c
index b1591c61c254..b404c26c1753 100644
--- a/sound/soc/codecs/wm8940.c
+++ b/sound/soc/codecs/wm8940.c
@@ -28,7 +28,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
-#include <linux/spi/spi.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -41,78 +41,116 @@
 
 struct wm8940_priv {
         unsigned int sysclk;
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
 };
 
-static int wm8940_volatile_register(struct snd_soc_codec *codec,
-                                    unsigned int reg)
+static bool wm8940_volatile_register(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case WM8940_SOFTRESET:
-                return 1;
+                return true;
         default:
-                return 0;
+                return false;
+        }
+}
+
+static bool wm8940_readable_register(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8940_SOFTRESET:
+        case WM8940_POWER1:
+        case WM8940_POWER2:
+        case WM8940_POWER3:
+        case WM8940_IFACE:
+        case WM8940_COMPANDINGCTL:
+        case WM8940_CLOCK:
+        case WM8940_ADDCNTRL:
+        case WM8940_GPIO:
+        case WM8940_CTLINT:
+        case WM8940_DAC:
+        case WM8940_DACVOL:
+        case WM8940_ADC:
+        case WM8940_ADCVOL:
+        case WM8940_NOTCH1:
+        case WM8940_NOTCH2:
+        case WM8940_NOTCH3:
+        case WM8940_NOTCH4:
+        case WM8940_NOTCH5:
+        case WM8940_NOTCH6:
+        case WM8940_NOTCH7:
+        case WM8940_NOTCH8:
+        case WM8940_DACLIM1:
+        case WM8940_DACLIM2:
+        case WM8940_ALC1:
+        case WM8940_ALC2:
+        case WM8940_ALC3:
+        case WM8940_NOISEGATE:
+        case WM8940_PLLN:
+        case WM8940_PLLK1:
+        case WM8940_PLLK2:
+        case WM8940_PLLK3:
+        case WM8940_ALC4:
+        case WM8940_INPUTCTL:
+        case WM8940_PGAGAIN:
+        case WM8940_ADCBOOST:
+        case WM8940_OUTPUTCTL:
+        case WM8940_SPKMIX:
+        case WM8940_SPKVOL:
+        case WM8940_MONOMIX:
+                return true;
+        default:
+                return false;
         }
 }
 
-static u16 wm8940_reg_defaults[] = {
-        0x8940, /* Soft Reset */
-        0x0000, /* Power 1 */
-        0x0000, /* Power 2 */
-        0x0000, /* Power 3 */
-        0x0010, /* Interface Control */
-        0x0000, /* Companding Control */
-        0x0140, /* Clock Control */
-        0x0000, /* Additional Controls */
-        0x0000, /* GPIO Control */
-        0x0002, /* Auto Increment Control */
-        0x0000, /* DAC Control */
-        0x00FF, /* DAC Volume */
-        0,
-        0,
-        0x0100, /* ADC Control */
-        0x00FF, /* ADC Volume */
-        0x0000, /* Notch Filter 1 Control 1 */
-        0x0000, /* Notch Filter 1 Control 2 */
-        0x0000, /* Notch Filter 2 Control 1 */
-        0x0000, /* Notch Filter 2 Control 2 */
-        0x0000, /* Notch Filter 3 Control 1 */
-        0x0000, /* Notch Filter 3 Control 2 */
-        0x0000, /* Notch Filter 4 Control 1 */
-        0x0000, /* Notch Filter 4 Control 2 */
-        0x0032, /* DAC Limit Control 1 */
-        0x0000, /* DAC Limit Control 2 */
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0x0038, /* ALC Control 1 */
-        0x000B, /* ALC Control 2 */
-        0x0032, /* ALC Control 3 */
-        0x0000, /* Noise Gate */
-        0x0041, /* PLLN */
-        0x000C, /* PLLK1 */
-        0x0093, /* PLLK2 */
-        0x00E9, /* PLLK3 */
-        0,
-        0,
-        0x0030, /* ALC Control 4 */
-        0,
-        0x0002, /* Input Control */
-        0x0050, /* PGA Gain */
-        0,
-        0x0002, /* ADC Boost Control */
-        0,
-        0x0002, /* Output Control */
-        0x0000, /* Speaker Mixer Control */
-        0,
-        0,
-        0,
-        0x0079, /* Speaker Volume */
-        0,
-        0x0000, /* Mono Mixer Control */
+static const struct reg_default wm8940_reg_defaults[] = {
+        {  0x1, 0x0000 }, /* Power 1 */
+        {  0x2, 0x0000 }, /* Power 2 */
+        {  0x3, 0x0000 }, /* Power 3 */
+        {  0x4, 0x0010 }, /* Interface Control */
+        {  0x5, 0x0000 }, /* Companding Control */
+        {  0x6, 0x0140 }, /* Clock Control */
+        {  0x7, 0x0000 }, /* Additional Controls */
+        {  0x8, 0x0000 }, /* GPIO Control */
+        {  0x9, 0x0002 }, /* Auto Increment Control */
+        {  0xa, 0x0000 }, /* DAC Control */
+        {  0xb, 0x00FF }, /* DAC Volume */
+
+        {  0xe, 0x0100 }, /* ADC Control */
+        {  0xf, 0x00FF }, /* ADC Volume */
+        { 0x10, 0x0000 }, /* Notch Filter 1 Control 1 */
+        { 0x11, 0x0000 }, /* Notch Filter 1 Control 2 */
+        { 0x12, 0x0000 }, /* Notch Filter 2 Control 1 */
+        { 0x13, 0x0000 }, /* Notch Filter 2 Control 2 */
+        { 0x14, 0x0000 }, /* Notch Filter 3 Control 1 */
+        { 0x15, 0x0000 }, /* Notch Filter 3 Control 2 */
+        { 0x16, 0x0000 }, /* Notch Filter 4 Control 1 */
+        { 0x17, 0x0000 }, /* Notch Filter 4 Control 2 */
+        { 0x18, 0x0032 }, /* DAC Limit Control 1 */
+        { 0x19, 0x0000 }, /* DAC Limit Control 2 */
+
+        { 0x20, 0x0038 }, /* ALC Control 1 */
+        { 0x21, 0x000B }, /* ALC Control 2 */
+        { 0x22, 0x0032 }, /* ALC Control 3 */
+        { 0x23, 0x0000 }, /* Noise Gate */
+        { 0x24, 0x0041 }, /* PLLN */
+        { 0x25, 0x000C }, /* PLLK1 */
+        { 0x26, 0x0093 }, /* PLLK2 */
+        { 0x27, 0x00E9 }, /* PLLK3 */
+
+        { 0x2a, 0x0030 }, /* ALC Control 4 */
+
+        { 0x2c, 0x0002 }, /* Input Control */
+        { 0x2d, 0x0050 }, /* PGA Gain */
+
+        { 0x2f, 0x0002 }, /* ADC Boost Control */
+
+        { 0x31, 0x0002 }, /* Output Control */
+        { 0x32, 0x0000 }, /* Speaker Mixer Control */
+
+        { 0x36, 0x0079 }, /* Speaker Volume */
+
+        { 0x38, 0x0000 }, /* Mono Mixer Control */
 };
 
 static const char *wm8940_companding[] = { "Off", "NC", "u-law", "A-law" };
@@ -264,7 +302,7 @@ static const struct snd_soc_dapm_widget wm8940_dapm_widgets[] = {
         SND_SOC_DAPM_INPUT("AUX"),
 };
 
-static const struct snd_soc_dapm_route audio_map[] = {
+static const struct snd_soc_dapm_route wm8940_dapm_routes[] = {
         /* Mono output mixer */
         {"Mono Mixer", "PCM Playback Switch", "DAC"},
         {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
@@ -296,21 +334,6 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"ADC", NULL, "Boost Mixer"},
 };
 
-static int wm8940_add_widgets(struct snd_soc_codec *codec)
-{
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-        int ret;
-
-        ret = snd_soc_dapm_new_controls(dapm, wm8940_dapm_widgets,
-                                        ARRAY_SIZE(wm8940_dapm_widgets));
-        if (ret)
-                goto error_ret;
-        ret = snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
-
-error_ret:
-        return ret;
-}
-
 #define wm8940_reset(c) snd_soc_write(c, WM8940_SOFTRESET, 0);
 
 static int wm8940_set_dai_fmt(struct snd_soc_dai *codec_dai,
@@ -446,6 +469,7 @@ static int wm8940_mute(struct snd_soc_dai *dai, int mute)
 static int wm8940_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8940_priv *wm8940 = snd_soc_codec_get_drvdata(codec);
         u16 val;
         u16 pwr_reg = snd_soc_read(codec, WM8940_POWER1) & 0x1F0;
         int ret = 0;
@@ -469,7 +493,7 @@ static int wm8940_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        ret = snd_soc_cache_sync(codec);
+                        ret = regcache_sync(wm8940->regmap);
                         if (ret < 0) {
                                 dev_err(codec->dev, "Failed to sync cache: %d\n", ret);
                                 return ret;
@@ -684,12 +708,11 @@ static int wm8940_resume(struct snd_soc_codec *codec)
 
 static int wm8940_probe(struct snd_soc_codec *codec)
 {
-        struct wm8940_priv *wm8940 = snd_soc_codec_get_drvdata(codec);
         struct wm8940_setup_data *pdata = codec->dev->platform_data;
         int ret;
         u16 reg;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, wm8940->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -716,11 +739,6 @@ static int wm8940_probe(struct snd_soc_codec *codec)
                         return ret;
         }
 
-        ret = snd_soc_add_codec_controls(codec, wm8940_snd_controls,
-                             ARRAY_SIZE(wm8940_snd_controls));
-        if (ret)
-                return ret;
-        ret = wm8940_add_widgets(codec);
         return ret;
 }
 
@@ -736,10 +754,24 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8940 = {
         .suspend =      wm8940_suspend,
         .resume =       wm8940_resume,
         .set_bias_level = wm8940_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8940_reg_defaults),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8940_reg_defaults,
-        .volatile_register = wm8940_volatile_register,
+        .controls =     wm8940_snd_controls,
+        .num_controls = ARRAY_SIZE(wm8940_snd_controls),
+        .dapm_widgets = wm8940_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(wm8940_dapm_widgets),
+        .dapm_routes =  wm8940_dapm_routes,
+        .num_dapm_routes = ARRAY_SIZE(wm8940_dapm_routes),
+};
+
+static const struct regmap_config wm8940_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+
+        .max_register = WM8940_MONOMIX,
+        .reg_defaults = wm8940_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8940_reg_defaults),
+
+        .readable_reg = wm8940_readable_register,
+        .volatile_reg = wm8940_volatile_register,
 };
 
 static int wm8940_i2c_probe(struct i2c_client *i2c,
@@ -753,8 +785,11 @@ static int wm8940_i2c_probe(struct i2c_client *i2c,
         if (wm8940 == NULL)
                 return -ENOMEM;
 
+        wm8940->regmap = devm_regmap_init_i2c(i2c, &wm8940_regmap);
+        if (IS_ERR(wm8940->regmap))
+                return PTR_ERR(wm8940->regmap);
+
         i2c_set_clientdata(i2c, wm8940);
-        wm8940->control_type = SND_SOC_I2C;
 
         ret = snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8940, &wm8940_dai, 1);
diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index 0f17ed3e29f4..97db3b45b411 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -74,7 +74,7 @@ struct wm8962_priv {
         struct regulator_bulk_data supplies[WM8962_NUM_SUPPLIES];
         struct notifier_block disable_nb[WM8962_NUM_SUPPLIES];
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         struct input_dev *beep;
         struct work_struct beep_work;
         int beep_rate;
@@ -3121,7 +3121,7 @@ int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
 }
 EXPORT_SYMBOL_GPL(wm8962_mic_detect);
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int beep_rates[] = {
         500, 1000, 2000, 4000,
 };
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
index a2d01d10a5dd..15f45c7bd833 100644
--- a/sound/soc/codecs/wm8974.c
+++ b/sound/soc/codecs/wm8974.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -27,22 +28,22 @@
 
 #include "wm8974.h"
 
-static const u16 wm8974_reg[WM8974_CACHEREGNUM] = {
-        0x0000, 0x0000, 0x0000, 0x0000,
-        0x0050, 0x0000, 0x0140, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x00ff,
-        0x0000, 0x0000, 0x0100, 0x00ff,
-        0x0000, 0x0000, 0x012c, 0x002c,
-        0x002c, 0x002c, 0x002c, 0x0000,
-        0x0032, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000,
-        0x0038, 0x000b, 0x0032, 0x0000,
-        0x0008, 0x000c, 0x0093, 0x00e9,
-        0x0000, 0x0000, 0x0000, 0x0000,
-        0x0003, 0x0010, 0x0000, 0x0000,
-        0x0000, 0x0002, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0039, 0x0000,
-        0x0000,
+static const struct reg_default wm8974_reg_defaults[] = {
+        {  0, 0x0000 }, {  1, 0x0000 }, {  2, 0x0000 }, {  3, 0x0000 },
+        {  4, 0x0050 }, {  5, 0x0000 }, {  6, 0x0140 }, {  7, 0x0000 },
+        {  8, 0x0000 }, {  9, 0x0000 }, { 10, 0x0000 }, { 11, 0x00ff },
+        { 12, 0x0000 }, { 13, 0x0000 }, { 14, 0x0100 }, { 15, 0x00ff },
+        { 16, 0x0000 }, { 17, 0x0000 }, { 18, 0x012c }, { 19, 0x002c },
+        { 20, 0x002c }, { 21, 0x002c }, { 22, 0x002c }, { 23, 0x0000 },
+        { 24, 0x0032 }, { 25, 0x0000 }, { 26, 0x0000 }, { 27, 0x0000 },
+        { 28, 0x0000 }, { 29, 0x0000 }, { 30, 0x0000 }, { 31, 0x0000 },
+        { 32, 0x0038 }, { 33, 0x000b }, { 34, 0x0032 }, { 35, 0x0000 },
+        { 36, 0x0008 }, { 37, 0x000c }, { 38, 0x0093 }, { 39, 0x00e9 },
+        { 40, 0x0000 }, { 41, 0x0000 }, { 42, 0x0000 }, { 43, 0x0000 },
+        { 44, 0x0003 }, { 45, 0x0010 }, { 46, 0x0000 }, { 47, 0x0000 },
+        { 48, 0x0000 }, { 49, 0x0002 }, { 50, 0x0000 }, { 51, 0x0000 },
+        { 52, 0x0000 }, { 53, 0x0000 }, { 54, 0x0039 }, { 55, 0x0000 },
+        { 56, 0x0000 },
 };
 
 #define WM8974_POWER1_BIASEN  0x08
@@ -514,7 +515,7 @@ static int wm8974_set_bias_level(struct snd_soc_codec *codec,
                 power1 |= WM8974_POWER1_BIASEN | WM8974_POWER1_BUFIOEN;
 
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(dev_get_regmap(codec->dev, NULL));
 
                         /* Initial cap charge at VMID 5k */
                         snd_soc_write(codec, WM8974_POWER1, power1 | 0x3);
@@ -579,11 +580,20 @@ static int wm8974_resume(struct snd_soc_codec *codec)
         return 0;
 }
 
+static const struct regmap_config wm8974_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+
+        .max_register = WM8974_MONOMIX,
+        .reg_defaults = wm8974_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8974_reg_defaults),
+};
+
 static int wm8974_probe(struct snd_soc_codec *codec)
 {
         int ret = 0;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_I2C);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -613,9 +623,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8974 = {
         .suspend =      wm8974_suspend,
         .resume =       wm8974_resume,
         .set_bias_level = wm8974_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8974_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8974_reg,
 
         .controls = wm8974_snd_controls,
         .num_controls = ARRAY_SIZE(wm8974_snd_controls),
@@ -628,8 +635,13 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8974 = {
 static int wm8974_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
+        struct regmap *regmap;
         int ret;
 
+        regmap = devm_regmap_init_i2c(i2c, &wm8974_regmap);
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+
         ret = snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8974, &wm8974_dai, 1);
 
diff --git a/sound/soc/codecs/wm8985.c b/sound/soc/codecs/wm8985.c
index 18f2babe1090..271b517911a4 100644
--- a/sound/soc/codecs/wm8985.c
+++ b/sound/soc/codecs/wm8985.c
@@ -1148,7 +1148,7 @@ static struct spi_driver wm8985_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8985_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -1201,7 +1201,7 @@ static int __init wm8985_modinit(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8985_i2c_driver);
         if (ret) {
                 printk(KERN_ERR "Failed to register wm8985 I2C driver: %d\n",
@@ -1221,7 +1221,7 @@ module_init(wm8985_modinit);
 
 static void __exit wm8985_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8985_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c
index 39b9acceb595..a55e1c2c382e 100644
--- a/sound/soc/codecs/wm8988.c
+++ b/sound/soc/codecs/wm8988.c
@@ -912,7 +912,7 @@ static struct spi_driver wm8988_spi_driver = {
 };
 #endif /* CONFIG_SPI_MASTER */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8988_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -964,7 +964,7 @@ static struct i2c_driver wm8988_i2c_driver = {
 static int __init wm8988_modinit(void)
 {
         int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8988_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register WM8988 I2C driver: %d\n",
@@ -984,7 +984,7 @@ module_init(wm8988_modinit);
 
 static void __exit wm8988_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8988_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index 4f05fb88bddf..0ccd4d8d043b 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -30,13 +31,12 @@
 
 /* codec private data */
 struct wm8990_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         unsigned int sysclk;
         unsigned int pcmclk;
 };
 
-static int wm8990_volatile_register(struct snd_soc_codec *codec,
-                                    unsigned int reg)
+static bool wm8990_volatile_register(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case WM8990_RESET:
@@ -46,71 +46,69 @@ static int wm8990_volatile_register(struct snd_soc_codec *codec,
         }
 }
 
-static const u16 wm8990_reg[] = {
-        0x8990,     /* R0  - Reset */
-        0x0000,     /* R1  - Power Management (1) */
-        0x6000,     /* R2  - Power Management (2) */
-        0x0000,     /* R3  - Power Management (3) */
-        0x4050,     /* R4  - Audio Interface (1) */
-        0x4000,     /* R5  - Audio Interface (2) */
-        0x01C8,     /* R6  - Clocking (1) */
-        0x0000,     /* R7  - Clocking (2) */
-        0x0040,     /* R8  - Audio Interface (3) */
-        0x0040,     /* R9  - Audio Interface (4) */
-        0x0004,     /* R10 - DAC CTRL */
-        0x00C0,     /* R11 - Left DAC Digital Volume */
-        0x00C0,     /* R12 - Right DAC Digital Volume */
-        0x0000,     /* R13 - Digital Side Tone */
-        0x0100,     /* R14 - ADC CTRL */
-        0x00C0,     /* R15 - Left ADC Digital Volume */
-        0x00C0,     /* R16 - Right ADC Digital Volume */
-        0x0000,     /* R17 */
-        0x0000,     /* R18 - GPIO CTRL 1 */
-        0x1000,     /* R19 - GPIO1 & GPIO2 */
-        0x1010,     /* R20 - GPIO3 & GPIO4 */
-        0x1010,     /* R21 - GPIO5 & GPIO6 */
-        0x8000,     /* R22 - GPIOCTRL 2 */
-        0x0800,     /* R23 - GPIO_POL */
-        0x008B,     /* R24 - Left Line Input 1&2 Volume */
-        0x008B,     /* R25 - Left Line Input 3&4 Volume */
-        0x008B,     /* R26 - Right Line Input 1&2 Volume */
-        0x008B,     /* R27 - Right Line Input 3&4 Volume */
-        0x0000,     /* R28 - Left Output Volume */
-        0x0000,     /* R29 - Right Output Volume */
-        0x0066,     /* R30 - Line Outputs Volume */
-        0x0022,     /* R31 - Out3/4 Volume */
-        0x0079,     /* R32 - Left OPGA Volume */
-        0x0079,     /* R33 - Right OPGA Volume */
-        0x0003,     /* R34 - Speaker Volume */
-        0x0003,     /* R35 - ClassD1 */
-        0x0000,     /* R36 */
-        0x0100,     /* R37 - ClassD3 */
-        0x0079,     /* R38 - ClassD4 */
-        0x0000,     /* R39 - Input Mixer1 */
-        0x0000,     /* R40 - Input Mixer2 */
-        0x0000,     /* R41 - Input Mixer3 */
-        0x0000,     /* R42 - Input Mixer4 */
-        0x0000,     /* R43 - Input Mixer5 */
-        0x0000,     /* R44 - Input Mixer6 */
-        0x0000,     /* R45 - Output Mixer1 */
-        0x0000,     /* R46 - Output Mixer2 */
-        0x0000,     /* R47 - Output Mixer3 */
-        0x0000,     /* R48 - Output Mixer4 */
-        0x0000,     /* R49 - Output Mixer5 */
-        0x0000,     /* R50 - Output Mixer6 */
-        0x0180,     /* R51 - Out3/4 Mixer */
-        0x0000,     /* R52 - Line Mixer1 */
-        0x0000,     /* R53 - Line Mixer2 */
-        0x0000,     /* R54 - Speaker Mixer */
-        0x0000,     /* R55 - Additional Control */
-        0x0000,     /* R56 - AntiPOP1 */
-        0x0000,     /* R57 - AntiPOP2 */
-        0x0000,     /* R58 - MICBIAS */
-        0x0000,     /* R59 */
-        0x0008,     /* R60 - PLL1 */
-        0x0031,     /* R61 - PLL2 */
-        0x0026,     /* R62 - PLL3 */
-        0x0000,     /* R63 - Driver internal */
+static const struct reg_default wm8990_reg_defaults[] = {
+        {  1, 0x0000 },     /* R1  - Power Management (1) */
+        {  2, 0x6000 },     /* R2  - Power Management (2) */
+        {  3, 0x0000 },     /* R3  - Power Management (3) */
+        {  4, 0x4050 },     /* R4  - Audio Interface (1) */
+        {  5, 0x4000 },     /* R5  - Audio Interface (2) */
+        {  6, 0x01C8 },     /* R6  - Clocking (1) */
+        {  7, 0x0000 },     /* R7  - Clocking (2) */
+        {  8, 0x0040 },     /* R8  - Audio Interface (3) */
+        {  9, 0x0040 },     /* R9  - Audio Interface (4) */
+        { 10, 0x0004 },     /* R10 - DAC CTRL */
+        { 11, 0x00C0 },     /* R11 - Left DAC Digital Volume */
+        { 12, 0x00C0 },     /* R12 - Right DAC Digital Volume */
+        { 13, 0x0000 },     /* R13 - Digital Side Tone */
+        { 14, 0x0100 },     /* R14 - ADC CTRL */
+        { 15, 0x00C0 },     /* R15 - Left ADC Digital Volume */
+        { 16, 0x00C0 },     /* R16 - Right ADC Digital Volume */
+
+        { 18, 0x0000 },     /* R18 - GPIO CTRL 1 */
+        { 19, 0x1000 },     /* R19 - GPIO1 & GPIO2 */
+        { 20, 0x1010 },     /* R20 - GPIO3 & GPIO4 */
+        { 21, 0x1010 },     /* R21 - GPIO5 & GPIO6 */
+        { 22, 0x8000 },     /* R22 - GPIOCTRL 2 */
+        { 23, 0x0800 },     /* R23 - GPIO_POL */
+        { 24, 0x008B },     /* R24 - Left Line Input 1&2 Volume */
+        { 25, 0x008B },     /* R25 - Left Line Input 3&4 Volume */
+        { 26, 0x008B },     /* R26 - Right Line Input 1&2 Volume */
+        { 27, 0x008B },     /* R27 - Right Line Input 3&4 Volume */
+        { 28, 0x0000 },     /* R28 - Left Output Volume */
+        { 29, 0x0000 },     /* R29 - Right Output Volume */
+        { 30, 0x0066 },     /* R30 - Line Outputs Volume */
+        { 31, 0x0022 },     /* R31 - Out3/4 Volume */
+        { 32, 0x0079 },     /* R32 - Left OPGA Volume */
+        { 33, 0x0079 },     /* R33 - Right OPGA Volume */
+        { 34, 0x0003 },     /* R34 - Speaker Volume */
+        { 35, 0x0003 },     /* R35 - ClassD1 */
+
+        { 37, 0x0100 },     /* R37 - ClassD3 */
+        { 38, 0x0079 },     /* R38 - ClassD4 */
+        { 39, 0x0000 },     /* R39 - Input Mixer1 */
+        { 40, 0x0000 },     /* R40 - Input Mixer2 */
+        { 41, 0x0000 },     /* R41 - Input Mixer3 */
+        { 42, 0x0000 },     /* R42 - Input Mixer4 */
+        { 43, 0x0000 },     /* R43 - Input Mixer5 */
+        { 44, 0x0000 },     /* R44 - Input Mixer6 */
+        { 45, 0x0000 },     /* R45 - Output Mixer1 */
+        { 46, 0x0000 },     /* R46 - Output Mixer2 */
+        { 47, 0x0000 },     /* R47 - Output Mixer3 */
+        { 48, 0x0000 },     /* R48 - Output Mixer4 */
+        { 49, 0x0000 },     /* R49 - Output Mixer5 */
+        { 50, 0x0000 },     /* R50 - Output Mixer6 */
+        { 51, 0x0180 },     /* R51 - Out3/4 Mixer */
+        { 52, 0x0000 },     /* R52 - Line Mixer1 */
+        { 53, 0x0000 },     /* R53 - Line Mixer2 */
+        { 54, 0x0000 },     /* R54 - Speaker Mixer */
+        { 55, 0x0000 },     /* R55 - Additional Control */
+        { 56, 0x0000 },     /* R56 - AntiPOP1 */
+        { 57, 0x0000 },     /* R57 - AntiPOP2 */
+        { 58, 0x0000 },     /* R58 - MICBIAS */
+
+        { 60, 0x0008 },     /* R60 - PLL1 */
+        { 61, 0x0031 },     /* R61 - PLL2 */
+        { 62, 0x0026 },     /* R62 - PLL3 */
 };
 
 #define wm8990_reset(c) snd_soc_write(c, WM8990_RESET, 0)
@@ -376,32 +374,6 @@ SOC_SINGLE("RIN34 Mute Switch", WM8990_RIGHT_LINE_INPUT_3_4_VOLUME,
  * _DAPM_ Controls
  */
 
-static int inmixer_event(struct snd_soc_dapm_widget *w,
-        struct snd_kcontrol *kcontrol, int event)
-{
-        u16 reg, fakepower;
-
-        reg = snd_soc_read(w->codec, WM8990_POWER_MANAGEMENT_2);
-        fakepower = snd_soc_read(w->codec, WM8990_INTDRIVBITS);
-
-        if (fakepower & ((1 << WM8990_INMIXL_PWR_BIT) |
-                (1 << WM8990_AINLMUX_PWR_BIT))) {
-                reg |= WM8990_AINL_ENA;
-        } else {
-                reg &= ~WM8990_AINL_ENA;
-        }
-
-        if (fakepower & ((1 << WM8990_INMIXR_PWR_BIT) |
-                (1 << WM8990_AINRMUX_PWR_BIT))) {
-                reg |= WM8990_AINR_ENA;
-        } else {
-                reg &= ~WM8990_AINR_ENA;
-        }
-        snd_soc_write(w->codec, WM8990_POWER_MANAGEMENT_2, reg);
-
-        return 0;
-}
-
 static int outmixer_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
@@ -656,6 +628,11 @@ SND_SOC_DAPM_INPUT("RIN1"),
 SND_SOC_DAPM_INPUT("RIN2"),
 SND_SOC_DAPM_INPUT("Internal ADC Source"),
 
+SND_SOC_DAPM_SUPPLY("INL", WM8990_POWER_MANAGEMENT_2, WM8990_AINL_ENA_BIT, 0,
+                    NULL, 0),
+SND_SOC_DAPM_SUPPLY("INR", WM8990_POWER_MANAGEMENT_2, WM8990_AINR_ENA_BIT, 0,
+                    NULL, 0),
+
 /* DACs */
 SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8990_POWER_MANAGEMENT_2,
         WM8990_ADCL_ENA_BIT, 0),
@@ -677,26 +654,20 @@ SND_SOC_DAPM_MIXER("RIN34 PGA", WM8990_POWER_MANAGEMENT_2, WM8990_RIN34_ENA_BIT,
         ARRAY_SIZE(wm8990_dapm_rin34_pga_controls)),
 
 /* INMIXL */
-SND_SOC_DAPM_MIXER_E("INMIXL", WM8990_INTDRIVBITS, WM8990_INMIXL_PWR_BIT, 0,
+SND_SOC_DAPM_MIXER("INMIXL", SND_SOC_NOPM, 0, 0,
         &wm8990_dapm_inmixl_controls[0],
-        ARRAY_SIZE(wm8990_dapm_inmixl_controls),
-        inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        ARRAY_SIZE(wm8990_dapm_inmixl_controls)),
 
 /* AINLMUX */
-SND_SOC_DAPM_MUX_E("AINLMUX", WM8990_INTDRIVBITS, WM8990_AINLMUX_PWR_BIT, 0,
-        &wm8990_dapm_ainlmux_controls, inmixer_event,
-        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_MUX("AINLMUX", SND_SOC_NOPM, 0, 0, &wm8990_dapm_ainlmux_controls),
 
 /* INMIXR */
-SND_SOC_DAPM_MIXER_E("INMIXR", WM8990_INTDRIVBITS, WM8990_INMIXR_PWR_BIT, 0,
+SND_SOC_DAPM_MIXER("INMIXR", SND_SOC_NOPM, 0, 0,
         &wm8990_dapm_inmixr_controls[0],
-        ARRAY_SIZE(wm8990_dapm_inmixr_controls),
-        inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        ARRAY_SIZE(wm8990_dapm_inmixr_controls)),
 
 /* AINRMUX */
-SND_SOC_DAPM_MUX_E("AINRMUX", WM8990_INTDRIVBITS, WM8990_AINRMUX_PWR_BIT, 0,
-        &wm8990_dapm_ainrmux_controls, inmixer_event,
-        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_MUX("AINRMUX", SND_SOC_NOPM, 0, 0, &wm8990_dapm_ainrmux_controls),
 
 /* Output Side */
 /* DACs */
@@ -787,7 +758,7 @@ SND_SOC_DAPM_OUTPUT("RON"),
 SND_SOC_DAPM_OUTPUT("Internal DAC Sink"),
 };
 
-static const struct snd_soc_dapm_route audio_map[] = {
+static const struct snd_soc_dapm_route wm8990_dapm_routes[] = {
         /* Make DACs turn on when playing even if not mixed into any outputs */
         {"Internal DAC Sink", NULL, "Left DAC"},
         {"Internal DAC Sink", NULL, "Right DAC"},
@@ -796,6 +767,11 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Left ADC", NULL, "Internal ADC Source"},
         {"Right ADC", NULL, "Internal ADC Source"},
 
+        {"AINLMUX", NULL, "INL"},
+        {"INMIXL", NULL, "INL"},
+        {"AINRMUX", NULL, "INR"},
+        {"INMIXR", NULL, "INR"},
+
         /* Input Side */
         /* LIN12 PGA */
         {"LIN12 PGA", "LIN1 Switch", "LIN1"},
@@ -912,18 +888,6 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"RON", NULL, "RONMIX"},
 };
 
-static int wm8990_add_widgets(struct snd_soc_codec *codec)
-{
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        snd_soc_dapm_new_controls(dapm, wm8990_dapm_widgets,
-                                  ARRAY_SIZE(wm8990_dapm_widgets));
-        /* set up the WM8990 audio map */
-        snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
-
-        return 0;
-}
-
 /* PLL divisors */
 struct _pll_div {
         u32 div2;
@@ -1148,6 +1112,7 @@ static int wm8990_mute(struct snd_soc_dai *dai, int mute)
 static int wm8990_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
+        struct wm8990_priv *wm8990 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
         switch (level) {
@@ -1162,7 +1127,7 @@ static int wm8990_set_bias_level(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        ret = snd_soc_cache_sync(codec);
+                        ret = regcache_sync(wm8990->regmap);
                         if (ret < 0) {
                                 dev_err(codec->dev, "Failed to sync cache: %d\n", ret);
                                 return ret;
@@ -1260,7 +1225,7 @@ static int wm8990_set_bias_level(struct snd_soc_codec *codec,
                 /* disable POBCTRL, SOFT_ST and BUFDCOPEN */
                 snd_soc_write(codec, WM8990_ANTIPOP2, 0x0);
 
-                codec->cache_sync = 1;
+                regcache_mark_dirty(wm8990->regmap);
                 break;
         }
 
@@ -1329,7 +1294,7 @@ static int wm8990_probe(struct snd_soc_codec *codec)
 {
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret < 0) {
                 printk(KERN_ERR "wm8990: failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -1352,10 +1317,6 @@ static int wm8990_probe(struct snd_soc_codec *codec)
         snd_soc_write(codec, WM8990_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8));
         snd_soc_write(codec, WM8990_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));
 
-        snd_soc_add_codec_controls(codec, wm8990_snd_controls,
-                                ARRAY_SIZE(wm8990_snd_controls));
-        wm8990_add_widgets(codec);
-
         return 0;
 }
 
@@ -1372,13 +1333,25 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8990 = {
         .suspend =      wm8990_suspend,
         .resume =       wm8990_resume,
         .set_bias_level = wm8990_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8990_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8990_reg,
-        .volatile_register = wm8990_volatile_register,
+        .controls =     wm8990_snd_controls,
+        .num_controls = ARRAY_SIZE(wm8990_snd_controls),
+        .dapm_widgets = wm8990_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(wm8990_dapm_widgets),
+        .dapm_routes =  wm8990_dapm_routes,
+        .num_dapm_routes = ARRAY_SIZE(wm8990_dapm_routes),
+};
+
+static const struct regmap_config wm8990_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+
+        .max_register = WM8990_PLL3,
+        .volatile_reg = wm8990_volatile_register,
+        .reg_defaults = wm8990_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8990_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static int wm8990_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -1420,29 +1393,8 @@ static struct i2c_driver wm8990_i2c_driver = {
         .remove =   wm8990_i2c_remove,
         .id_table = wm8990_i2c_id,
 };
-#endif
 
-static int __init wm8990_modinit(void)
-{
-        int ret = 0;
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        ret = i2c_add_driver(&wm8990_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register wm8990 I2C driver: %d\n",
-                       ret);
-        }
-#endif
-        return ret;
-}
-module_init(wm8990_modinit);
-
-static void __exit wm8990_exit(void)
-{
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        i2c_del_driver(&wm8990_i2c_driver);
-#endif
-}
-module_exit(wm8990_exit);
+module_i2c_driver(wm8990_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8990 driver");
 MODULE_AUTHOR("Liam Girdwood");
diff --git a/sound/soc/codecs/wm8990.h b/sound/soc/codecs/wm8990.h
index 77c98a4bfe9c..0e9c78040c4c 100644
--- a/sound/soc/codecs/wm8990.h
+++ b/sound/soc/codecs/wm8990.h
@@ -78,7 +78,6 @@
 #define WM8990_PLL1                             0x3C
 #define WM8990_PLL2                             0x3D
 #define WM8990_PLL3                             0x3E
-#define WM8990_INTDRIVBITS                      0x3F
 
 #define WM8990_EXT_ACCESS_ENA                   0x75
 #define WM8990_EXT_CTL1                         0x7a
@@ -818,14 +817,6 @@
  */
 #define WM8990_PLLK2_MASK                       0x00FF  /* PLLK2 - [7:0] */
 
-/*
- * R63 (0x3F) - Internal Driver Bits
- */
-#define WM8990_INMIXL_PWR_BIT                   0
-#define WM8990_AINLMUX_PWR_BIT                  1
-#define WM8990_INMIXR_PWR_BIT                   2
-#define WM8990_AINRMUX_PWR_BIT                  3
-
 #define WM8990_MCLK_DIV 0
 #define WM8990_DACCLK_DIV 1
 #define WM8990_ADCCLK_DIV 2
diff --git a/sound/soc/codecs/wm8991.c b/sound/soc/codecs/wm8991.c
index 3a39df7a3829..dba0306c42a5 100644
--- a/sound/soc/codecs/wm8991.c
+++ b/sound/soc/codecs/wm8991.c
@@ -18,6 +18,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -31,77 +32,84 @@
 #include "wm8991.h"
 
 struct wm8991_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         unsigned int pcmclk;
 };
 
-static const u16 wm8991_reg_defs[] = {
-        0x8991,     /* R0  - Reset */
-        0x0000,     /* R1  - Power Management (1) */
-        0x6000,     /* R2  - Power Management (2) */
-        0x0000,     /* R3  - Power Management (3) */
-        0x4050,     /* R4  - Audio Interface (1) */
-        0x4000,     /* R5  - Audio Interface (2) */
-        0x01C8,     /* R6  - Clocking (1) */
-        0x0000,     /* R7  - Clocking (2) */
-        0x0040,     /* R8  - Audio Interface (3) */
-        0x0040,     /* R9  - Audio Interface (4) */
-        0x0004,     /* R10 - DAC CTRL */
-        0x00C0,     /* R11 - Left DAC Digital Volume */
-        0x00C0,     /* R12 - Right DAC Digital Volume */
-        0x0000,     /* R13 - Digital Side Tone */
-        0x0100,     /* R14 - ADC CTRL */
-        0x00C0,     /* R15 - Left ADC Digital Volume */
-        0x00C0,     /* R16 - Right ADC Digital Volume */
-        0x0000,     /* R17 */
-        0x0000,     /* R18 - GPIO CTRL 1 */
-        0x1000,     /* R19 - GPIO1 & GPIO2 */
-        0x1010,     /* R20 - GPIO3 & GPIO4 */
-        0x1010,     /* R21 - GPIO5 & GPIO6 */
-        0x8000,     /* R22 - GPIOCTRL 2 */
-        0x0800,     /* R23 - GPIO_POL */
-        0x008B,     /* R24 - Left Line Input 1&2 Volume */
-        0x008B,     /* R25 - Left Line Input 3&4 Volume */
-        0x008B,     /* R26 - Right Line Input 1&2 Volume */
-        0x008B,     /* R27 - Right Line Input 3&4 Volume */
-        0x0000,     /* R28 - Left Output Volume */
-        0x0000,     /* R29 - Right Output Volume */
-        0x0066,     /* R30 - Line Outputs Volume */
-        0x0022,     /* R31 - Out3/4 Volume */
-        0x0079,     /* R32 - Left OPGA Volume */
-        0x0079,     /* R33 - Right OPGA Volume */
-        0x0003,     /* R34 - Speaker Volume */
-        0x0003,     /* R35 - ClassD1 */
-        0x0000,     /* R36 */
-        0x0100,     /* R37 - ClassD3 */
-        0x0000,     /* R38 */
-        0x0000,     /* R39 - Input Mixer1 */
-        0x0000,     /* R40 - Input Mixer2 */
-        0x0000,     /* R41 - Input Mixer3 */
-        0x0000,     /* R42 - Input Mixer4 */
-        0x0000,     /* R43 - Input Mixer5 */
-        0x0000,     /* R44 - Input Mixer6 */
-        0x0000,     /* R45 - Output Mixer1 */
-        0x0000,     /* R46 - Output Mixer2 */
-        0x0000,     /* R47 - Output Mixer3 */
-        0x0000,     /* R48 - Output Mixer4 */
-        0x0000,     /* R49 - Output Mixer5 */
-        0x0000,     /* R50 - Output Mixer6 */
-        0x0180,     /* R51 - Out3/4 Mixer */
-        0x0000,     /* R52 - Line Mixer1 */
-        0x0000,     /* R53 - Line Mixer2 */
-        0x0000,     /* R54 - Speaker Mixer */
-        0x0000,     /* R55 - Additional Control */
-        0x0000,     /* R56 - AntiPOP1 */
-        0x0000,     /* R57 - AntiPOP2 */
-        0x0000,     /* R58 - MICBIAS */
-        0x0000,     /* R59 */
-        0x0008,     /* R60 - PLL1 */
-        0x0031,     /* R61 - PLL2 */
-        0x0026,     /* R62 - PLL3 */
+static const struct reg_default wm8991_reg_defaults[] = {
+        {  1, 0x0000 },     /* R1  - Power Management (1) */
+        {  2, 0x6000 },     /* R2  - Power Management (2) */
+        {  3, 0x0000 },     /* R3  - Power Management (3) */
+        {  4, 0x4050 },     /* R4  - Audio Interface (1) */
+        {  5, 0x4000 },     /* R5  - Audio Interface (2) */
+        {  6, 0x01C8 },     /* R6  - Clocking (1) */
+        {  7, 0x0000 },     /* R7  - Clocking (2) */
+        {  8, 0x0040 },     /* R8  - Audio Interface (3) */
+        {  9, 0x0040 },     /* R9  - Audio Interface (4) */
+        { 10, 0x0004 },     /* R10 - DAC CTRL */
+        { 11, 0x00C0 },     /* R11 - Left DAC Digital Volume */
+        { 12, 0x00C0 },     /* R12 - Right DAC Digital Volume */
+        { 13, 0x0000 },     /* R13 - Digital Side Tone */
+        { 14, 0x0100 },     /* R14 - ADC CTRL */
+        { 15, 0x00C0 },     /* R15 - Left ADC Digital Volume */
+        { 16, 0x00C0 },     /* R16 - Right ADC Digital Volume */
+
+        { 18, 0x0000 },     /* R18 - GPIO CTRL 1 */
+        { 19, 0x1000 },     /* R19 - GPIO1 & GPIO2 */
+        { 20, 0x1010 },     /* R20 - GPIO3 & GPIO4 */
+        { 21, 0x1010 },     /* R21 - GPIO5 & GPIO6 */
+        { 22, 0x8000 },     /* R22 - GPIOCTRL 2 */
+        { 23, 0x0800 },     /* R23 - GPIO_POL */
+        { 24, 0x008B },     /* R24 - Left Line Input 1&2 Volume */
+        { 25, 0x008B },     /* R25 - Left Line Input 3&4 Volume */
+        { 26, 0x008B },     /* R26 - Right Line Input 1&2 Volume */
+        { 27, 0x008B },     /* R27 - Right Line Input 3&4 Volume */
+        { 28, 0x0000 },     /* R28 - Left Output Volume */
+        { 29, 0x0000 },     /* R29 - Right Output Volume */
+        { 30, 0x0066 },     /* R30 - Line Outputs Volume */
+        { 31, 0x0022 },     /* R31 - Out3/4 Volume */
+        { 32, 0x0079 },     /* R32 - Left OPGA Volume */
+        { 33, 0x0079 },     /* R33 - Right OPGA Volume */
+        { 34, 0x0003 },     /* R34 - Speaker Volume */
+        { 35, 0x0003 },     /* R35 - ClassD1 */
+
+        { 37, 0x0100 },     /* R37 - ClassD3 */
+
+        { 39, 0x0000 },     /* R39 - Input Mixer1 */
+        { 40, 0x0000 },     /* R40 - Input Mixer2 */
+        { 41, 0x0000 },     /* R41 - Input Mixer3 */
+        { 42, 0x0000 },     /* R42 - Input Mixer4 */
+        { 43, 0x0000 },     /* R43 - Input Mixer5 */
+        { 44, 0x0000 },     /* R44 - Input Mixer6 */
+        { 45, 0x0000 },     /* R45 - Output Mixer1 */
+        { 46, 0x0000 },     /* R46 - Output Mixer2 */
+        { 47, 0x0000 },     /* R47 - Output Mixer3 */
+        { 48, 0x0000 },     /* R48 - Output Mixer4 */
+        { 49, 0x0000 },     /* R49 - Output Mixer5 */
+        { 50, 0x0000 },     /* R50 - Output Mixer6 */
+        { 51, 0x0180 },     /* R51 - Out3/4 Mixer */
+        { 52, 0x0000 },     /* R52 - Line Mixer1 */
+        { 53, 0x0000 },     /* R53 - Line Mixer2 */
+        { 54, 0x0000 },     /* R54 - Speaker Mixer */
+        { 55, 0x0000 },     /* R55 - Additional Control */
+        { 56, 0x0000 },     /* R56 - AntiPOP1 */
+        { 57, 0x0000 },     /* R57 - AntiPOP2 */
+        { 58, 0x0000 },     /* R58 - MICBIAS */
+
+        { 60, 0x0008 },     /* R60 - PLL1 */
+        { 61, 0x0031 },     /* R61 - PLL2 */
+        { 62, 0x0026 },     /* R62 - PLL3 */
 };
 
-#define wm8991_reset(c) snd_soc_write(c, WM8991_RESET, 0)
+static bool wm8991_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8991_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
 
 static const unsigned int rec_mix_tlv[] = {
         TLV_DB_RANGE_HEAD(1),
@@ -374,30 +382,6 @@ static const struct snd_kcontrol_new wm8991_snd_controls[] = {
 /*
  * _DAPM_ Controls
  */
-static int inmixer_event(struct snd_soc_dapm_widget *w,
-                         struct snd_kcontrol *kcontrol, int event)
-{
-        u16 reg, fakepower;
-
-        reg = snd_soc_read(w->codec, WM8991_POWER_MANAGEMENT_2);
-        fakepower = snd_soc_read(w->codec, WM8991_INTDRIVBITS);
-
-        if (fakepower & ((1 << WM8991_INMIXL_PWR_BIT) |
-                         (1 << WM8991_AINLMUX_PWR_BIT)))
-                reg |= WM8991_AINL_ENA;
-        else
-                reg &= ~WM8991_AINL_ENA;
-
-        if (fakepower & ((1 << WM8991_INMIXR_PWR_BIT) |
-                         (1 << WM8991_AINRMUX_PWR_BIT)))
-                reg |= WM8991_AINR_ENA;
-        else
-                reg &= ~WM8991_AINR_ENA;
-
-        snd_soc_write(w->codec, WM8991_POWER_MANAGEMENT_2, reg);
-        return 0;
-}
-
 static int outmixer_event(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol, int event)
 {
@@ -655,6 +639,11 @@ static const struct snd_soc_dapm_widget wm8991_dapm_widgets[] = {
         SND_SOC_DAPM_INPUT("RIN2"),
         SND_SOC_DAPM_INPUT("Internal ADC Source"),
 
+        SND_SOC_DAPM_SUPPLY("INL", WM8991_POWER_MANAGEMENT_2,
+                            WM8991_AINL_ENA_BIT, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("INR", WM8991_POWER_MANAGEMENT_2,
+                            WM8991_AINR_ENA_BIT, 0, NULL, 0),
+
         /* DACs */
         SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8991_POWER_MANAGEMENT_2,
                 WM8991_ADCL_ENA_BIT, 0),
@@ -676,26 +665,22 @@ static const struct snd_soc_dapm_widget wm8991_dapm_widgets[] = {
                 ARRAY_SIZE(wm8991_dapm_rin34_pga_controls)),
 
         /* INMIXL */
-        SND_SOC_DAPM_MIXER_E("INMIXL", WM8991_INTDRIVBITS, WM8991_INMIXL_PWR_BIT, 0,
+        SND_SOC_DAPM_MIXER("INMIXL", SND_SOC_NOPM, 0, 0,
                 &wm8991_dapm_inmixl_controls[0],
-                ARRAY_SIZE(wm8991_dapm_inmixl_controls),
-                inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+                ARRAY_SIZE(wm8991_dapm_inmixl_controls)),
 
         /* AINLMUX */
-        SND_SOC_DAPM_MUX_E("AINLMUX", WM8991_INTDRIVBITS, WM8991_AINLMUX_PWR_BIT, 0,
-                &wm8991_dapm_ainlmux_controls, inmixer_event,
-                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MUX("AINLMUX", SND_SOC_NOPM, 0, 0,
+                &wm8991_dapm_ainlmux_controls),
 
         /* INMIXR */
-        SND_SOC_DAPM_MIXER_E("INMIXR", WM8991_INTDRIVBITS, WM8991_INMIXR_PWR_BIT, 0,
+        SND_SOC_DAPM_MIXER("INMIXR", SND_SOC_NOPM, 0, 0,
                 &wm8991_dapm_inmixr_controls[0],
-                ARRAY_SIZE(wm8991_dapm_inmixr_controls),
-                inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+                ARRAY_SIZE(wm8991_dapm_inmixr_controls)),
 
         /* AINRMUX */
-        SND_SOC_DAPM_MUX_E("AINRMUX", WM8991_INTDRIVBITS, WM8991_AINRMUX_PWR_BIT, 0,
-                &wm8991_dapm_ainrmux_controls, inmixer_event,
-                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MUX("AINRMUX", SND_SOC_NOPM, 0, 0,
+                &wm8991_dapm_ainrmux_controls),
 
         /* Output Side */
         /* DACs */
@@ -787,7 +772,7 @@ static const struct snd_soc_dapm_widget wm8991_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("Internal DAC Sink"),
 };
 
-static const struct snd_soc_dapm_route audio_map[] = {
+static const struct snd_soc_dapm_route wm8991_dapm_routes[] = {
         /* Make DACs turn on when playing even if not mixed into any outputs */
         {"Internal DAC Sink", NULL, "Left DAC"},
         {"Internal DAC Sink", NULL, "Right DAC"},
@@ -797,6 +782,10 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Right ADC", NULL, "Internal ADC Source"},
 
         /* Input Side */
+        {"INMIXL", NULL, "INL"},
+        {"AINLMUX", NULL, "INL"},
+        {"INMIXR", NULL, "INR"},
+        {"AINRMUX", NULL, "INR"},
         /* LIN12 PGA */
         {"LIN12 PGA", "LIN1 Switch", "LIN1"},
         {"LIN12 PGA", "LIN2 Switch", "LIN2"},
@@ -1129,6 +1118,7 @@ static int wm8991_mute(struct snd_soc_dai *dai, int mute)
 static int wm8991_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8991_priv *wm8991 = snd_soc_codec_get_drvdata(codec);
         u16 val;
 
         switch (level) {
@@ -1144,7 +1134,7 @@ static int wm8991_set_bias_level(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8991->regmap);
                         /* Enable all output discharge bits */
                         snd_soc_write(codec, WM8991_ANTIPOP1, WM8991_DIS_LLINE |
                                       WM8991_DIS_RLINE | WM8991_DIS_OUT3 |
@@ -1232,7 +1222,7 @@ static int wm8991_set_bias_level(struct snd_soc_codec *codec,
 
                 /* disable POBCTRL, SOFT_ST and BUFDCOPEN */
                 snd_soc_write(codec, WM8991_ANTIPOP2, 0x0);
-                codec->cache_sync = 1;
+                regcache_mark_dirty(wm8991->regmap);
                 break;
         }
 
@@ -1266,44 +1256,14 @@ static int wm8991_probe(struct snd_soc_codec *codec)
 
         wm8991 = snd_soc_codec_get_drvdata(codec);
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, wm8991->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache i/o: %d\n", ret);
                 return ret;
         }
 
-        ret = wm8991_reset(codec);
-        if (ret < 0) {
-                dev_err(codec->dev, "Failed to issue reset\n");
-                return ret;
-        }
-
         wm8991_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
-        snd_soc_update_bits(codec, WM8991_AUDIO_INTERFACE_4,
-                            WM8991_ALRCGPIO1, WM8991_ALRCGPIO1);
-
-        snd_soc_update_bits(codec, WM8991_GPIO1_GPIO2,
-                            WM8991_GPIO1_SEL_MASK, 1);
-
-        snd_soc_update_bits(codec, WM8991_POWER_MANAGEMENT_1,
-                            WM8991_VREF_ENA | WM8991_VMID_MODE_MASK,
-                            WM8991_VREF_ENA | WM8991_VMID_MODE_MASK);
-
-        snd_soc_update_bits(codec, WM8991_POWER_MANAGEMENT_2,
-                            WM8991_OPCLK_ENA, WM8991_OPCLK_ENA);
-
-        snd_soc_write(codec, WM8991_DAC_CTRL, 0);
-        snd_soc_write(codec, WM8991_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8));
-        snd_soc_write(codec, WM8991_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));
-
-        snd_soc_add_codec_controls(codec, wm8991_snd_controls,
-                             ARRAY_SIZE(wm8991_snd_controls));
-
-        snd_soc_dapm_new_controls(&codec->dapm, wm8991_dapm_widgets,
-                                  ARRAY_SIZE(wm8991_dapm_widgets));
-        snd_soc_dapm_add_routes(&codec->dapm, audio_map,
-                                ARRAY_SIZE(audio_map));
         return 0;
 }
 
@@ -1352,24 +1312,77 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8991 = {
         .suspend = wm8991_suspend,
         .resume = wm8991_resume,
         .set_bias_level = wm8991_set_bias_level,
-        .reg_cache_size = WM8991_MAX_REGISTER + 1,
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8991_reg_defs
+        .controls = wm8991_snd_controls,
+        .num_controls = ARRAY_SIZE(wm8991_snd_controls),
+        .dapm_widgets = wm8991_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(wm8991_dapm_widgets),
+        .dapm_routes = wm8991_dapm_routes,
+        .num_dapm_routes = ARRAY_SIZE(wm8991_dapm_routes),
+};
+
+static const struct regmap_config wm8991_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+
+        .max_register = WM8991_PLL3,
+        .volatile_reg = wm8991_volatile,
+        .reg_defaults = wm8991_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8991_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
 };
 
 static int wm8991_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct wm8991_priv *wm8991;
+        unsigned int val;
         int ret;
 
         wm8991 = devm_kzalloc(&i2c->dev, sizeof(*wm8991), GFP_KERNEL);
         if (!wm8991)
                 return -ENOMEM;
 
-        wm8991->control_type = SND_SOC_I2C;
+        wm8991->regmap = devm_regmap_init_i2c(i2c, &wm8991_regmap);
+        if (IS_ERR(wm8991->regmap))
+                return PTR_ERR(wm8991->regmap);
+
         i2c_set_clientdata(i2c, wm8991);
 
+        ret = regmap_read(wm8991->regmap, WM8991_RESET, &val);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to read device ID: %d\n", ret);
+                return ret;
+        }
+        if (val != 0x8991) {
+                dev_err(&i2c->dev, "Device with ID %x is not a WM8991\n", val);
+                return -EINVAL;
+        }
+
+        ret = regmap_write(wm8991->regmap, WM8991_RESET, 0);
+        if (ret < 0) {
+                dev_err(&i2c->dev, "Failed to issue reset: %d\n", ret);
+                return ret;
+        }
+
+        regmap_update_bits(wm8991->regmap, WM8991_AUDIO_INTERFACE_4,
+                           WM8991_ALRCGPIO1, WM8991_ALRCGPIO1);
+
+        regmap_update_bits(wm8991->regmap, WM8991_GPIO1_GPIO2,
+                           WM8991_GPIO1_SEL_MASK, 1);
+
+        regmap_update_bits(wm8991->regmap, WM8991_POWER_MANAGEMENT_1,
+                           WM8991_VREF_ENA | WM8991_VMID_MODE_MASK,
+                           WM8991_VREF_ENA | WM8991_VMID_MODE_MASK);
+
+        regmap_update_bits(wm8991->regmap, WM8991_POWER_MANAGEMENT_2,
+                           WM8991_OPCLK_ENA, WM8991_OPCLK_ENA);
+
+        regmap_write(wm8991->regmap, WM8991_DAC_CTRL, 0);
+        regmap_write(wm8991->regmap, WM8991_LEFT_OUTPUT_VOLUME,
+                     0x50 | (1<<8));
+        regmap_write(wm8991->regmap, WM8991_RIGHT_OUTPUT_VOLUME,
+                     0x50 | (1<<8));
+
         ret = snd_soc_register_codec(&i2c->dev,
                                      &soc_codec_dev_wm8991, &wm8991_dai, 1);
 
diff --git a/sound/soc/codecs/wm8991.h b/sound/soc/codecs/wm8991.h
index 07707d8d7e20..08ed383303c0 100644
--- a/sound/soc/codecs/wm8991.h
+++ b/sound/soc/codecs/wm8991.h
@@ -76,7 +76,6 @@
 #define WM8991_PLL1                             0x3C
 #define WM8991_PLL2                             0x3D
 #define WM8991_PLL3                             0x3E
-#define WM8991_INTDRIVBITS                      0x3F
 
 #define WM8991_REGISTER_COUNT                   60
 #define WM8991_MAX_REGISTER                     0x3F
@@ -807,14 +806,6 @@
  */
 #define WM8991_PLLK2_MASK                       0x00FF  /* PLLK2 - [7:0] */
 
-/*
- * R63 (0x3F) - Internal Driver Bits
- */
-#define WM8991_INMIXL_PWR_BIT                   0
-#define WM8991_AINLMUX_PWR_BIT                  1
-#define WM8991_INMIXR_PWR_BIT                   2
-#define WM8991_AINRMUX_PWR_BIT                  3
-
 #define WM8991_MCLK_DIV 0
 #define WM8991_DACCLK_DIV 1
 #define WM8991_ADCCLK_DIV 2
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index 86426a117b07..b9be9cbc4603 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -4077,12 +4077,6 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
         wm8994_request_irq(wm8994->wm8994, WM8994_IRQ_TEMP_SHUT,
                            wm8994_temp_shut, "Thermal shutdown", codec);
 
-        ret = wm8994_request_irq(wm8994->wm8994, WM8994_IRQ_DCS_DONE,
-                                 wm_hubs_dcs_done, "DC servo done",
-                                 &wm8994->hubs);
-        if (ret == 0)
-                wm8994->hubs.dcs_done_irq = true;
-
         switch (control->type) {
         case WM8994:
                 if (wm8994->micdet_irq) {
@@ -4313,6 +4307,11 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
         }
 
         wm_hubs_add_analogue_routes(codec, 0, 0);
+        ret = wm8994_request_irq(wm8994->wm8994, WM8994_IRQ_DCS_DONE,
+                                 wm_hubs_dcs_done, "DC servo done",
+                                 &wm8994->hubs);
+        if (ret == 0)
+                wm8994->hubs.dcs_done_irq = true;
         snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
 
         switch (control->type) {
diff --git a/sound/soc/codecs/wm8995.c b/sound/soc/codecs/wm8995.c
index da2899e6c401..4300caff1783 100644
--- a/sound/soc/codecs/wm8995.c
+++ b/sound/soc/codecs/wm8995.c
@@ -2293,7 +2293,7 @@ static struct spi_driver wm8995_spi_driver = {
 };
 #endif
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm8995_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -2350,7 +2350,7 @@ static int __init wm8995_modinit(void)
 {
         int ret = 0;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         ret = i2c_add_driver(&wm8995_i2c_driver);
         if (ret) {
                 printk(KERN_ERR "Failed to register wm8995 I2C driver: %d\n",
@@ -2371,7 +2371,7 @@ module_init(wm8995_modinit);
 
 static void __exit wm8995_exit(void)
 {
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_driver(&wm8995_i2c_driver);
 #endif
 #if defined(CONFIG_SPI_MASTER)
diff --git a/sound/soc/codecs/wm8997.c b/sound/soc/codecs/wm8997.c
index 1392bb3c9254..555115ee2159 100644
--- a/sound/soc/codecs/wm8997.c
+++ b/sound/soc/codecs/wm8997.c
@@ -103,8 +103,8 @@ static int wm8997_sysclk_ev(struct snd_soc_dapm_widget *w,
         case SND_SOC_DAPM_POST_PMU:
                 if (patch)
                         for (i = 0; i < patch_size; i++)
-                                regmap_write(regmap, patch[i].reg,
-                                             patch[i].def);
+                                regmap_write_async(regmap, patch[i].reg,
+                                                   patch[i].def);
                 break;
         default:
                 break;
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
index 630b3d776ec2..0982c1d38ec4 100644
--- a/sound/soc/codecs/wm9081.c
+++ b/sound/soc/codecs/wm9081.c
@@ -1326,7 +1326,7 @@ static const struct regmap_config wm9081_regmap = {
         .cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 static int wm9081_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c
index 4fbcab63e61f..fb0c678939bf 100644
--- a/sound/soc/codecs/wm_adsp.c
+++ b/sound/soc/codecs/wm_adsp.c
@@ -1286,6 +1286,7 @@ static int wm_adsp_load_coeff(struct wm_adsp *dsp)
                                         reg = wm_adsp_region_to_reg(mem,
                                                                     reg);
                                         reg += offset;
+                                        break;
                                 }
                         }
 
@@ -1468,8 +1469,8 @@ static int wm_adsp2_ena(struct wm_adsp *dsp)
         unsigned int val;
         int ret, count;
 
-        ret = regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL,
-                                 ADSP2_SYS_ENA, ADSP2_SYS_ENA);
+        ret = regmap_update_bits_async(dsp->regmap, dsp->base + ADSP2_CONTROL,
+                                       ADSP2_SYS_ENA, ADSP2_SYS_ENA);
         if (ret != 0)
                 return ret;
 
@@ -1492,7 +1493,6 @@ static int wm_adsp2_ena(struct wm_adsp *dsp)
         }
 
         adsp_dbg(dsp, "RAM ready after %d polls\n", count);
-        adsp_info(dsp, "RAM ready after %d polls\n", count);
 
         return 0;
 }
@@ -1525,9 +1525,9 @@ int wm_adsp2_event(struct snd_soc_dapm_widget *w,
                 val = (val & ARIZONA_SYSCLK_FREQ_MASK)
                         >> ARIZONA_SYSCLK_FREQ_SHIFT;
 
-                ret = regmap_update_bits(dsp->regmap,
-                                         dsp->base + ADSP2_CLOCKING,
-                                         ADSP2_CLK_SEL_MASK, val);
+                ret = regmap_update_bits_async(dsp->regmap,
+                                               dsp->base + ADSP2_CLOCKING,
+                                               ADSP2_CLK_SEL_MASK, val);
                 if (ret != 0) {
                         adsp_err(dsp, "Failed to set clock rate: %d\n",
                                  ret);
@@ -1590,10 +1590,10 @@ int wm_adsp2_event(struct snd_soc_dapm_widget *w,
                 if (ret != 0)
                         goto err;
 
-                ret = regmap_update_bits(dsp->regmap,
-                                         dsp->base + ADSP2_CONTROL,
-                                         ADSP2_CORE_ENA | ADSP2_START,
-                                         ADSP2_CORE_ENA | ADSP2_START);
+                ret = regmap_update_bits_async(dsp->regmap,
+                                               dsp->base + ADSP2_CONTROL,
+                                               ADSP2_CORE_ENA | ADSP2_START,
+                                               ADSP2_CORE_ENA | ADSP2_START);
                 if (ret != 0)
                         goto err;
 
diff --git a/sound/soc/davinci/Kconfig b/sound/soc/davinci/Kconfig
index 95970f5db3ec..a8ec1fc3e4d0 100644
--- a/sound/soc/davinci/Kconfig
+++ b/sound/soc/davinci/Kconfig
@@ -1,11 +1,6 @@
 config SND_DAVINCI_SOC
-        tristate "SoC Audio for the TI DAVINCI or AM33XX chip"
-        depends on ARCH_DAVINCI || SOC_AM33XX
-        help
-          Platform driver for daVinci or AM33xx
-          Say Y or M if you want to add support for codecs attached to
-          the DAVINCI AC97, I2S, or McASP interface. You will also need
-          to select the audio interfaces to support below.
+        tristate "SoC Audio for TI DAVINCI or AM33XX/AM43XX chips"
+        depends on ARCH_DAVINCI || SOC_AM33XX || SOC_AM43XX
 
 config SND_DAVINCI_SOC_I2S
         tristate
@@ -16,11 +11,15 @@ config SND_DAVINCI_SOC_MCASP
 config SND_DAVINCI_SOC_VCIF
         tristate
 
+config SND_DAVINCI_SOC_GENERIC_EVM
+        tristate
+        select SND_SOC_TLV320AIC3X
+        select SND_DAVINCI_SOC_MCASP
+
 config SND_AM33XX_SOC_EVM
         tristate "SoC Audio for the AM33XX chip based boards"
         depends on SND_DAVINCI_SOC && SOC_AM33XX
-        select SND_SOC_TLV320AIC3X
-        select SND_DAVINCI_SOC_MCASP
+        select SND_DAVINCI_SOC_GENERIC_EVM
         help
           Say Y or M if you want to add support for SoC audio on AM33XX
           boards using McASP and TLV320AIC3X codec. For example AM335X-EVM,
@@ -31,8 +30,7 @@ config SND_DAVINCI_SOC_EVM
         tristate "SoC Audio support for DaVinci DM6446, DM355 or DM365 EVM"
         depends on SND_DAVINCI_SOC
         depends on MACH_DAVINCI_EVM || MACH_DAVINCI_DM355_EVM || MACH_DAVINCI_DM365_EVM
-        select SND_DAVINCI_SOC_I2S
-        select SND_SOC_TLV320AIC3X
+        select SND_DAVINCI_SOC_GENERIC_EVM
         help
           Say Y if you want to add support for SoC audio on TI
           DaVinci DM6446, DM355 or DM365 EVM platforms.
@@ -59,8 +57,7 @@ endchoice
 config  SND_DM6467_SOC_EVM
         tristate "SoC Audio support for DaVinci DM6467 EVM"
         depends on SND_DAVINCI_SOC && MACH_DAVINCI_DM6467_EVM
-        select SND_DAVINCI_SOC_MCASP
-        select SND_SOC_TLV320AIC3X
+        select SND_DAVINCI_SOC_GENERIC_EVM
         select SND_SOC_SPDIF
 
         help
@@ -69,8 +66,7 @@ config  SND_DM6467_SOC_EVM
 config  SND_DA830_SOC_EVM
         tristate "SoC Audio support for DA830/OMAP-L137 EVM"
         depends on SND_DAVINCI_SOC && MACH_DAVINCI_DA830_EVM
-        select SND_DAVINCI_SOC_MCASP
-        select SND_SOC_TLV320AIC3X
+        select SND_DAVINCI_SOC_GENERIC_EVM
 
         help
           Say Y if you want to add support for SoC audio on TI
@@ -79,8 +75,7 @@ config  SND_DA830_SOC_EVM
 config  SND_DA850_SOC_EVM
         tristate "SoC Audio support for DA850/OMAP-L138 EVM"
         depends on SND_DAVINCI_SOC && MACH_DAVINCI_DA850_EVM
-        select SND_DAVINCI_SOC_MCASP
-        select SND_SOC_TLV320AIC3X
+        select SND_DAVINCI_SOC_GENERIC_EVM
         help
           Say Y if you want to add support for SoC audio on TI
           DA850/OMAP-L138 EVM
diff --git a/sound/soc/davinci/Makefile b/sound/soc/davinci/Makefile
index bc81e79fc301..744d4d9a0184 100644
--- a/sound/soc/davinci/Makefile
+++ b/sound/soc/davinci/Makefile
@@ -9,11 +9,7 @@ obj-$(CONFIG_SND_DAVINCI_SOC_I2S) += snd-soc-davinci-i2s.o
 obj-$(CONFIG_SND_DAVINCI_SOC_MCASP) += snd-soc-davinci-mcasp.o
 obj-$(CONFIG_SND_DAVINCI_SOC_VCIF) += snd-soc-davinci-vcif.o
 
-# DAVINCI Machine Support
+# Generic DAVINCI/AM33xx Machine Support
 snd-soc-evm-objs := davinci-evm.o
 
-obj-$(CONFIG_SND_DAVINCI_SOC_EVM) += snd-soc-evm.o
-obj-$(CONFIG_SND_AM33XX_SOC_EVM) += snd-soc-evm.o
-obj-$(CONFIG_SND_DM6467_SOC_EVM) += snd-soc-evm.o
-obj-$(CONFIG_SND_DA830_SOC_EVM) += snd-soc-evm.o
-obj-$(CONFIG_SND_DA850_SOC_EVM) += snd-soc-evm.o
+obj-$(CONFIG_SND_DAVINCI_SOC_GENERIC_EVM) += snd-soc-evm.o
diff --git a/sound/soc/davinci/davinci-evm.c b/sound/soc/davinci/davinci-evm.c
index 623eb5e7c089..70ff3772079f 100644
--- a/sound/soc/davinci/davinci-evm.c
+++ b/sound/soc/davinci/davinci-evm.c
@@ -28,14 +28,11 @@
 
 #include "davinci-pcm.h"
 #include "davinci-i2s.h"
-#include "davinci-mcasp.h"
 
 struct snd_soc_card_drvdata_davinci {
         unsigned sysclk;
 };
 
-#define AUDIO_FORMAT (SND_SOC_DAIFMT_DSP_B | \
-                SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_IB_NF)
 static int evm_hw_params(struct snd_pcm_substream *substream,
                          struct snd_pcm_hw_params *params)
 {
@@ -48,16 +45,6 @@ static int evm_hw_params(struct snd_pcm_substream *substream,
         unsigned sysclk = ((struct snd_soc_card_drvdata_davinci *)
                            snd_soc_card_get_drvdata(soc_card))->sysclk;
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, AUDIO_FORMAT);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, AUDIO_FORMAT);
-        if (ret < 0)
-                return ret;
-
         /* set the codec system clock */
         ret = snd_soc_dai_set_sysclk(codec_dai, 0, sysclk, SND_SOC_CLOCK_OUT);
         if (ret < 0)
@@ -71,24 +58,10 @@ static int evm_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static int evm_spdif_hw_params(struct snd_pcm_substream *substream,
-                                struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-
-        /* set cpu DAI configuration */
-        return snd_soc_dai_set_fmt(cpu_dai, AUDIO_FORMAT);
-}
-
 static struct snd_soc_ops evm_ops = {
         .hw_params = evm_hw_params,
 };
 
-static struct snd_soc_ops evm_spdif_ops = {
-        .hw_params = evm_spdif_hw_params,
-};
-
 /* davinci-evm machine dapm widgets */
 static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
         SND_SOC_DAPM_HP("Headphone Jack", NULL),
@@ -165,6 +138,8 @@ static struct snd_soc_dai_link dm6446_evm_dai = {
         .platform_name = "davinci-mcbsp",
         .init = evm_aic3x_init,
         .ops = &evm_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 };
 
 static struct snd_soc_dai_link dm355_evm_dai = {
@@ -176,6 +151,8 @@ static struct snd_soc_dai_link dm355_evm_dai = {
         .platform_name = "davinci-mcbsp.1",
         .init = evm_aic3x_init,
         .ops = &evm_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 };
 
 static struct snd_soc_dai_link dm365_evm_dai = {
@@ -184,10 +161,12 @@ static struct snd_soc_dai_link dm365_evm_dai = {
         .stream_name = "AIC3X",
         .cpu_dai_name = "davinci-mcbsp",
         .codec_dai_name = "tlv320aic3x-hifi",
-        .init = evm_aic3x_init,
         .codec_name = "tlv320aic3x-codec.1-0018",
-        .ops = &evm_ops,
         .platform_name = "davinci-mcbsp",
+        .init = evm_aic3x_init,
+        .ops = &evm_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 #elif defined(CONFIG_SND_DM365_VOICE_CODEC)
         .name = "Voice Codec - CQ93VC",
         .stream_name = "CQ93",
@@ -208,6 +187,8 @@ static struct snd_soc_dai_link dm6467_evm_dai[] = {
                 .codec_name = "tlv320aic3x-codec.0-001a",
                 .init = evm_aic3x_init,
                 .ops = &evm_ops,
+                .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                           SND_SOC_DAIFMT_IB_NF,
         },
         {
                 .name = "McASP",
@@ -216,7 +197,8 @@ static struct snd_soc_dai_link dm6467_evm_dai[] = {
                 .codec_dai_name = "dit-hifi",
                 .codec_name = "spdif_dit",
                 .platform_name = "davinci-mcasp.1",
-                .ops = &evm_spdif_ops,
+                .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                           SND_SOC_DAIFMT_IB_NF,
         },
 };
 
@@ -229,6 +211,8 @@ static struct snd_soc_dai_link da830_evm_dai = {
         .platform_name = "davinci-mcasp.1",
         .init = evm_aic3x_init,
         .ops = &evm_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 };
 
 static struct snd_soc_dai_link da850_evm_dai = {
@@ -240,6 +224,8 @@ static struct snd_soc_dai_link da850_evm_dai = {
         .platform_name = "davinci-mcasp.0",
         .init = evm_aic3x_init,
         .ops = &evm_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 };
 
 /* davinci dm6446 evm audio machine driver */
@@ -336,6 +322,8 @@ static struct snd_soc_dai_link evm_dai_tlv320aic3x = {
         .codec_dai_name = "tlv320aic3x-hifi",
         .ops            = &evm_ops,
         .init           = evm_aic3x_init,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
+                   SND_SOC_DAIFMT_IB_NF,
 };
 
 static const struct of_device_id davinci_evm_dt_ids[] = {
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index 71e14bb3a8cd..b7858bfa0295 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/io.h>
+#include <linux/clk.h>
 #include <linux/pm_runtime.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
@@ -31,351 +32,147 @@
 #include <sound/pcm_params.h>
 #include <sound/initval.h>
 #include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
 
 #include "davinci-pcm.h"
 #include "davinci-mcasp.h"
 
-/*
- * McASP register definitions
- */
-#define DAVINCI_MCASP_PID_REG           0x00
-#define DAVINCI_MCASP_PWREMUMGT_REG     0x04
-
-#define DAVINCI_MCASP_PFUNC_REG         0x10
-#define DAVINCI_MCASP_PDIR_REG          0x14
-#define DAVINCI_MCASP_PDOUT_REG         0x18
-#define DAVINCI_MCASP_PDSET_REG         0x1c
-
-#define DAVINCI_MCASP_PDCLR_REG         0x20
-
-#define DAVINCI_MCASP_TLGC_REG          0x30
-#define DAVINCI_MCASP_TLMR_REG          0x34
-
-#define DAVINCI_MCASP_GBLCTL_REG        0x44
-#define DAVINCI_MCASP_AMUTE_REG         0x48
-#define DAVINCI_MCASP_LBCTL_REG         0x4c
-
-#define DAVINCI_MCASP_TXDITCTL_REG      0x50
-
-#define DAVINCI_MCASP_GBLCTLR_REG       0x60
-#define DAVINCI_MCASP_RXMASK_REG        0x64
-#define DAVINCI_MCASP_RXFMT_REG         0x68
-#define DAVINCI_MCASP_RXFMCTL_REG       0x6c
-
-#define DAVINCI_MCASP_ACLKRCTL_REG      0x70
-#define DAVINCI_MCASP_AHCLKRCTL_REG     0x74
-#define DAVINCI_MCASP_RXTDM_REG         0x78
-#define DAVINCI_MCASP_EVTCTLR_REG       0x7c
-
-#define DAVINCI_MCASP_RXSTAT_REG        0x80
-#define DAVINCI_MCASP_RXTDMSLOT_REG     0x84
-#define DAVINCI_MCASP_RXCLKCHK_REG      0x88
-#define DAVINCI_MCASP_REVTCTL_REG       0x8c
-
-#define DAVINCI_MCASP_GBLCTLX_REG       0xa0
-#define DAVINCI_MCASP_TXMASK_REG        0xa4
-#define DAVINCI_MCASP_TXFMT_REG         0xa8
-#define DAVINCI_MCASP_TXFMCTL_REG       0xac
-
-#define DAVINCI_MCASP_ACLKXCTL_REG      0xb0
-#define DAVINCI_MCASP_AHCLKXCTL_REG     0xb4
-#define DAVINCI_MCASP_TXTDM_REG         0xb8
-#define DAVINCI_MCASP_EVTCTLX_REG       0xbc
-
-#define DAVINCI_MCASP_TXSTAT_REG        0xc0
-#define DAVINCI_MCASP_TXTDMSLOT_REG     0xc4
-#define DAVINCI_MCASP_TXCLKCHK_REG      0xc8
-#define DAVINCI_MCASP_XEVTCTL_REG       0xcc
-
-/* Left(even TDM Slot) Channel Status Register File */
-#define DAVINCI_MCASP_DITCSRA_REG       0x100
-/* Right(odd TDM slot) Channel Status Register File */
-#define DAVINCI_MCASP_DITCSRB_REG       0x118
-/* Left(even TDM slot) User Data Register File */
-#define DAVINCI_MCASP_DITUDRA_REG       0x130
-/* Right(odd TDM Slot) User Data Register File */
-#define DAVINCI_MCASP_DITUDRB_REG       0x148
-
-/* Serializer n Control Register */
-#define DAVINCI_MCASP_XRSRCTL_BASE_REG  0x180
-#define DAVINCI_MCASP_XRSRCTL_REG(n)    (DAVINCI_MCASP_XRSRCTL_BASE_REG + \
-                                                (n << 2))
-
-/* Transmit Buffer for Serializer n */
-#define DAVINCI_MCASP_TXBUF_REG         0x200
-/* Receive Buffer for Serializer n */
-#define DAVINCI_MCASP_RXBUF_REG         0x280
-
-/* McASP FIFO Registers */
-#define DAVINCI_MCASP_WFIFOCTL          (0x1010)
-#define DAVINCI_MCASP_WFIFOSTS          (0x1014)
-#define DAVINCI_MCASP_RFIFOCTL          (0x1018)
-#define DAVINCI_MCASP_RFIFOSTS          (0x101C)
-#define MCASP_VER3_WFIFOCTL             (0x1000)
-#define MCASP_VER3_WFIFOSTS             (0x1004)
-#define MCASP_VER3_RFIFOCTL             (0x1008)
-#define MCASP_VER3_RFIFOSTS             (0x100C)
-
-/*
- * DAVINCI_MCASP_PWREMUMGT_REG - Power Down and Emulation Management
- *     Register Bits
- */
-#define MCASP_FREE      BIT(0)
-#define MCASP_SOFT      BIT(1)
-
-/*
- * DAVINCI_MCASP_PFUNC_REG - Pin Function / GPIO Enable Register Bits
- */
-#define AXR(n)          (1<<n)
-#define PFUNC_AMUTE     BIT(25)
-#define ACLKX           BIT(26)
-#define AHCLKX          BIT(27)
-#define AFSX            BIT(28)
-#define ACLKR           BIT(29)
-#define AHCLKR          BIT(30)
-#define AFSR            BIT(31)
-
-/*
- * DAVINCI_MCASP_PDIR_REG - Pin Direction Register Bits
- */
-#define AXR(n)          (1<<n)
-#define PDIR_AMUTE      BIT(25)
-#define ACLKX           BIT(26)
-#define AHCLKX          BIT(27)
-#define AFSX            BIT(28)
-#define ACLKR           BIT(29)
-#define AHCLKR          BIT(30)
-#define AFSR            BIT(31)
-
-/*
- * DAVINCI_MCASP_TXDITCTL_REG - Transmit DIT Control Register Bits
- */
-#define DITEN   BIT(0)  /* Transmit DIT mode enable/disable */
-#define VA      BIT(2)
-#define VB      BIT(3)
-
-/*
- * DAVINCI_MCASP_TXFMT_REG - Transmit Bitstream Format Register Bits
- */
-#define TXROT(val)      (val)
-#define TXSEL           BIT(3)
-#define TXSSZ(val)      (val<<4)
-#define TXPBIT(val)     (val<<8)
-#define TXPAD(val)      (val<<13)
-#define TXORD           BIT(15)
-#define FSXDLY(val)     (val<<16)
-
-/*
- * DAVINCI_MCASP_RXFMT_REG - Receive Bitstream Format Register Bits
- */
-#define RXROT(val)      (val)
-#define RXSEL           BIT(3)
-#define RXSSZ(val)      (val<<4)
-#define RXPBIT(val)     (val<<8)
-#define RXPAD(val)      (val<<13)
-#define RXORD           BIT(15)
-#define FSRDLY(val)     (val<<16)
-
-/*
- * DAVINCI_MCASP_TXFMCTL_REG -  Transmit Frame Control Register Bits
- */
-#define FSXPOL          BIT(0)
-#define AFSXE           BIT(1)
-#define FSXDUR          BIT(4)
-#define FSXMOD(val)     (val<<7)
-
-/*
- * DAVINCI_MCASP_RXFMCTL_REG - Receive Frame Control Register Bits
- */
-#define FSRPOL          BIT(0)
-#define AFSRE           BIT(1)
-#define FSRDUR          BIT(4)
-#define FSRMOD(val)     (val<<7)
-
-/*
- * DAVINCI_MCASP_ACLKXCTL_REG - Transmit Clock Control Register Bits
- */
-#define ACLKXDIV(val)   (val)
-#define ACLKXE          BIT(5)
-#define TX_ASYNC        BIT(6)
-#define ACLKXPOL        BIT(7)
-#define ACLKXDIV_MASK   0x1f
-
-/*
- * DAVINCI_MCASP_ACLKRCTL_REG Receive Clock Control Register Bits
- */
-#define ACLKRDIV(val)   (val)
-#define ACLKRE          BIT(5)
-#define RX_ASYNC        BIT(6)
-#define ACLKRPOL        BIT(7)
-#define ACLKRDIV_MASK   0x1f
-
-/*
- * DAVINCI_MCASP_AHCLKXCTL_REG - High Frequency Transmit Clock Control
- *     Register Bits
- */
-#define AHCLKXDIV(val)  (val)
-#define AHCLKXPOL       BIT(14)
-#define AHCLKXE         BIT(15)
-#define AHCLKXDIV_MASK  0xfff
+struct davinci_mcasp {
+        struct davinci_pcm_dma_params dma_params[2];
+        struct snd_dmaengine_dai_dma_data dma_data[2];
+        void __iomem *base;
+        u32 fifo_base;
+        struct device *dev;
 
-/*
- * DAVINCI_MCASP_AHCLKRCTL_REG - High Frequency Receive Clock Control
- *     Register Bits
- */
-#define AHCLKRDIV(val)  (val)
-#define AHCLKRPOL       BIT(14)
-#define AHCLKRE         BIT(15)
-#define AHCLKRDIV_MASK  0xfff
+        /* McASP specific data */
+        int     tdm_slots;
+        u8      op_mode;
+        u8      num_serializer;
+        u8      *serial_dir;
+        u8      version;
+        u16     bclk_lrclk_ratio;
+        int     streams;
 
-/*
- * DAVINCI_MCASP_XRSRCTL_BASE_REG -  Serializer Control Register Bits
- */
-#define MODE(val)       (val)
-#define DISMOD          (val)(val<<2)
-#define TXSTATE         BIT(4)
-#define RXSTATE         BIT(5)
-#define SRMOD_MASK      3
-#define SRMOD_INACTIVE  0
-
-/*
- * DAVINCI_MCASP_LBCTL_REG - Loop Back Control Register Bits
- */
-#define LBEN            BIT(0)
-#define LBORD           BIT(1)
-#define LBGENMODE(val)  (val<<2)
+        /* McASP FIFO related */
+        u8      txnumevt;
+        u8      rxnumevt;
 
-/*
- * DAVINCI_MCASP_TXTDMSLOT_REG - Transmit TDM Slot Register configuration
- */
-#define TXTDMS(n)       (1<<n)
-
-/*
- * DAVINCI_MCASP_RXTDMSLOT_REG - Receive TDM Slot Register configuration
- */
-#define RXTDMS(n)       (1<<n)
-
-/*
- * DAVINCI_MCASP_GBLCTL_REG -  Global Control Register Bits
- */
-#define RXCLKRST        BIT(0)  /* Receiver Clock Divider Reset */
-#define RXHCLKRST       BIT(1)  /* Receiver High Frequency Clock Divider */
-#define RXSERCLR        BIT(2)  /* Receiver Serializer Clear */
-#define RXSMRST         BIT(3)  /* Receiver State Machine Reset */
-#define RXFSRST         BIT(4)  /* Frame Sync Generator Reset */
-#define TXCLKRST        BIT(8)  /* Transmitter Clock Divider Reset */
-#define TXHCLKRST       BIT(9)  /* Transmitter High Frequency Clock Divider*/
-#define TXSERCLR        BIT(10) /* Transmit Serializer Clear */
-#define TXSMRST         BIT(11) /* Transmitter State Machine Reset */
-#define TXFSRST         BIT(12) /* Frame Sync Generator Reset */
+        bool    dat_port;
 
-/*
- * DAVINCI_MCASP_AMUTE_REG -  Mute Control Register Bits
- */
-#define MUTENA(val)     (val)
-#define MUTEINPOL       BIT(2)
-#define MUTEINENA       BIT(3)
-#define MUTEIN          BIT(4)
-#define MUTER           BIT(5)
-#define MUTEX           BIT(6)
-#define MUTEFSR         BIT(7)
-#define MUTEFSX         BIT(8)
-#define MUTEBADCLKR     BIT(9)
-#define MUTEBADCLKX     BIT(10)
-#define MUTERXDMAERR    BIT(11)
-#define MUTETXDMAERR    BIT(12)
-
-/*
- * DAVINCI_MCASP_REVTCTL_REG - Receiver DMA Event Control Register bits
- */
-#define RXDATADMADIS    BIT(0)
-
-/*
- * DAVINCI_MCASP_XEVTCTL_REG - Transmitter DMA Event Control Register bits
- */
-#define TXDATADMADIS    BIT(0)
-
-/*
- * DAVINCI_MCASP_W[R]FIFOCTL - Write/Read FIFO Control Register bits
- */
-#define FIFO_ENABLE     BIT(16)
-#define NUMEVT_MASK     (0xFF << 8)
-#define NUMDMA_MASK     (0xFF)
-
-#define DAVINCI_MCASP_NUM_SERIALIZER    16
+#ifdef CONFIG_PM_SLEEP
+        struct {
+                u32     txfmtctl;
+                u32     rxfmtctl;
+                u32     txfmt;
+                u32     rxfmt;
+                u32     aclkxctl;
+                u32     aclkrctl;
+                u32     pdir;
+        } context;
+#endif
+};
 
-static inline void mcasp_set_bits(void __iomem *reg, u32 val)
+static inline void mcasp_set_bits(struct davinci_mcasp *mcasp, u32 offset,
+                                  u32 val)
 {
+        void __iomem *reg = mcasp->base + offset;
         __raw_writel(__raw_readl(reg) | val, reg);
 }
 
-static inline void mcasp_clr_bits(void __iomem *reg, u32 val)
+static inline void mcasp_clr_bits(struct davinci_mcasp *mcasp, u32 offset,
+                                  u32 val)
 {
+        void __iomem *reg = mcasp->base + offset;
         __raw_writel((__raw_readl(reg) & ~(val)), reg);
 }
 
-static inline void mcasp_mod_bits(void __iomem *reg, u32 val, u32 mask)
+static inline void mcasp_mod_bits(struct davinci_mcasp *mcasp, u32 offset,
+                                  u32 val, u32 mask)
 {
+        void __iomem *reg = mcasp->base + offset;
         __raw_writel((__raw_readl(reg) & ~mask) | val, reg);
 }
 
-static inline void mcasp_set_reg(void __iomem *reg, u32 val)
+static inline void mcasp_set_reg(struct davinci_mcasp *mcasp, u32 offset,
+                                 u32 val)
 {
-        __raw_writel(val, reg);
+        __raw_writel(val, mcasp->base + offset);
 }
 
-static inline u32 mcasp_get_reg(void __iomem *reg)
+static inline u32 mcasp_get_reg(struct davinci_mcasp *mcasp, u32 offset)
 {
-        return (unsigned int)__raw_readl(reg);
+        return (u32)__raw_readl(mcasp->base + offset);
 }
 
-static inline void mcasp_set_ctl_reg(void __iomem *regs, u32 val)
+static void mcasp_set_ctl_reg(struct davinci_mcasp *mcasp, u32 ctl_reg, u32 val)
 {
         int i = 0;
 
-        mcasp_set_bits(regs, val);
+        mcasp_set_bits(mcasp, ctl_reg, val);
 
         /* programming GBLCTL needs to read back from GBLCTL and verfiy */
         /* loop count is to avoid the lock-up */
         for (i = 0; i < 1000; i++) {
-                if ((mcasp_get_reg(regs) & val) == val)
+                if ((mcasp_get_reg(mcasp, ctl_reg) & val) == val)
                         break;
         }
 
-        if (i == 1000 && ((mcasp_get_reg(regs) & val) != val))
+        if (i == 1000 && ((mcasp_get_reg(mcasp, ctl_reg) & val) != val))
                 printk(KERN_ERR "GBLCTL write error\n");
 }
 
-static void mcasp_start_rx(struct davinci_audio_dev *dev)
+static bool mcasp_is_synchronous(struct davinci_mcasp *mcasp)
 {
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_RXBUF_REG, 0);
+        u32 rxfmctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXFMCTL_REG);
+        u32 aclkxctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_ACLKXCTL_REG);
 
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_RXBUF_REG, 0);
+        return !(aclkxctl & TX_ASYNC) && rxfmctl & AFSRE;
+}
 
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
+static void mcasp_start_rx(struct davinci_mcasp *mcasp)
+{
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
+
+        /*
+         * When ASYNC == 0 the transmit and receive sections operate
+         * synchronously from the transmit clock and frame sync. We need to make
+         * sure that the TX signlas are enabled when starting reception.
+         */
+        if (mcasp_is_synchronous(mcasp)) {
+                mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
+                mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
+        }
+
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXBUF_REG, 0);
+
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXBUF_REG, 0);
+
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
+
+        if (mcasp_is_synchronous(mcasp))
+                mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 }
 
-static void mcasp_start_tx(struct davinci_audio_dev *dev)
+static void mcasp_start_tx(struct davinci_mcasp *mcasp)
 {
         u8 offset = 0, i;
         u32 cnt;
 
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
 
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
-        mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
-        for (i = 0; i < dev->num_serializer; i++) {
-                if (dev->serial_dir[i] == TX_MODE) {
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
+        for (i = 0; i < mcasp->num_serializer; i++) {
+                if (mcasp->serial_dir[i] == TX_MODE) {
                         offset = i;
                         break;
                 }
@@ -383,156 +180,140 @@ static void mcasp_start_tx(struct davinci_audio_dev *dev)
 
         /* wait for TX ready */
         cnt = 0;
-        while (!(mcasp_get_reg(dev->base + DAVINCI_MCASP_XRSRCTL_REG(offset)) &
+        while (!(mcasp_get_reg(mcasp, DAVINCI_MCASP_XRSRCTL_REG(offset)) &
                  TXSTATE) && (cnt < 100000))
                 cnt++;
 
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
 }
 
-static void davinci_mcasp_start(struct davinci_audio_dev *dev, int stream)
+static void davinci_mcasp_start(struct davinci_mcasp *mcasp, int stream)
 {
+        u32 reg;
+
+        mcasp->streams++;
+
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                if (dev->txnumevt) {    /* enable FIFO */
-                        switch (dev->version) {
-                        case MCASP_VERSION_3:
-                                mcasp_clr_bits(dev->base + MCASP_VER3_WFIFOCTL,
-                                                                FIFO_ENABLE);
-                                mcasp_set_bits(dev->base + MCASP_VER3_WFIFOCTL,
-                                                                FIFO_ENABLE);
-                                break;
-                        default:
-                                mcasp_clr_bits(dev->base +
-                                        DAVINCI_MCASP_WFIFOCTL, FIFO_ENABLE);
-                                mcasp_set_bits(dev->base +
-                                        DAVINCI_MCASP_WFIFOCTL, FIFO_ENABLE);
-                        }
+                if (mcasp->txnumevt) {  /* enable FIFO */
+                        reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
+                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
+                        mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
                 }
-                mcasp_start_tx(dev);
+                mcasp_start_tx(mcasp);
         } else {
-                if (dev->rxnumevt) {    /* enable FIFO */
-                        switch (dev->version) {
-                        case MCASP_VERSION_3:
-                                mcasp_clr_bits(dev->base + MCASP_VER3_RFIFOCTL,
-                                                                FIFO_ENABLE);
-                                mcasp_set_bits(dev->base + MCASP_VER3_RFIFOCTL,
-                                                                FIFO_ENABLE);
-                                break;
-                        default:
-                                mcasp_clr_bits(dev->base +
-                                        DAVINCI_MCASP_RFIFOCTL, FIFO_ENABLE);
-                                mcasp_set_bits(dev->base +
-                                        DAVINCI_MCASP_RFIFOCTL, FIFO_ENABLE);
-                        }
+                if (mcasp->rxnumevt) {  /* enable FIFO */
+                        reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
+                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
+                        mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
                 }
-                mcasp_start_rx(dev);
+                mcasp_start_rx(mcasp);
         }
 }
 
-static void mcasp_stop_rx(struct davinci_audio_dev *dev)
+static void mcasp_stop_rx(struct davinci_mcasp *mcasp)
 {
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, 0);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
+        /*
+         * In synchronous mode stop the TX clocks if no other stream is
+         * running
+         */
+        if (mcasp_is_synchronous(mcasp) && !mcasp->streams)
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, 0);
+
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, 0);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
 }
 
-static void mcasp_stop_tx(struct davinci_audio_dev *dev)
+static void mcasp_stop_tx(struct davinci_mcasp *mcasp)
 {
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, 0);
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
+        u32 val = 0;
+
+        /*
+         * In synchronous mode keep TX clocks running if the capture stream is
+         * still running.
+         */
+        if (mcasp_is_synchronous(mcasp) && mcasp->streams)
+                val =  TXHCLKRST | TXCLKRST | TXFSRST;
+
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, val);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
 }
 
-static void davinci_mcasp_stop(struct davinci_audio_dev *dev, int stream)
+static void davinci_mcasp_stop(struct davinci_mcasp *mcasp, int stream)
 {
+        u32 reg;
+
+        mcasp->streams--;
+
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                if (dev->txnumevt) {    /* disable FIFO */
-                        switch (dev->version) {
-                        case MCASP_VERSION_3:
-                                mcasp_clr_bits(dev->base + MCASP_VER3_WFIFOCTL,
-                                                                FIFO_ENABLE);
-                                break;
-                        default:
-                                mcasp_clr_bits(dev->base +
-                                        DAVINCI_MCASP_WFIFOCTL, FIFO_ENABLE);
-                        }
+                if (mcasp->txnumevt) {  /* disable FIFO */
+                        reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
+                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
                 }
-                mcasp_stop_tx(dev);
+                mcasp_stop_tx(mcasp);
         } else {
-                if (dev->rxnumevt) {    /* disable FIFO */
-                        switch (dev->version) {
-                        case MCASP_VERSION_3:
-                                mcasp_clr_bits(dev->base + MCASP_VER3_RFIFOCTL,
-                                                                FIFO_ENABLE);
-                        break;
-
-                        default:
-                                mcasp_clr_bits(dev->base +
-                                        DAVINCI_MCASP_RFIFOCTL, FIFO_ENABLE);
-                        }
+                if (mcasp->rxnumevt) {  /* disable FIFO */
+                        reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
+                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
                 }
-                mcasp_stop_rx(dev);
+                mcasp_stop_rx(mcasp);
         }
 }
 
 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                                          unsigned int fmt)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
-        void __iomem *base = dev->base;
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 
         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
         case SND_SOC_DAIFMT_DSP_B:
         case SND_SOC_DAIFMT_AC97:
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
                 break;
         default:
                 /* configure a full-word SYNC pulse (LRCLK) */
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 
                 /* make 1st data bit occur one ACLK cycle after the frame sync */
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMT_REG, FSXDLY(1));
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_RXFMT_REG, FSRDLY(1));
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, FSXDLY(1));
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, FSRDLY(1));
                 break;
         }
 
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
         case SND_SOC_DAIFMT_CBS_CFS:
                 /* codec is clock and frame slave */
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
-                mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
-                mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 
-                mcasp_set_bits(base + DAVINCI_MCASP_PDIR_REG,
-                                ACLKX | ACLKR);
-                mcasp_set_bits(base + DAVINCI_MCASP_PDIR_REG,
-                                AFSX | AFSR);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
                 break;
         case SND_SOC_DAIFMT_CBM_CFS:
                 /* codec is clock master and frame slave */
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
-                mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
-                mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 
-                mcasp_clr_bits(base + DAVINCI_MCASP_PDIR_REG,
-                                ACLKX | ACLKR);
-                mcasp_set_bits(base + DAVINCI_MCASP_PDIR_REG,
-                                AFSX | AFSR);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
                 break;
         case SND_SOC_DAIFMT_CBM_CFM:
                 /* codec is clock and frame master */
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
-                mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
-                mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 
-                mcasp_clr_bits(base + DAVINCI_MCASP_PDIR_REG,
-                                ACLKX | AHCLKX | AFSX | ACLKR | AHCLKR | AFSR);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG,
+                               ACLKX | AHCLKX | AFSX | ACLKR | AHCLKR | AFSR);
                 break;
 
         default:
@@ -541,35 +322,35 @@ static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 
         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
         case SND_SOC_DAIFMT_IB_NF:
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
-                mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
-                mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
                 break;
 
         case SND_SOC_DAIFMT_NB_IF:
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
-                mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
-                mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
                 break;
 
         case SND_SOC_DAIFMT_IB_IF:
-                mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
-                mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
-                mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
                 break;
 
         case SND_SOC_DAIFMT_NB_NF:
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
-                mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 
-                mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
-                mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
                 break;
 
         default:
@@ -581,25 +362,25 @@ static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 
 static int davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(dai);
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 
         switch (div_id) {
         case 0:         /* MCLK divider */
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG,
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG,
                                AHCLKXDIV(div - 1), AHCLKXDIV_MASK);
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_AHCLKRCTL_REG,
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG,
                                AHCLKRDIV(div - 1), AHCLKRDIV_MASK);
                 break;
 
         case 1:         /* BCLK divider */
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_ACLKXCTL_REG,
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG,
                                ACLKXDIV(div - 1), ACLKXDIV_MASK);
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_ACLKRCTL_REG,
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG,
                                ACLKRDIV(div - 1), ACLKRDIV_MASK);
                 break;
 
         case 2:         /* BCLK/LRCLK ratio */
-                dev->bclk_lrclk_ratio = div;
+                mcasp->bclk_lrclk_ratio = div;
                 break;
 
         default:
@@ -612,22 +393,22 @@ static int davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div
 static int davinci_mcasp_set_sysclk(struct snd_soc_dai *dai, int clk_id,
                                     unsigned int freq, int dir)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(dai);
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 
         if (dir == SND_SOC_CLOCK_OUT) {
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_PDIR_REG, AHCLKX);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
         } else {
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_PDIR_REG, AHCLKX);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
         }
 
         return 0;
 }
 
-static int davinci_config_channel_size(struct davinci_audio_dev *dev,
+static int davinci_config_channel_size(struct davinci_mcasp *mcasp,
                                        int word_length)
 {
         u32 fmt;
@@ -644,71 +425,68 @@ static int davinci_config_channel_size(struct davinci_audio_dev *dev,
          * both left and right channels), so it has to be divided by number of
          * tdm-slots (for I2S - divided by 2).
          */
-        if (dev->bclk_lrclk_ratio)
-                word_length = dev->bclk_lrclk_ratio / dev->tdm_slots;
+        if (mcasp->bclk_lrclk_ratio)
+                word_length = mcasp->bclk_lrclk_ratio / mcasp->tdm_slots;
 
         /* mapping of the XSSZ bit-field as described in the datasheet */
         fmt = (word_length >> 1) - 1;
 
-        if (dev->op_mode != DAVINCI_MCASP_DIT_MODE) {
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMT_REG,
-                                RXSSZ(fmt), RXSSZ(0x0F));
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMT_REG,
-                                TXSSZ(fmt), TXSSZ(0x0F));
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMT_REG,
-                                TXROT(tx_rotate), TXROT(7));
-                mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMT_REG,
-                                RXROT(rx_rotate), RXROT(7));
-                mcasp_set_reg(dev->base + DAVINCI_MCASP_RXMASK_REG,
-                                mask);
+        if (mcasp->op_mode != DAVINCI_MCASP_DIT_MODE) {
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXSSZ(fmt),
+                               RXSSZ(0x0F));
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXSSZ(fmt),
+                               TXSSZ(0x0F));
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(tx_rotate),
+                               TXROT(7));
+                mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXROT(rx_rotate),
+                               RXROT(7));
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_RXMASK_REG, mask);
         }
 
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXMASK_REG, mask);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXMASK_REG, mask);
 
         return 0;
 }
 
-static int davinci_hw_common_param(struct davinci_audio_dev *dev, int stream,
+static int davinci_hw_common_param(struct davinci_mcasp *mcasp, int stream,
                                     int channels)
 {
         int i;
         u8 tx_ser = 0;
         u8 rx_ser = 0;
         u8 ser;
-        u8 slots = dev->tdm_slots;
+        u8 slots = mcasp->tdm_slots;
         u8 max_active_serializers = (channels + slots - 1) / slots;
+        u32 reg;
         /* Default configuration */
-        mcasp_set_bits(dev->base + DAVINCI_MCASP_PWREMUMGT_REG, MCASP_SOFT);
+        if (mcasp->version != MCASP_VERSION_4)
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_PWREMUMGT_REG, MCASP_SOFT);
 
         /* All PINS as McASP */
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_PFUNC_REG, 0x00000000);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_PFUNC_REG, 0x00000000);
 
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                mcasp_set_reg(dev->base + DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_XEVTCTL_REG,
-                                TXDATADMADIS);
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
         } else {
-                mcasp_set_reg(dev->base + DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
-                mcasp_clr_bits(dev->base + DAVINCI_MCASP_REVTCTL_REG,
-                                RXDATADMADIS);
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
+                mcasp_clr_bits(mcasp, DAVINCI_MCASP_REVTCTL_REG, RXDATADMADIS);
         }
 
-        for (i = 0; i < dev->num_serializer; i++) {
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_XRSRCTL_REG(i),
-                                        dev->serial_dir[i]);
-                if (dev->serial_dir[i] == TX_MODE &&
+        for (i = 0; i < mcasp->num_serializer; i++) {
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
+                               mcasp->serial_dir[i]);
+                if (mcasp->serial_dir[i] == TX_MODE &&
                                         tx_ser < max_active_serializers) {
-                        mcasp_set_bits(dev->base + DAVINCI_MCASP_PDIR_REG,
-                                        AXR(i));
+                        mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
                         tx_ser++;
-                } else if (dev->serial_dir[i] == RX_MODE &&
+                } else if (mcasp->serial_dir[i] == RX_MODE &&
                                         rx_ser < max_active_serializers) {
-                        mcasp_clr_bits(dev->base + DAVINCI_MCASP_PDIR_REG,
-                                        AXR(i));
+                        mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
                         rx_ser++;
                 } else {
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_XRSRCTL_REG(i),
-                                        SRMOD_INACTIVE, SRMOD_MASK);
+                        mcasp_mod_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
+                                       SRMOD_INACTIVE, SRMOD_MASK);
                 }
         }
 
@@ -718,127 +496,113 @@ static int davinci_hw_common_param(struct davinci_audio_dev *dev, int stream,
                 ser = rx_ser;
 
         if (ser < max_active_serializers) {
-                dev_warn(dev->dev, "stream has more channels (%d) than are "
+                dev_warn(mcasp->dev, "stream has more channels (%d) than are "
                         "enabled in mcasp (%d)\n", channels, ser * slots);
                 return -EINVAL;
         }
 
-        if (dev->txnumevt && stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                if (dev->txnumevt * tx_ser > 64)
-                        dev->txnumevt = 1;
+        if (mcasp->txnumevt && stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (mcasp->txnumevt * tx_ser > 64)
+                        mcasp->txnumevt = 1;
 
-                switch (dev->version) {
-                case MCASP_VERSION_3:
-                        mcasp_mod_bits(dev->base + MCASP_VER3_WFIFOCTL, tx_ser,
-                                                                NUMDMA_MASK);
-                        mcasp_mod_bits(dev->base + MCASP_VER3_WFIFOCTL,
-                                ((dev->txnumevt * tx_ser) << 8), NUMEVT_MASK);
-                        break;
-                default:
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_WFIFOCTL,
-                                                        tx_ser, NUMDMA_MASK);
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_WFIFOCTL,
-                                ((dev->txnumevt * tx_ser) << 8), NUMEVT_MASK);
-                }
+                reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
+                mcasp_mod_bits(mcasp, reg, tx_ser, NUMDMA_MASK);
+                mcasp_mod_bits(mcasp, reg, ((mcasp->txnumevt * tx_ser) << 8),
+                               NUMEVT_MASK);
         }
 
-        if (dev->rxnumevt && stream == SNDRV_PCM_STREAM_CAPTURE) {
-                if (dev->rxnumevt * rx_ser > 64)
-                        dev->rxnumevt = 1;
-                switch (dev->version) {
-                case MCASP_VERSION_3:
-                        mcasp_mod_bits(dev->base + MCASP_VER3_RFIFOCTL, rx_ser,
-                                                                NUMDMA_MASK);
-                        mcasp_mod_bits(dev->base + MCASP_VER3_RFIFOCTL,
-                                ((dev->rxnumevt * rx_ser) << 8), NUMEVT_MASK);
-                        break;
-                default:
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_RFIFOCTL,
-                                                        rx_ser, NUMDMA_MASK);
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_RFIFOCTL,
-                                ((dev->rxnumevt * rx_ser) << 8), NUMEVT_MASK);
-                }
+        if (mcasp->rxnumevt && stream == SNDRV_PCM_STREAM_CAPTURE) {
+                if (mcasp->rxnumevt * rx_ser > 64)
+                        mcasp->rxnumevt = 1;
+
+                reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
+                mcasp_mod_bits(mcasp, reg, rx_ser, NUMDMA_MASK);
+                mcasp_mod_bits(mcasp, reg, ((mcasp->rxnumevt * rx_ser) << 8),
+                               NUMEVT_MASK);
         }
 
         return 0;
 }
 
-static void davinci_hw_param(struct davinci_audio_dev *dev, int stream)
+static void davinci_hw_param(struct davinci_mcasp *mcasp, int stream)
 {
         int i, active_slots;
         u32 mask = 0;
+        u32 busel = 0;
 
-        active_slots = (dev->tdm_slots > 31) ? 32 : dev->tdm_slots;
+        active_slots = (mcasp->tdm_slots > 31) ? 32 : mcasp->tdm_slots;
         for (i = 0; i < active_slots; i++)
                 mask |= (1 << i);
 
-        mcasp_clr_bits(dev->base + DAVINCI_MCASP_ACLKXCTL_REG, TX_ASYNC);
+        mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, TX_ASYNC);
+
+        if (!mcasp->dat_port)
+                busel = TXSEL;
 
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 /* bit stream is MSB first  with no delay */
                 /* DSP_B mode */
-                mcasp_set_reg(dev->base + DAVINCI_MCASP_TXTDM_REG, mask);
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMT_REG, TXORD);
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, mask);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, busel | TXORD);
 
-                if ((dev->tdm_slots >= 2) && (dev->tdm_slots <= 32))
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMCTL_REG,
-                                        FSXMOD(dev->tdm_slots), FSXMOD(0x1FF));
+                if ((mcasp->tdm_slots >= 2) && (mcasp->tdm_slots <= 32))
+                        mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG,
+                                       FSXMOD(mcasp->tdm_slots), FSXMOD(0x1FF));
                 else
                         printk(KERN_ERR "playback tdm slot %d not supported\n",
-                                dev->tdm_slots);
+                                mcasp->tdm_slots);
         } else {
                 /* bit stream is MSB first with no delay */
                 /* DSP_B mode */
-                mcasp_set_bits(dev->base + DAVINCI_MCASP_RXFMT_REG, RXORD);
-                mcasp_set_reg(dev->base + DAVINCI_MCASP_RXTDM_REG, mask);
+                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, busel | RXORD);
+                mcasp_set_reg(mcasp, DAVINCI_MCASP_RXTDM_REG, mask);
 
-                if ((dev->tdm_slots >= 2) && (dev->tdm_slots <= 32))
-                        mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMCTL_REG,
-                                        FSRMOD(dev->tdm_slots), FSRMOD(0x1FF));
+                if ((mcasp->tdm_slots >= 2) && (mcasp->tdm_slots <= 32))
+                        mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG,
+                                       FSRMOD(mcasp->tdm_slots), FSRMOD(0x1FF));
                 else
                         printk(KERN_ERR "capture tdm slot %d not supported\n",
-                                dev->tdm_slots);
+                                mcasp->tdm_slots);
         }
 }
 
 /* S/PDIF */
-static void davinci_hw_dit_param(struct davinci_audio_dev *dev)
+static void davinci_hw_dit_param(struct davinci_mcasp *mcasp)
 {
         /* Set the TX format : 24 bit right rotation, 32 bit slot, Pad 0
            and LSB first */
-        mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMT_REG,
-                                                TXROT(6) | TXSSZ(15));
+        mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(6) | TXSSZ(15));
 
         /* Set TX frame synch : DIT Mode, 1 bit width, internal, rising edge */
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXFMCTL_REG,
-                                                AFSXE | FSXMOD(0x180));
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE | FSXMOD(0x180));
 
         /* Set the TX tdm : for all the slots */
-        mcasp_set_reg(dev->base + DAVINCI_MCASP_TXTDM_REG, 0xFFFFFFFF);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, 0xFFFFFFFF);
 
         /* Set the TX clock controls : div = 1 and internal */
-        mcasp_set_bits(dev->base + DAVINCI_MCASP_ACLKXCTL_REG,
-                                                ACLKXE | TX_ASYNC);
+        mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE | TX_ASYNC);
 
-        mcasp_clr_bits(dev->base + DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
+        mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
 
         /* Only 44100 and 48000 are valid, both have the same setting */
-        mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXDIV(3));
+        mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXDIV(3));
 
         /* Enable the DIT */
-        mcasp_set_bits(dev->base + DAVINCI_MCASP_TXDITCTL_REG, DITEN);
+        mcasp_set_bits(mcasp, DAVINCI_MCASP_TXDITCTL_REG, DITEN);
 }
 
 static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
                                         struct snd_pcm_hw_params *params,
                                         struct snd_soc_dai *cpu_dai)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
         struct davinci_pcm_dma_params *dma_params =
-                                        &dev->dma_params[substream->stream];
+                                        &mcasp->dma_params[substream->stream];
+        struct snd_dmaengine_dai_dma_data *dma_data =
+                                        &mcasp->dma_data[substream->stream];
         int word_length;
         u8 fifo_level;
-        u8 slots = dev->tdm_slots;
+        u8 slots = mcasp->tdm_slots;
         u8 active_serializers;
         int channels;
         struct snd_interval *pcm_channels = hw_param_interval(params,
@@ -847,17 +611,17 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
 
         active_serializers = (channels + slots - 1) / slots;
 
-        if (davinci_hw_common_param(dev, substream->stream, channels) == -EINVAL)
+        if (davinci_hw_common_param(mcasp, substream->stream, channels) == -EINVAL)
                 return -EINVAL;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                fifo_level = dev->txnumevt * active_serializers;
+                fifo_level = mcasp->txnumevt * active_serializers;
         else
-                fifo_level = dev->rxnumevt * active_serializers;
+                fifo_level = mcasp->rxnumevt * active_serializers;
 
-        if (dev->op_mode == DAVINCI_MCASP_DIT_MODE)
-                davinci_hw_dit_param(dev);
+        if (mcasp->op_mode == DAVINCI_MCASP_DIT_MODE)
+                davinci_hw_dit_param(mcasp);
         else
-                davinci_hw_param(dev, substream->stream);
+                davinci_hw_param(mcasp, substream->stream);
 
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_U8:
@@ -891,13 +655,15 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        if (dev->version == MCASP_VERSION_2 && !fifo_level)
+        if (mcasp->version == MCASP_VERSION_2 && !fifo_level)
                 dma_params->acnt = 4;
         else
                 dma_params->acnt = dma_params->data_type;
 
         dma_params->fifo_level = fifo_level;
-        davinci_config_channel_size(dev, word_length);
+        dma_data->maxburst = fifo_level;
+
+        davinci_config_channel_size(mcasp, word_length);
 
         return 0;
 }
@@ -905,29 +671,29 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
 static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
                                      int cmd, struct snd_soc_dai *cpu_dai)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
         int ret = 0;
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_RESUME:
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                ret = pm_runtime_get_sync(dev->dev);
+                ret = pm_runtime_get_sync(mcasp->dev);
                 if (IS_ERR_VALUE(ret))
-                        dev_err(dev->dev, "pm_runtime_get_sync() failed\n");
-                davinci_mcasp_start(dev, substream->stream);
+                        dev_err(mcasp->dev, "pm_runtime_get_sync() failed\n");
+                davinci_mcasp_start(mcasp, substream->stream);
                 break;
 
         case SNDRV_PCM_TRIGGER_SUSPEND:
-                davinci_mcasp_stop(dev, substream->stream);
-                ret = pm_runtime_put_sync(dev->dev);
+                davinci_mcasp_stop(mcasp, substream->stream);
+                ret = pm_runtime_put_sync(mcasp->dev);
                 if (IS_ERR_VALUE(ret))
-                        dev_err(dev->dev, "pm_runtime_put_sync() failed\n");
+                        dev_err(mcasp->dev, "pm_runtime_put_sync() failed\n");
                 break;
 
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                davinci_mcasp_stop(dev, substream->stream);
+                davinci_mcasp_stop(mcasp, substream->stream);
                 break;
 
         default:
@@ -940,9 +706,14 @@ static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
 static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
                                  struct snd_soc_dai *dai)
 {
-        struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(dai);
+        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
+
+        if (mcasp->version == MCASP_VERSION_4)
+                snd_soc_dai_set_dma_data(dai, substream,
+                                        &mcasp->dma_data[substream->stream]);
+        else
+                snd_soc_dai_set_dma_data(dai, substream, mcasp->dma_params);
 
-        snd_soc_dai_set_dma_data(dai, substream, dev->dma_params);
         return 0;
 }
 
@@ -955,6 +726,8 @@ static const struct snd_soc_dai_ops davinci_mcasp_dai_ops = {
         .set_sysclk     = davinci_mcasp_set_sysclk,
 };
 
+#define DAVINCI_MCASP_RATES     SNDRV_PCM_RATE_8000_192000
+
 #define DAVINCI_MCASP_PCM_FMTS (SNDRV_PCM_FMTBIT_S8 | \
                                 SNDRV_PCM_FMTBIT_U8 | \
                                 SNDRV_PCM_FMTBIT_S16_LE | \
@@ -985,7 +758,7 @@ static struct snd_soc_dai_driver davinci_mcasp_dai[] = {
 
         },
         {
-                "davinci-mcasp.1",
+                .name           = "davinci-mcasp.1",
                 .playback       = {
                         .channels_min   = 1,
                         .channels_max   = 384,
@@ -1016,13 +789,20 @@ static struct snd_platform_data da830_mcasp_pdata = {
         .version = MCASP_VERSION_2,
 };
 
-static struct snd_platform_data omap2_mcasp_pdata = {
+static struct snd_platform_data am33xx_mcasp_pdata = {
         .tx_dma_offset = 0,
         .rx_dma_offset = 0,
         .asp_chan_q = EVENTQ_0,
         .version = MCASP_VERSION_3,
 };
 
+static struct snd_platform_data dra7_mcasp_pdata = {
+        .tx_dma_offset = 0x200,
+        .rx_dma_offset = 0x284,
+        .asp_chan_q = EVENTQ_0,
+        .version = MCASP_VERSION_4,
+};
+
 static const struct of_device_id mcasp_dt_ids[] = {
         {
                 .compatible = "ti,dm646x-mcasp-audio",
@@ -1034,12 +814,56 @@ static const struct of_device_id mcasp_dt_ids[] = {
         },
         {
                 .compatible = "ti,am33xx-mcasp-audio",
-                .data = &omap2_mcasp_pdata,
+                .data = &am33xx_mcasp_pdata,
+        },
+        {
+                .compatible = "ti,dra7-mcasp-audio",
+                .data = &dra7_mcasp_pdata,
         },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, mcasp_dt_ids);
 
+static int mcasp_reparent_fck(struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        struct clk *gfclk, *parent_clk;
+        const char *parent_name;
+        int ret;
+
+        if (!node)
+                return 0;
+
+        parent_name = of_get_property(node, "fck_parent", NULL);
+        if (!parent_name)
+                return 0;
+
+        gfclk = clk_get(&pdev->dev, "fck");
+        if (IS_ERR(gfclk)) {
+                dev_err(&pdev->dev, "failed to get fck\n");
+                return PTR_ERR(gfclk);
+        }
+
+        parent_clk = clk_get(NULL, parent_name);
+        if (IS_ERR(parent_clk)) {
+                dev_err(&pdev->dev, "failed to get parent clock\n");
+                ret = PTR_ERR(parent_clk);
+                goto err1;
+        }
+
+        ret = clk_set_parent(gfclk, parent_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to reparent fck\n");
+                goto err2;
+        }
+
+err2:
+        clk_put(parent_clk);
+err1:
+        clk_put(gfclk);
+        return ret;
+}
+
 static struct snd_platform_data *davinci_mcasp_set_pdata_from_of(
                                                 struct platform_device *pdev)
 {
@@ -1152,7 +976,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         struct davinci_pcm_dma_params *dma_data;
         struct resource *mem, *ioarea, *res, *dat;
         struct snd_platform_data *pdata;
-        struct davinci_audio_dev *dev;
+        struct davinci_mcasp *mcasp;
         int ret;
 
         if (!pdev->dev.platform_data && !pdev->dev.of_node) {
@@ -1160,9 +984,9 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        dev = devm_kzalloc(&pdev->dev, sizeof(struct davinci_audio_dev),
+        mcasp = devm_kzalloc(&pdev->dev, sizeof(struct davinci_mcasp),
                            GFP_KERNEL);
-        if (!dev)
+        if (!mcasp)
                 return  -ENOMEM;
 
         pdata = davinci_mcasp_set_pdata_from_of(pdev);
@@ -1173,7 +997,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
 
         mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mpu");
         if (!mem) {
-                dev_warn(dev->dev,
+                dev_warn(mcasp->dev,
                          "\"mpu\" mem resource not found, using index 0\n");
                 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
                 if (!mem) {
@@ -1197,32 +1021,39 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        dev->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
-        if (!dev->base) {
+        mcasp->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
+        if (!mcasp->base) {
                 dev_err(&pdev->dev, "ioremap failed\n");
                 ret = -ENOMEM;
                 goto err_release_clk;
         }
 
-        dev->op_mode = pdata->op_mode;
-        dev->tdm_slots = pdata->tdm_slots;
-        dev->num_serializer = pdata->num_serializer;
-        dev->serial_dir = pdata->serial_dir;
-        dev->version = pdata->version;
-        dev->txnumevt = pdata->txnumevt;
-        dev->rxnumevt = pdata->rxnumevt;
-        dev->dev = &pdev->dev;
+        mcasp->op_mode = pdata->op_mode;
+        mcasp->tdm_slots = pdata->tdm_slots;
+        mcasp->num_serializer = pdata->num_serializer;
+        mcasp->serial_dir = pdata->serial_dir;
+        mcasp->version = pdata->version;
+        mcasp->txnumevt = pdata->txnumevt;
+        mcasp->rxnumevt = pdata->rxnumevt;
+
+        mcasp->dev = &pdev->dev;
 
         dat = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
-        if (!dat)
-                dat = mem;
+        if (dat)
+                mcasp->dat_port = true;
 
-        dma_data = &dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
+        dma_data = &mcasp->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
         dma_data->asp_chan_q = pdata->asp_chan_q;
         dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->sram_pool = pdata->sram_pool;
         dma_data->sram_size = pdata->sram_size_playback;
-        dma_data->dma_addr = dat->start + pdata->tx_dma_offset;
+        if (dat)
+                dma_data->dma_addr = dat->start;
+        else
+                dma_data->dma_addr = mem->start + pdata->tx_dma_offset;
+
+        /* Unconditional dmaengine stuff */
+        mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK].addr = dma_data->dma_addr;
 
         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
         if (res)
@@ -1230,12 +1061,26 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         else
                 dma_data->channel = pdata->tx_dma_channel;
 
-        dma_data = &dev->dma_params[SNDRV_PCM_STREAM_CAPTURE];
+        dma_data = &mcasp->dma_params[SNDRV_PCM_STREAM_CAPTURE];
         dma_data->asp_chan_q = pdata->asp_chan_q;
         dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->sram_pool = pdata->sram_pool;
         dma_data->sram_size = pdata->sram_size_capture;
-        dma_data->dma_addr = dat->start + pdata->rx_dma_offset;
+        if (dat)
+                dma_data->dma_addr = dat->start;
+        else
+                dma_data->dma_addr = mem->start + pdata->rx_dma_offset;
+
+        /* Unconditional dmaengine stuff */
+        mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE].addr = dma_data->dma_addr;
+
+        if (mcasp->version < MCASP_VERSION_3) {
+                mcasp->fifo_base = DAVINCI_MCASP_V2_AFIFO_BASE;
+                /* dma_data->dma_addr is pointing to the data port address */
+                mcasp->dat_port = true;
+        } else {
+                mcasp->fifo_base = DAVINCI_MCASP_V3_AFIFO_BASE;
+        }
 
         res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
         if (res)
@@ -1243,17 +1088,26 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         else
                 dma_data->channel = pdata->rx_dma_channel;
 
-        dev_set_drvdata(&pdev->dev, dev);
+        /* Unconditional dmaengine stuff */
+        mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK].filter_data = "tx";
+        mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE].filter_data = "rx";
+
+        dev_set_drvdata(&pdev->dev, mcasp);
+
+        mcasp_reparent_fck(pdev);
+
         ret = snd_soc_register_component(&pdev->dev, &davinci_mcasp_component,
                                          &davinci_mcasp_dai[pdata->op_mode], 1);
 
         if (ret != 0)
                 goto err_release_clk;
 
-        ret = davinci_soc_platform_register(&pdev->dev);
-        if (ret) {
-                dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
-                goto err_unregister_component;
+        if (mcasp->version != MCASP_VERSION_4) {
+                ret = davinci_soc_platform_register(&pdev->dev);
+                if (ret) {
+                        dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
+                        goto err_unregister_component;
+                }
         }
 
         return 0;
@@ -1268,9 +1122,11 @@ err_release_clk:
 
 static int davinci_mcasp_remove(struct platform_device *pdev)
 {
+        struct davinci_mcasp *mcasp = dev_get_drvdata(&pdev->dev);
 
         snd_soc_unregister_component(&pdev->dev);
-        davinci_soc_platform_unregister(&pdev->dev);
+        if (mcasp->version != MCASP_VERSION_4)
+                davinci_soc_platform_unregister(&pdev->dev);
 
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
@@ -1281,32 +1137,30 @@ static int davinci_mcasp_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM_SLEEP
 static int davinci_mcasp_suspend(struct device *dev)
 {
-        struct davinci_audio_dev *a = dev_get_drvdata(dev);
-        void __iomem *base = a->base;
+        struct davinci_mcasp *mcasp = dev_get_drvdata(dev);
 
-        a->context.txfmtctl = mcasp_get_reg(base + DAVINCI_MCASP_TXFMCTL_REG);
-        a->context.rxfmtctl = mcasp_get_reg(base + DAVINCI_MCASP_RXFMCTL_REG);
-        a->context.txfmt = mcasp_get_reg(base + DAVINCI_MCASP_TXFMT_REG);
-        a->context.rxfmt = mcasp_get_reg(base + DAVINCI_MCASP_RXFMT_REG);
-        a->context.aclkxctl = mcasp_get_reg(base + DAVINCI_MCASP_ACLKXCTL_REG);
-        a->context.aclkrctl = mcasp_get_reg(base + DAVINCI_MCASP_ACLKRCTL_REG);
-        a->context.pdir = mcasp_get_reg(base + DAVINCI_MCASP_PDIR_REG);
+        mcasp->context.txfmtctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_TXFMCTL_REG);
+        mcasp->context.rxfmtctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXFMCTL_REG);
+        mcasp->context.txfmt = mcasp_get_reg(mcasp, DAVINCI_MCASP_TXFMT_REG);
+        mcasp->context.rxfmt = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXFMT_REG);
+        mcasp->context.aclkxctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_ACLKXCTL_REG);
+        mcasp->context.aclkrctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_ACLKRCTL_REG);
+        mcasp->context.pdir = mcasp_get_reg(mcasp, DAVINCI_MCASP_PDIR_REG);
 
         return 0;
 }
 
 static int davinci_mcasp_resume(struct device *dev)
 {
-        struct davinci_audio_dev *a = dev_get_drvdata(dev);
-        void __iomem *base = a->base;
-
-        mcasp_set_reg(base + DAVINCI_MCASP_TXFMCTL_REG, a->context.txfmtctl);
-        mcasp_set_reg(base + DAVINCI_MCASP_RXFMCTL_REG, a->context.rxfmtctl);
-        mcasp_set_reg(base + DAVINCI_MCASP_TXFMT_REG, a->context.txfmt);
-        mcasp_set_reg(base + DAVINCI_MCASP_RXFMT_REG, a->context.rxfmt);
-        mcasp_set_reg(base + DAVINCI_MCASP_ACLKXCTL_REG, a->context.aclkxctl);
-        mcasp_set_reg(base + DAVINCI_MCASP_ACLKRCTL_REG, a->context.aclkrctl);
-        mcasp_set_reg(base + DAVINCI_MCASP_PDIR_REG, a->context.pdir);
+        struct davinci_mcasp *mcasp = dev_get_drvdata(dev);
+
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXFMCTL_REG, mcasp->context.txfmtctl);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXFMCTL_REG, mcasp->context.rxfmtctl);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXFMT_REG, mcasp->context.txfmt);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXFMT_REG, mcasp->context.rxfmt);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, mcasp->context.aclkxctl);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, mcasp->context.aclkrctl);
+        mcasp_set_reg(mcasp, DAVINCI_MCASP_PDIR_REG, mcasp->context.pdir);
 
         return 0;
 }
diff --git a/sound/soc/davinci/davinci-mcasp.h b/sound/soc/davinci/davinci-mcasp.h
index a2e27e1c32f3..8fed757d6087 100644
--- a/sound/soc/davinci/davinci-mcasp.h
+++ b/sound/soc/davinci/davinci-mcasp.h
@@ -18,43 +18,271 @@
 #ifndef DAVINCI_MCASP_H
 #define DAVINCI_MCASP_H
 
-#include <linux/io.h>
-#include <linux/platform_data/davinci_asp.h>
-
-#include "davinci-pcm.h"
-
-#define DAVINCI_MCASP_RATES     SNDRV_PCM_RATE_8000_192000
-#define DAVINCI_MCASP_I2S_DAI   0
-#define DAVINCI_MCASP_DIT_DAI   1
-
-struct davinci_audio_dev {
-        struct davinci_pcm_dma_params dma_params[2];
-        void __iomem *base;
-        struct device *dev;
-
-        /* McASP specific data */
-        int     tdm_slots;
-        u8      op_mode;
-        u8      num_serializer;
-        u8      *serial_dir;
-        u8      version;
-        u16     bclk_lrclk_ratio;
-
-        /* McASP FIFO related */
-        u8      txnumevt;
-        u8      rxnumevt;
-
-#ifdef CONFIG_PM_SLEEP
-        struct {
-                u32     txfmtctl;
-                u32     rxfmtctl;
-                u32     txfmt;
-                u32     rxfmt;
-                u32     aclkxctl;
-                u32     aclkrctl;
-                u32     pdir;
-        } context;
-#endif
-};
+/*
+ * McASP register definitions
+ */
+#define DAVINCI_MCASP_PID_REG           0x00
+#define DAVINCI_MCASP_PWREMUMGT_REG     0x04
+
+#define DAVINCI_MCASP_PFUNC_REG         0x10
+#define DAVINCI_MCASP_PDIR_REG          0x14
+#define DAVINCI_MCASP_PDOUT_REG         0x18
+#define DAVINCI_MCASP_PDSET_REG         0x1c
+
+#define DAVINCI_MCASP_PDCLR_REG         0x20
+
+#define DAVINCI_MCASP_TLGC_REG          0x30
+#define DAVINCI_MCASP_TLMR_REG          0x34
+
+#define DAVINCI_MCASP_GBLCTL_REG        0x44
+#define DAVINCI_MCASP_AMUTE_REG         0x48
+#define DAVINCI_MCASP_LBCTL_REG         0x4c
+
+#define DAVINCI_MCASP_TXDITCTL_REG      0x50
+
+#define DAVINCI_MCASP_GBLCTLR_REG       0x60
+#define DAVINCI_MCASP_RXMASK_REG        0x64
+#define DAVINCI_MCASP_RXFMT_REG         0x68
+#define DAVINCI_MCASP_RXFMCTL_REG       0x6c
+
+#define DAVINCI_MCASP_ACLKRCTL_REG      0x70
+#define DAVINCI_MCASP_AHCLKRCTL_REG     0x74
+#define DAVINCI_MCASP_RXTDM_REG         0x78
+#define DAVINCI_MCASP_EVTCTLR_REG       0x7c
+
+#define DAVINCI_MCASP_RXSTAT_REG        0x80
+#define DAVINCI_MCASP_RXTDMSLOT_REG     0x84
+#define DAVINCI_MCASP_RXCLKCHK_REG      0x88
+#define DAVINCI_MCASP_REVTCTL_REG       0x8c
+
+#define DAVINCI_MCASP_GBLCTLX_REG       0xa0
+#define DAVINCI_MCASP_TXMASK_REG        0xa4
+#define DAVINCI_MCASP_TXFMT_REG         0xa8
+#define DAVINCI_MCASP_TXFMCTL_REG       0xac
+
+#define DAVINCI_MCASP_ACLKXCTL_REG      0xb0
+#define DAVINCI_MCASP_AHCLKXCTL_REG     0xb4
+#define DAVINCI_MCASP_TXTDM_REG         0xb8
+#define DAVINCI_MCASP_EVTCTLX_REG       0xbc
+
+#define DAVINCI_MCASP_TXSTAT_REG        0xc0
+#define DAVINCI_MCASP_TXTDMSLOT_REG     0xc4
+#define DAVINCI_MCASP_TXCLKCHK_REG      0xc8
+#define DAVINCI_MCASP_XEVTCTL_REG       0xcc
+
+/* Left(even TDM Slot) Channel Status Register File */
+#define DAVINCI_MCASP_DITCSRA_REG       0x100
+/* Right(odd TDM slot) Channel Status Register File */
+#define DAVINCI_MCASP_DITCSRB_REG       0x118
+/* Left(even TDM slot) User Data Register File */
+#define DAVINCI_MCASP_DITUDRA_REG       0x130
+/* Right(odd TDM Slot) User Data Register File */
+#define DAVINCI_MCASP_DITUDRB_REG       0x148
+
+/* Serializer n Control Register */
+#define DAVINCI_MCASP_XRSRCTL_BASE_REG  0x180
+#define DAVINCI_MCASP_XRSRCTL_REG(n)    (DAVINCI_MCASP_XRSRCTL_BASE_REG + \
+                                                (n << 2))
+
+/* Transmit Buffer for Serializer n */
+#define DAVINCI_MCASP_TXBUF_REG         0x200
+/* Receive Buffer for Serializer n */
+#define DAVINCI_MCASP_RXBUF_REG         0x280
+
+/* McASP FIFO Registers */
+#define DAVINCI_MCASP_V2_AFIFO_BASE     (0x1010)
+#define DAVINCI_MCASP_V3_AFIFO_BASE     (0x1000)
+
+/* FIFO register offsets from AFIFO base */
+#define MCASP_WFIFOCTL_OFFSET           (0x0)
+#define MCASP_WFIFOSTS_OFFSET           (0x4)
+#define MCASP_RFIFOCTL_OFFSET           (0x8)
+#define MCASP_RFIFOSTS_OFFSET           (0xc)
+
+/*
+ * DAVINCI_MCASP_PWREMUMGT_REG - Power Down and Emulation Management
+ *     Register Bits
+ */
+#define MCASP_FREE      BIT(0)
+#define MCASP_SOFT      BIT(1)
+
+/*
+ * DAVINCI_MCASP_PFUNC_REG - Pin Function / GPIO Enable Register Bits
+ */
+#define AXR(n)          (1<<n)
+#define PFUNC_AMUTE     BIT(25)
+#define ACLKX           BIT(26)
+#define AHCLKX          BIT(27)
+#define AFSX            BIT(28)
+#define ACLKR           BIT(29)
+#define AHCLKR          BIT(30)
+#define AFSR            BIT(31)
+
+/*
+ * DAVINCI_MCASP_PDIR_REG - Pin Direction Register Bits
+ */
+#define AXR(n)          (1<<n)
+#define PDIR_AMUTE      BIT(25)
+#define ACLKX           BIT(26)
+#define AHCLKX          BIT(27)
+#define AFSX            BIT(28)
+#define ACLKR           BIT(29)
+#define AHCLKR          BIT(30)
+#define AFSR            BIT(31)
+
+/*
+ * DAVINCI_MCASP_TXDITCTL_REG - Transmit DIT Control Register Bits
+ */
+#define DITEN   BIT(0)  /* Transmit DIT mode enable/disable */
+#define VA      BIT(2)
+#define VB      BIT(3)
+
+/*
+ * DAVINCI_MCASP_TXFMT_REG - Transmit Bitstream Format Register Bits
+ */
+#define TXROT(val)      (val)
+#define TXSEL           BIT(3)
+#define TXSSZ(val)      (val<<4)
+#define TXPBIT(val)     (val<<8)
+#define TXPAD(val)      (val<<13)
+#define TXORD           BIT(15)
+#define FSXDLY(val)     (val<<16)
+
+/*
+ * DAVINCI_MCASP_RXFMT_REG - Receive Bitstream Format Register Bits
+ */
+#define RXROT(val)      (val)
+#define RXSEL           BIT(3)
+#define RXSSZ(val)      (val<<4)
+#define RXPBIT(val)     (val<<8)
+#define RXPAD(val)      (val<<13)
+#define RXORD           BIT(15)
+#define FSRDLY(val)     (val<<16)
+
+/*
+ * DAVINCI_MCASP_TXFMCTL_REG -  Transmit Frame Control Register Bits
+ */
+#define FSXPOL          BIT(0)
+#define AFSXE           BIT(1)
+#define FSXDUR          BIT(4)
+#define FSXMOD(val)     (val<<7)
+
+/*
+ * DAVINCI_MCASP_RXFMCTL_REG - Receive Frame Control Register Bits
+ */
+#define FSRPOL          BIT(0)
+#define AFSRE           BIT(1)
+#define FSRDUR          BIT(4)
+#define FSRMOD(val)     (val<<7)
+
+/*
+ * DAVINCI_MCASP_ACLKXCTL_REG - Transmit Clock Control Register Bits
+ */
+#define ACLKXDIV(val)   (val)
+#define ACLKXE          BIT(5)
+#define TX_ASYNC        BIT(6)
+#define ACLKXPOL        BIT(7)
+#define ACLKXDIV_MASK   0x1f
+
+/*
+ * DAVINCI_MCASP_ACLKRCTL_REG Receive Clock Control Register Bits
+ */
+#define ACLKRDIV(val)   (val)
+#define ACLKRE          BIT(5)
+#define RX_ASYNC        BIT(6)
+#define ACLKRPOL        BIT(7)
+#define ACLKRDIV_MASK   0x1f
+
+/*
+ * DAVINCI_MCASP_AHCLKXCTL_REG - High Frequency Transmit Clock Control
+ *     Register Bits
+ */
+#define AHCLKXDIV(val)  (val)
+#define AHCLKXPOL       BIT(14)
+#define AHCLKXE         BIT(15)
+#define AHCLKXDIV_MASK  0xfff
+
+/*
+ * DAVINCI_MCASP_AHCLKRCTL_REG - High Frequency Receive Clock Control
+ *     Register Bits
+ */
+#define AHCLKRDIV(val)  (val)
+#define AHCLKRPOL       BIT(14)
+#define AHCLKRE         BIT(15)
+#define AHCLKRDIV_MASK  0xfff
+
+/*
+ * DAVINCI_MCASP_XRSRCTL_BASE_REG -  Serializer Control Register Bits
+ */
+#define MODE(val)       (val)
+#define DISMOD          (val)(val<<2)
+#define TXSTATE         BIT(4)
+#define RXSTATE         BIT(5)
+#define SRMOD_MASK      3
+#define SRMOD_INACTIVE  0
+
+/*
+ * DAVINCI_MCASP_LBCTL_REG - Loop Back Control Register Bits
+ */
+#define LBEN            BIT(0)
+#define LBORD           BIT(1)
+#define LBGENMODE(val)  (val<<2)
+
+/*
+ * DAVINCI_MCASP_TXTDMSLOT_REG - Transmit TDM Slot Register configuration
+ */
+#define TXTDMS(n)       (1<<n)
+
+/*
+ * DAVINCI_MCASP_RXTDMSLOT_REG - Receive TDM Slot Register configuration
+ */
+#define RXTDMS(n)       (1<<n)
+
+/*
+ * DAVINCI_MCASP_GBLCTL_REG -  Global Control Register Bits
+ */
+#define RXCLKRST        BIT(0)  /* Receiver Clock Divider Reset */
+#define RXHCLKRST       BIT(1)  /* Receiver High Frequency Clock Divider */
+#define RXSERCLR        BIT(2)  /* Receiver Serializer Clear */
+#define RXSMRST         BIT(3)  /* Receiver State Machine Reset */
+#define RXFSRST         BIT(4)  /* Frame Sync Generator Reset */
+#define TXCLKRST        BIT(8)  /* Transmitter Clock Divider Reset */
+#define TXHCLKRST       BIT(9)  /* Transmitter High Frequency Clock Divider*/
+#define TXSERCLR        BIT(10) /* Transmit Serializer Clear */
+#define TXSMRST         BIT(11) /* Transmitter State Machine Reset */
+#define TXFSRST         BIT(12) /* Frame Sync Generator Reset */
+
+/*
+ * DAVINCI_MCASP_AMUTE_REG -  Mute Control Register Bits
+ */
+#define MUTENA(val)     (val)
+#define MUTEINPOL       BIT(2)
+#define MUTEINENA       BIT(3)
+#define MUTEIN          BIT(4)
+#define MUTER           BIT(5)
+#define MUTEX           BIT(6)
+#define MUTEFSR         BIT(7)
+#define MUTEFSX         BIT(8)
+#define MUTEBADCLKR     BIT(9)
+#define MUTEBADCLKX     BIT(10)
+#define MUTERXDMAERR    BIT(11)
+#define MUTETXDMAERR    BIT(12)
+
+/*
+ * DAVINCI_MCASP_REVTCTL_REG - Receiver DMA Event Control Register bits
+ */
+#define RXDATADMADIS    BIT(0)
+
+/*
+ * DAVINCI_MCASP_XEVTCTL_REG - Transmitter DMA Event Control Register bits
+ */
+#define TXDATADMADIS    BIT(0)
+
+/*
+ * DAVINCI_MCASP_W[R]FIFOCTL - Write/Read FIFO Control Register bits
+ */
+#define FIFO_ENABLE     BIT(16)
+#define NUMEVT_MASK     (0xFF << 8)
+#define NUMDMA_MASK     (0xFF)
 
 #endif  /* DAVINCI_MCASP_H */
diff --git a/sound/soc/davinci/davinci-pcm.c b/sound/soc/davinci/davinci-pcm.c
index fb5d107f5603..14145cdf8a11 100644
--- a/sound/soc/davinci/davinci-pcm.c
+++ b/sound/soc/davinci/davinci-pcm.c
@@ -46,33 +46,11 @@ static void print_buf_info(int slot, char *name)
 }
 #endif
 
-#define DAVINCI_PCM_FMTBITS     (\
-                                SNDRV_PCM_FMTBIT_S8     |\
-                                SNDRV_PCM_FMTBIT_U8     |\
-                                SNDRV_PCM_FMTBIT_S16_LE |\
-                                SNDRV_PCM_FMTBIT_S16_BE |\
-                                SNDRV_PCM_FMTBIT_U16_LE |\
-                                SNDRV_PCM_FMTBIT_U16_BE |\
-                                SNDRV_PCM_FMTBIT_S24_LE |\
-                                SNDRV_PCM_FMTBIT_S24_BE |\
-                                SNDRV_PCM_FMTBIT_U24_LE |\
-                                SNDRV_PCM_FMTBIT_U24_BE |\
-                                SNDRV_PCM_FMTBIT_S32_LE |\
-                                SNDRV_PCM_FMTBIT_S32_BE |\
-                                SNDRV_PCM_FMTBIT_U32_LE |\
-                                SNDRV_PCM_FMTBIT_U32_BE)
-
 static struct snd_pcm_hardware pcm_hardware_playback = {
         .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME|
                  SNDRV_PCM_INFO_BATCH),
-        .formats = DAVINCI_PCM_FMTBITS,
-        .rates = SNDRV_PCM_RATE_8000_192000 | SNDRV_PCM_RATE_KNOT,
-        .rate_min = 8000,
-        .rate_max = 192000,
-        .channels_min = 2,
-        .channels_max = 384,
         .buffer_bytes_max = 128 * 1024,
         .period_bytes_min = 32,
         .period_bytes_max = 8 * 1024,
@@ -86,12 +64,6 @@ static struct snd_pcm_hardware pcm_hardware_capture = {
                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                  SNDRV_PCM_INFO_PAUSE |
                  SNDRV_PCM_INFO_BATCH),
-        .formats = DAVINCI_PCM_FMTBITS,
-        .rates = SNDRV_PCM_RATE_8000_192000 | SNDRV_PCM_RATE_KNOT,
-        .rate_min = 8000,
-        .rate_max = 192000,
-        .channels_min = 2,
-        .channels_max = 384,
         .buffer_bytes_max = 128 * 1024,
         .period_bytes_min = 32,
         .period_bytes_max = 8 * 1024,
diff --git a/sound/soc/fsl/Kconfig b/sound/soc/fsl/Kconfig
index b7ab71f2ccc1..514c275c6108 100644
--- a/sound/soc/fsl/Kconfig
+++ b/sound/soc/fsl/Kconfig
@@ -1,3 +1,7 @@
+config SND_SOC_FSL_SAI
+        tristate
+        select SND_SOC_GENERIC_DMAENGINE_PCM
+
 config SND_SOC_FSL_SSI
         tristate
 
@@ -197,7 +201,6 @@ config SND_SOC_IMX_SPDIF
         tristate "SoC Audio support for i.MX boards with S/PDIF"
         select SND_SOC_IMX_PCM_DMA
         select SND_SOC_FSL_SPDIF
-        select SND_SOC_SPDIF
         select REGMAP_MMIO
         help
           SoC Audio support for i.MX boards with S/PDIF
diff --git a/sound/soc/fsl/Makefile b/sound/soc/fsl/Makefile
index 8db705b0fdf9..aaccbee17006 100644
--- a/sound/soc/fsl/Makefile
+++ b/sound/soc/fsl/Makefile
@@ -10,11 +10,13 @@ obj-$(CONFIG_SND_SOC_P1022_DS) += snd-soc-p1022-ds.o
 snd-soc-p1022-rdk-objs := p1022_rdk.o
 obj-$(CONFIG_SND_SOC_P1022_RDK) += snd-soc-p1022-rdk.o
 
-# Freescale PowerPC SSI/DMA Platform Support
+# Freescale SSI/DMA/SAI/SPDIF Support
+snd-soc-fsl-sai-objs := fsl_sai.o
 snd-soc-fsl-ssi-objs := fsl_ssi.o
 snd-soc-fsl-spdif-objs := fsl_spdif.o
 snd-soc-fsl-utils-objs := fsl_utils.o
 snd-soc-fsl-dma-objs := fsl_dma.o
+obj-$(CONFIG_SND_SOC_FSL_SAI) += snd-soc-fsl-sai.o
 obj-$(CONFIG_SND_SOC_FSL_SSI) += snd-soc-fsl-ssi.o
 obj-$(CONFIG_SND_SOC_FSL_SPDIF) += snd-soc-fsl-spdif.o
 obj-$(CONFIG_SND_SOC_FSL_UTILS) += snd-soc-fsl-utils.o
diff --git a/sound/soc/fsl/fsl_dma.c b/sound/soc/fsl/fsl_dma.c
index fb9bb9eb5ca3..d570f8c81dc6 100644
--- a/sound/soc/fsl/fsl_dma.c
+++ b/sound/soc/fsl/fsl_dma.c
@@ -852,7 +852,7 @@ static void fsl_dma_free_dma_buffers(struct snd_pcm *pcm)
 }
 
 /**
- * find_ssi_node -- returns the SSI node that points to his DMA channel node
+ * find_ssi_node -- returns the SSI node that points to its DMA channel node
  *
  * Although this DMA driver attempts to operate independently of the other
  * devices, it still needs to determine some information about the SSI device
diff --git a/sound/soc/fsl/fsl_sai.c b/sound/soc/fsl/fsl_sai.c
new file mode 100644
index 000000000000..5d38a6749b9f
--- /dev/null
+++ b/sound/soc/fsl/fsl_sai.c
@@ -0,0 +1,460 @@
+/*
+ * Freescale ALSA SoC Digital Audio Interface (SAI) driver.
+ *
+ * Copyright 2012-2013 Freescale Semiconductor, Inc.
+ *
+ * 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/clk.h>
+#include <linux/delay.h>
+#include <linux/dmaengine.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/dmaengine_pcm.h>
+#include <sound/pcm_params.h>
+
+#include "fsl_sai.h"
+
+static inline u32 sai_readl(struct fsl_sai *sai,
+                const void __iomem *addr)
+{
+        u32 val;
+
+        val = __raw_readl(addr);
+
+        if (likely(sai->big_endian_regs))
+                val = be32_to_cpu(val);
+        else
+                val = le32_to_cpu(val);
+        rmb();
+
+        return val;
+}
+
+static inline void sai_writel(struct fsl_sai *sai,
+                u32 val, void __iomem *addr)
+{
+        wmb();
+        if (likely(sai->big_endian_regs))
+                val = cpu_to_be32(val);
+        else
+                val = cpu_to_le32(val);
+
+        __raw_writel(val, addr);
+}
+
+static int fsl_sai_set_dai_sysclk_tr(struct snd_soc_dai *cpu_dai,
+                int clk_id, unsigned int freq, int fsl_dir)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        u32 val_cr2, reg_cr2;
+
+        if (fsl_dir == FSL_FMT_TRANSMITTER)
+                reg_cr2 = FSL_SAI_TCR2;
+        else
+                reg_cr2 = FSL_SAI_RCR2;
+
+        val_cr2 = sai_readl(sai, sai->base + reg_cr2);
+        switch (clk_id) {
+        case FSL_SAI_CLK_BUS:
+                val_cr2 &= ~FSL_SAI_CR2_MSEL_MASK;
+                val_cr2 |= FSL_SAI_CR2_MSEL_BUS;
+                break;
+        case FSL_SAI_CLK_MAST1:
+                val_cr2 &= ~FSL_SAI_CR2_MSEL_MASK;
+                val_cr2 |= FSL_SAI_CR2_MSEL_MCLK1;
+                break;
+        case FSL_SAI_CLK_MAST2:
+                val_cr2 &= ~FSL_SAI_CR2_MSEL_MASK;
+                val_cr2 |= FSL_SAI_CR2_MSEL_MCLK2;
+                break;
+        case FSL_SAI_CLK_MAST3:
+                val_cr2 &= ~FSL_SAI_CR2_MSEL_MASK;
+                val_cr2 |= FSL_SAI_CR2_MSEL_MCLK3;
+                break;
+        default:
+                return -EINVAL;
+        }
+        sai_writel(sai, val_cr2, sai->base + reg_cr2);
+
+        return 0;
+}
+
+static int fsl_sai_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        int ret;
+
+        if (dir == SND_SOC_CLOCK_IN)
+                return 0;
+
+        ret = clk_prepare_enable(sai->clk);
+        if (ret)
+                return ret;
+
+        ret = fsl_sai_set_dai_sysclk_tr(cpu_dai, clk_id, freq,
+                                        FSL_FMT_TRANSMITTER);
+        if (ret) {
+                dev_err(cpu_dai->dev, "Cannot set tx sysclk: %d\n", ret);
+                goto err_clk;
+        }
+
+        ret = fsl_sai_set_dai_sysclk_tr(cpu_dai, clk_id, freq,
+                                        FSL_FMT_RECEIVER);
+        if (ret) {
+                dev_err(cpu_dai->dev, "Cannot set rx sysclk: %d\n", ret);
+                goto err_clk;
+        }
+
+err_clk:
+        clk_disable_unprepare(sai->clk);
+
+        return ret;
+}
+
+static int fsl_sai_set_dai_fmt_tr(struct snd_soc_dai *cpu_dai,
+                                unsigned int fmt, int fsl_dir)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        u32 val_cr2, val_cr4, reg_cr2, reg_cr4;
+
+        if (fsl_dir == FSL_FMT_TRANSMITTER) {
+                reg_cr2 = FSL_SAI_TCR2;
+                reg_cr4 = FSL_SAI_TCR4;
+        } else {
+                reg_cr2 = FSL_SAI_RCR2;
+                reg_cr4 = FSL_SAI_RCR4;
+        }
+
+        val_cr2 = sai_readl(sai, sai->base + reg_cr2);
+        val_cr4 = sai_readl(sai, sai->base + reg_cr4);
+
+        if (sai->big_endian_data)
+                val_cr4 &= ~FSL_SAI_CR4_MF;
+        else
+                val_cr4 |= FSL_SAI_CR4_MF;
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                val_cr4 |= FSL_SAI_CR4_FSE;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_IB_IF:
+                val_cr4 |= FSL_SAI_CR4_FSP;
+                val_cr2 &= ~FSL_SAI_CR2_BCP;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                val_cr4 &= ~FSL_SAI_CR4_FSP;
+                val_cr2 &= ~FSL_SAI_CR2_BCP;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                val_cr4 |= FSL_SAI_CR4_FSP;
+                val_cr2 |= FSL_SAI_CR2_BCP;
+                break;
+        case SND_SOC_DAIFMT_NB_NF:
+                val_cr4 &= ~FSL_SAI_CR4_FSP;
+                val_cr2 |= FSL_SAI_CR2_BCP;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                val_cr2 |= FSL_SAI_CR2_BCD_MSTR;
+                val_cr4 |= FSL_SAI_CR4_FSD_MSTR;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                val_cr2 &= ~FSL_SAI_CR2_BCD_MSTR;
+                val_cr4 &= ~FSL_SAI_CR4_FSD_MSTR;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        sai_writel(sai, val_cr2, sai->base + reg_cr2);
+        sai_writel(sai, val_cr4, sai->base + reg_cr4);
+
+        return 0;
+}
+
+static int fsl_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        int ret;
+
+        ret = clk_prepare_enable(sai->clk);
+        if (ret)
+                return ret;
+
+        ret = fsl_sai_set_dai_fmt_tr(cpu_dai, fmt, FSL_FMT_TRANSMITTER);
+        if (ret) {
+                dev_err(cpu_dai->dev, "Cannot set tx format: %d\n", ret);
+                goto err_clk;
+        }
+
+        ret = fsl_sai_set_dai_fmt_tr(cpu_dai, fmt, FSL_FMT_RECEIVER);
+        if (ret) {
+                dev_err(cpu_dai->dev, "Cannot set rx format: %d\n", ret);
+                goto err_clk;
+        }
+
+err_clk:
+        clk_disable_unprepare(sai->clk);
+
+        return ret;
+}
+
+static int fsl_sai_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params,
+                struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        u32 val_cr4, val_cr5, val_mr, reg_cr4, reg_cr5, reg_mr;
+        unsigned int channels = params_channels(params);
+        u32 word_width = snd_pcm_format_width(params_format(params));
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                reg_cr4 = FSL_SAI_TCR4;
+                reg_cr5 = FSL_SAI_TCR5;
+                reg_mr = FSL_SAI_TMR;
+        } else {
+                reg_cr4 = FSL_SAI_RCR4;
+                reg_cr5 = FSL_SAI_RCR5;
+                reg_mr = FSL_SAI_RMR;
+        }
+
+        val_cr4 = sai_readl(sai, sai->base + reg_cr4);
+        val_cr4 &= ~FSL_SAI_CR4_SYWD_MASK;
+        val_cr4 &= ~FSL_SAI_CR4_FRSZ_MASK;
+
+        val_cr5 = sai_readl(sai, sai->base + reg_cr5);
+        val_cr5 &= ~FSL_SAI_CR5_WNW_MASK;
+        val_cr5 &= ~FSL_SAI_CR5_W0W_MASK;
+        val_cr5 &= ~FSL_SAI_CR5_FBT_MASK;
+
+        val_cr4 |= FSL_SAI_CR4_SYWD(word_width);
+        val_cr5 |= FSL_SAI_CR5_WNW(word_width);
+        val_cr5 |= FSL_SAI_CR5_W0W(word_width);
+
+        val_cr5 &= ~FSL_SAI_CR5_FBT_MASK;
+        if (sai->big_endian_data)
+                val_cr5 |= FSL_SAI_CR5_FBT(0);
+        else
+                val_cr5 |= FSL_SAI_CR5_FBT(word_width - 1);
+
+        val_cr4 |= FSL_SAI_CR4_FRSZ(channels);
+        val_mr = ~0UL - ((1 << channels) - 1);
+
+        sai_writel(sai, val_cr4, sai->base + reg_cr4);
+        sai_writel(sai, val_cr5, sai->base + reg_cr5);
+        sai_writel(sai, val_mr, sai->base + reg_mr);
+
+        return 0;
+}
+
+static int fsl_sai_trigger(struct snd_pcm_substream *substream, int cmd,
+                struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+        u32 tcsr, rcsr, val_cr2, val_cr3, reg_cr3;
+
+        val_cr2 = sai_readl(sai, sai->base + FSL_SAI_TCR2);
+        val_cr2 &= ~FSL_SAI_CR2_SYNC;
+        sai_writel(sai, val_cr2, sai->base + FSL_SAI_TCR2);
+
+        val_cr2 = sai_readl(sai, sai->base + FSL_SAI_RCR2);
+        val_cr2 |= FSL_SAI_CR2_SYNC;
+        sai_writel(sai, val_cr2, sai->base + FSL_SAI_RCR2);
+
+        tcsr = sai_readl(sai, sai->base + FSL_SAI_TCSR);
+        rcsr = sai_readl(sai, sai->base + FSL_SAI_RCSR);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                tcsr |= FSL_SAI_CSR_FRDE;
+                rcsr &= ~FSL_SAI_CSR_FRDE;
+                reg_cr3 = FSL_SAI_TCR3;
+        } else {
+                rcsr |= FSL_SAI_CSR_FRDE;
+                tcsr &= ~FSL_SAI_CSR_FRDE;
+                reg_cr3 = FSL_SAI_RCR3;
+        }
+
+        val_cr3 = sai_readl(sai, sai->base + reg_cr3);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                tcsr |= FSL_SAI_CSR_TERE;
+                rcsr |= FSL_SAI_CSR_TERE;
+                val_cr3 |= FSL_SAI_CR3_TRCE;
+
+                sai_writel(sai, val_cr3, sai->base + reg_cr3);
+                sai_writel(sai, rcsr, sai->base + FSL_SAI_RCSR);
+                sai_writel(sai, tcsr, sai->base + FSL_SAI_TCSR);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                if (!(cpu_dai->playback_active || cpu_dai->capture_active)) {
+                        tcsr &= ~FSL_SAI_CSR_TERE;
+                        rcsr &= ~FSL_SAI_CSR_TERE;
+                }
+
+                val_cr3 &= ~FSL_SAI_CR3_TRCE;
+
+                sai_writel(sai, tcsr, sai->base + FSL_SAI_TCSR);
+                sai_writel(sai, rcsr, sai->base + FSL_SAI_RCSR);
+                sai_writel(sai, val_cr3, sai->base + reg_cr3);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int fsl_sai_startup(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+
+        return clk_prepare_enable(sai->clk);
+}
+
+static void fsl_sai_shutdown(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_sai *sai = snd_soc_dai_get_drvdata(cpu_dai);
+
+        clk_disable_unprepare(sai->clk);
+}
+
+static const struct snd_soc_dai_ops fsl_sai_pcm_dai_ops = {
+        .set_sysclk     = fsl_sai_set_dai_sysclk,
+        .set_fmt        = fsl_sai_set_dai_fmt,
+        .hw_params      = fsl_sai_hw_params,
+        .trigger        = fsl_sai_trigger,
+        .startup        = fsl_sai_startup,
+        .shutdown       = fsl_sai_shutdown,
+};
+
+static int fsl_sai_dai_probe(struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_sai *sai = dev_get_drvdata(cpu_dai->dev);
+        int ret;
+
+        ret = clk_prepare_enable(sai->clk);
+        if (ret)
+                return ret;
+
+        sai_writel(sai, 0x0, sai->base + FSL_SAI_RCSR);
+        sai_writel(sai, 0x0, sai->base + FSL_SAI_TCSR);
+        sai_writel(sai, FSL_SAI_MAXBURST_TX * 2, sai->base + FSL_SAI_TCR1);
+        sai_writel(sai, FSL_SAI_MAXBURST_RX - 1, sai->base + FSL_SAI_RCR1);
+
+        clk_disable_unprepare(sai->clk);
+
+        snd_soc_dai_init_dma_data(cpu_dai, &sai->dma_params_tx,
+                                &sai->dma_params_rx);
+
+        snd_soc_dai_set_drvdata(cpu_dai, sai);
+
+        return 0;
+}
+
+static struct snd_soc_dai_driver fsl_sai_dai = {
+        .probe = fsl_sai_dai_probe,
+        .playback = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = FSL_SAI_FORMATS,
+        },
+        .capture = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = FSL_SAI_FORMATS,
+        },
+        .ops = &fsl_sai_pcm_dai_ops,
+};
+
+static const struct snd_soc_component_driver fsl_component = {
+        .name           = "fsl-sai",
+};
+
+static int fsl_sai_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct fsl_sai *sai;
+        struct resource *res;
+        int ret;
+
+        sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL);
+        if (!sai)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        sai->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(sai->base))
+                return PTR_ERR(sai->base);
+
+        sai->clk = devm_clk_get(&pdev->dev, "sai");
+        if (IS_ERR(sai->clk)) {
+                dev_err(&pdev->dev, "Cannot get SAI's clock\n");
+                return PTR_ERR(sai->clk);
+        }
+
+        sai->dma_params_rx.addr = res->start + FSL_SAI_RDR;
+        sai->dma_params_tx.addr = res->start + FSL_SAI_TDR;
+        sai->dma_params_rx.maxburst = FSL_SAI_MAXBURST_RX;
+        sai->dma_params_tx.maxburst = FSL_SAI_MAXBURST_TX;
+
+        sai->big_endian_regs = of_property_read_bool(np, "big-endian-regs");
+        sai->big_endian_data = of_property_read_bool(np, "big-endian-data");
+
+        platform_set_drvdata(pdev, sai);
+
+        ret = devm_snd_soc_register_component(&pdev->dev, &fsl_component,
+                        &fsl_sai_dai, 1);
+        if (ret)
+                return ret;
+
+        return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
+                        SND_DMAENGINE_PCM_FLAG_NO_RESIDUE);
+}
+
+static const struct of_device_id fsl_sai_ids[] = {
+        { .compatible = "fsl,vf610-sai", },
+        { /* sentinel */ }
+};
+
+static struct platform_driver fsl_sai_driver = {
+        .probe = fsl_sai_probe,
+        .driver = {
+                .name = "fsl-sai",
+                .owner = THIS_MODULE,
+                .of_match_table = fsl_sai_ids,
+        },
+};
+module_platform_driver(fsl_sai_driver);
+
+MODULE_DESCRIPTION("Freescale Soc SAI Interface");
+MODULE_AUTHOR("Xiubo Li, <Li.Xiubo@freescale.com>");
+MODULE_ALIAS("platform:fsl-sai");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/fsl/fsl_sai.h b/sound/soc/fsl/fsl_sai.h
new file mode 100644
index 000000000000..41bb62e69361
--- /dev/null
+++ b/sound/soc/fsl/fsl_sai.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2012-2013 Freescale Semiconductor, 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 __FSL_SAI_H
+#define __FSL_SAI_H
+
+#include <sound/dmaengine_pcm.h>
+
+#define FSL_SAI_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
+                         SNDRV_PCM_FMTBIT_S20_3LE |\
+                         SNDRV_PCM_FMTBIT_S24_LE)
+
+/* SAI Transmit/Recieve Control Register */
+#define FSL_SAI_TCSR            0x00
+#define FSL_SAI_RCSR            0x80
+#define FSL_SAI_CSR_TERE        BIT(31)
+#define FSL_SAI_CSR_FWF         BIT(17)
+#define FSL_SAI_CSR_FRIE        BIT(8)
+#define FSL_SAI_CSR_FRDE        BIT(0)
+
+/* SAI Transmit Data/FIFO/MASK Register */
+#define FSL_SAI_TDR             0x20
+#define FSL_SAI_TFR             0x40
+#define FSL_SAI_TMR             0x60
+
+/* SAI Recieve Data/FIFO/MASK Register */
+#define FSL_SAI_RDR             0xa0
+#define FSL_SAI_RFR             0xc0
+#define FSL_SAI_RMR             0xe0
+
+/* SAI Transmit and Recieve Configuration 1 Register */
+#define FSL_SAI_TCR1            0x04
+#define FSL_SAI_RCR1            0x84
+
+/* SAI Transmit and Recieve Configuration 2 Register */
+#define FSL_SAI_TCR2            0x08
+#define FSL_SAI_RCR2            0x88
+#define FSL_SAI_CR2_SYNC        BIT(30)
+#define FSL_SAI_CR2_MSEL_MASK   (0xff << 26)
+#define FSL_SAI_CR2_MSEL_BUS    0
+#define FSL_SAI_CR2_MSEL_MCLK1  BIT(26)
+#define FSL_SAI_CR2_MSEL_MCLK2  BIT(27)
+#define FSL_SAI_CR2_MSEL_MCLK3  (BIT(26) | BIT(27))
+#define FSL_SAI_CR2_BCP         BIT(25)
+#define FSL_SAI_CR2_BCD_MSTR    BIT(24)
+
+/* SAI Transmit and Recieve Configuration 3 Register */
+#define FSL_SAI_TCR3            0x0c
+#define FSL_SAI_RCR3            0x8c
+#define FSL_SAI_CR3_TRCE        BIT(16)
+#define FSL_SAI_CR3_WDFL(x)     (x)
+#define FSL_SAI_CR3_WDFL_MASK   0x1f
+
+/* SAI Transmit and Recieve Configuration 4 Register */
+#define FSL_SAI_TCR4            0x10
+#define FSL_SAI_RCR4            0x90
+#define FSL_SAI_CR4_FRSZ(x)     (((x) - 1) << 16)
+#define FSL_SAI_CR4_FRSZ_MASK   (0x1f << 16)
+#define FSL_SAI_CR4_SYWD(x)     (((x) - 1) << 8)
+#define FSL_SAI_CR4_SYWD_MASK   (0x1f << 8)
+#define FSL_SAI_CR4_MF          BIT(4)
+#define FSL_SAI_CR4_FSE         BIT(3)
+#define FSL_SAI_CR4_FSP         BIT(1)
+#define FSL_SAI_CR4_FSD_MSTR    BIT(0)
+
+/* SAI Transmit and Recieve Configuration 5 Register */
+#define FSL_SAI_TCR5            0x14
+#define FSL_SAI_RCR5            0x94
+#define FSL_SAI_CR5_WNW(x)      (((x) - 1) << 24)
+#define FSL_SAI_CR5_WNW_MASK    (0x1f << 24)
+#define FSL_SAI_CR5_W0W(x)      (((x) - 1) << 16)
+#define FSL_SAI_CR5_W0W_MASK    (0x1f << 16)
+#define FSL_SAI_CR5_FBT(x)      ((x) << 8)
+#define FSL_SAI_CR5_FBT_MASK    (0x1f << 8)
+
+/* SAI type */
+#define FSL_SAI_DMA             BIT(0)
+#define FSL_SAI_USE_AC97        BIT(1)
+#define FSL_SAI_NET             BIT(2)
+#define FSL_SAI_TRA_SYN         BIT(3)
+#define FSL_SAI_REC_SYN         BIT(4)
+#define FSL_SAI_USE_I2S_SLAVE   BIT(5)
+
+#define FSL_FMT_TRANSMITTER     0
+#define FSL_FMT_RECEIVER        1
+
+/* SAI clock sources */
+#define FSL_SAI_CLK_BUS         0
+#define FSL_SAI_CLK_MAST1       1
+#define FSL_SAI_CLK_MAST2       2
+#define FSL_SAI_CLK_MAST3       3
+
+/* SAI data transfer numbers per DMA request */
+#define FSL_SAI_MAXBURST_TX 6
+#define FSL_SAI_MAXBURST_RX 6
+
+struct fsl_sai {
+        struct clk *clk;
+
+        void __iomem *base;
+
+        bool big_endian_regs;
+        bool big_endian_data;
+
+        struct snd_dmaengine_dai_dma_data dma_params_rx;
+        struct snd_dmaengine_dai_dma_data dma_params_tx;
+};
+
+#endif /* __FSL_SAI_H */
diff --git a/sound/soc/fsl/fsl_spdif.c b/sound/soc/fsl/fsl_spdif.c
index 55193a5596ca..4d075f1abe78 100644
--- a/sound/soc/fsl/fsl_spdif.c
+++ b/sound/soc/fsl/fsl_spdif.c
@@ -1181,13 +1181,6 @@ static int fsl_spdif_probe(struct platform_device *pdev)
         return ret;
 }
 
-static int fsl_spdif_remove(struct platform_device *pdev)
-{
-        imx_pcm_dma_exit(pdev);
-
-        return 0;
-}
-
 static const struct of_device_id fsl_spdif_dt_ids[] = {
         { .compatible = "fsl,imx35-spdif", },
         {}
@@ -1201,7 +1194,6 @@ static struct platform_driver fsl_spdif_driver = {
                 .of_match_table = fsl_spdif_dt_ids,
         },
         .probe = fsl_spdif_probe,
-        .remove = fsl_spdif_remove,
 };
 
 module_platform_driver(fsl_spdif_driver);
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 35e277379b86..b2ebaf811599 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -38,6 +38,7 @@
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
+#include <linux/spinlock.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
@@ -119,8 +120,6 @@ static inline void write_ssi_mask(u32 __iomem *addr, u32 clear, u32 set)
  * @ssi: pointer to the SSI's registers
  * @ssi_phys: physical address of the SSI registers
  * @irq: IRQ of this SSI
- * @first_stream: pointer to the stream that was opened first
- * @second_stream: pointer to second stream
  * @playback: the number of playback streams opened
  * @capture: the number of capture streams opened
  * @cpu_dai: the CPU DAI for this device
@@ -132,8 +131,6 @@ struct fsl_ssi_private {
         struct ccsr_ssi __iomem *ssi;
         dma_addr_t ssi_phys;
         unsigned int irq;
-        struct snd_pcm_substream *first_stream;
-        struct snd_pcm_substream *second_stream;
         unsigned int fifo_depth;
         struct snd_soc_dai_driver cpu_dai_drv;
         struct device_attribute dev_attr;
@@ -143,6 +140,10 @@ struct fsl_ssi_private {
         bool ssi_on_imx;
         bool imx_ac97;
         bool use_dma;
+        bool baudclk_locked;
+        u8 i2s_mode;
+        spinlock_t baudclk_lock;
+        struct clk *baudclk;
         struct clk *clk;
         struct snd_dmaengine_dai_dma_data dma_params_tx;
         struct snd_dmaengine_dai_dma_data dma_params_rx;
@@ -321,17 +322,46 @@ static irqreturn_t fsl_ssi_isr(int irq, void *dev_id)
         return ret;
 }
 
+static void fsl_ssi_setup_ac97(struct fsl_ssi_private *ssi_private)
+{
+        struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
+
+        /*
+         * Setup the clock control register
+         */
+        write_ssi(CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13),
+                        &ssi->stccr);
+        write_ssi(CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13),
+                        &ssi->srccr);
+
+        /*
+         * Enable AC97 mode and startup the SSI
+         */
+        write_ssi(CCSR_SSI_SACNT_AC97EN | CCSR_SSI_SACNT_FV,
+                        &ssi->sacnt);
+        write_ssi(0xff, &ssi->saccdis);
+        write_ssi(0x300, &ssi->saccen);
+
+        /*
+         * Enable SSI, Transmit and Receive. AC97 has to communicate with the
+         * codec before a stream is started.
+         */
+        write_ssi_mask(&ssi->scr, 0, CCSR_SSI_SCR_SSIEN |
+                        CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE);
+
+        write_ssi(CCSR_SSI_SOR_WAIT(3), &ssi->sor);
+}
+
 static int fsl_ssi_setup(struct fsl_ssi_private *ssi_private)
 {
         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
-        u8 i2s_mode;
         u8 wm;
         int synchronous = ssi_private->cpu_dai_drv.symmetric_rates;
 
         if (ssi_private->imx_ac97)
-                i2s_mode = CCSR_SSI_SCR_I2S_MODE_NORMAL | CCSR_SSI_SCR_NET;
+                ssi_private->i2s_mode = CCSR_SSI_SCR_I2S_MODE_NORMAL | CCSR_SSI_SCR_NET;
         else
-                i2s_mode = CCSR_SSI_SCR_I2S_MODE_SLAVE;
+                ssi_private->i2s_mode = CCSR_SSI_SCR_I2S_MODE_SLAVE;
 
         /*
          * Section 16.5 of the MPC8610 reference manual says that the SSI needs
@@ -348,7 +378,7 @@ static int fsl_ssi_setup(struct fsl_ssi_private *ssi_private)
         write_ssi_mask(&ssi->scr,
                 CCSR_SSI_SCR_I2S_MODE_MASK | CCSR_SSI_SCR_SYN,
                 CCSR_SSI_SCR_TFR_CLK_DIS |
-                i2s_mode |
+                ssi_private->i2s_mode |
                 (synchronous ? CCSR_SSI_SCR_SYN : 0));
 
         write_ssi(CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFEN0 |
@@ -387,31 +417,8 @@ static int fsl_ssi_setup(struct fsl_ssi_private *ssi_private)
          * because it is also running without an active substream. Normally SSI
          * is only enabled when there is a substream.
          */
-        if (ssi_private->imx_ac97) {
-                /*
-                 * Setup the clock control register
-                 */
-                write_ssi(CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13),
-                                &ssi->stccr);
-                write_ssi(CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13),
-                                &ssi->srccr);
-
-                /*
-                 * Enable AC97 mode and startup the SSI
-                 */
-                write_ssi(CCSR_SSI_SACNT_AC97EN | CCSR_SSI_SACNT_FV,
-                                &ssi->sacnt);
-                write_ssi(0xff, &ssi->saccdis);
-                write_ssi(0x300, &ssi->saccen);
-
-                /*
-                 * Enable SSI, Transmit and Receive
-                 */
-                write_ssi_mask(&ssi->scr, 0, CCSR_SSI_SCR_SSIEN |
-                                CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE);
-
-                write_ssi(CCSR_SSI_SOR_WAIT(3), &ssi->sor);
-        }
+        if (ssi_private->imx_ac97)
+                fsl_ssi_setup_ac97(ssi_private);
 
         return 0;
 }
@@ -431,53 +438,17 @@ static int fsl_ssi_startup(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct fsl_ssi_private *ssi_private =
                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
-        int synchronous = ssi_private->cpu_dai_drv.symmetric_rates;
+        unsigned long flags;
 
-        /*
-         * If this is the first stream opened, then request the IRQ
-         * and initialize the SSI registers.
+        /* First, we only do fsl_ssi_setup() when SSI is going to be active.
+         * Second, fsl_ssi_setup was already called by ac97_init earlier if
+         * the driver is in ac97 mode.
          */
-        if (!ssi_private->first_stream) {
-                ssi_private->first_stream = substream;
-
-                /*
-                 * fsl_ssi_setup was already called by ac97_init earlier if
-                 * the driver is in ac97 mode.
-                 */
-                if (!ssi_private->imx_ac97)
-                        fsl_ssi_setup(ssi_private);
-        } else {
-                if (synchronous) {
-                        struct snd_pcm_runtime *first_runtime =
-                                ssi_private->first_stream->runtime;
-                        /*
-                         * This is the second stream open, and we're in
-                         * synchronous mode, so we need to impose sample
-                         * sample size constraints. This is because STCCR is
-                         * used for playback and capture in synchronous mode,
-                         * so there's no way to specify different word
-                         * lengths.
-                         *
-                         * Note that this can cause a race condition if the
-                         * second stream is opened before the first stream is
-                         * fully initialized.  We provide some protection by
-                         * checking to make sure the first stream is
-                         * initialized, but it's not perfect.  ALSA sometimes
-                         * re-initializes the driver with a different sample
-                         * rate or size.  If the second stream is opened
-                         * before the first stream has received its final
-                         * parameters, then the second stream may be
-                         * constrained to the wrong sample rate or size.
-                         */
-                        if (first_runtime->sample_bits) {
-                                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                                SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
-                                first_runtime->sample_bits,
-                                first_runtime->sample_bits);
-                        }
-                }
-
-                ssi_private->second_stream = substream;
+        if (!dai->active && !ssi_private->imx_ac97) {
+                fsl_ssi_setup(ssi_private);
+                spin_lock_irqsave(&ssi_private->baudclk_lock, flags);
+                ssi_private->baudclk_locked = false;
+                spin_unlock_irqrestore(&ssi_private->baudclk_lock, flags);
         }
 
         return 0;
@@ -501,6 +472,7 @@ static int fsl_ssi_hw_params(struct snd_pcm_substream *substream,
 {
         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
+        unsigned int channels = params_channels(hw_params);
         unsigned int sample_size =
                 snd_pcm_format_width(params_format(hw_params));
         u32 wl = CCSR_SSI_SxCCR_WL(sample_size);
@@ -530,6 +502,248 @@ static int fsl_ssi_hw_params(struct snd_pcm_substream *substream,
         else
                 write_ssi_mask(&ssi->srccr, CCSR_SSI_SxCCR_WL_MASK, wl);
 
+        if (!ssi_private->imx_ac97)
+                write_ssi_mask(&ssi->scr,
+                                CCSR_SSI_SCR_NET | CCSR_SSI_SCR_I2S_MODE_MASK,
+                                channels == 1 ? 0 : ssi_private->i2s_mode);
+
+        return 0;
+}
+
+/**
+ * fsl_ssi_set_dai_fmt - configure Digital Audio Interface Format.
+ */
+static int fsl_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
+{
+        struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
+        struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
+        u32 strcr = 0, stcr, srcr, scr, mask;
+
+        scr = read_ssi(&ssi->scr) & ~(CCSR_SSI_SCR_SYN | CCSR_SSI_SCR_I2S_MODE_MASK);
+        scr |= CCSR_SSI_SCR_NET;
+
+        mask = CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR |
+                CCSR_SSI_STCR_TSCKP | CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TFSL |
+                CCSR_SSI_STCR_TEFS;
+        stcr = read_ssi(&ssi->stcr) & ~mask;
+        srcr = read_ssi(&ssi->srcr) & ~mask;
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+                case SND_SOC_DAIFMT_CBS_CFS:
+                        ssi_private->i2s_mode = CCSR_SSI_SCR_I2S_MODE_MASTER;
+                        break;
+                case SND_SOC_DAIFMT_CBM_CFM:
+                        ssi_private->i2s_mode = CCSR_SSI_SCR_I2S_MODE_SLAVE;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                scr |= ssi_private->i2s_mode;
+
+                /* Data on rising edge of bclk, frame low, 1clk before data */
+                strcr |= CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TSCKP |
+                        CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                /* Data on rising edge of bclk, frame high */
+                strcr |= CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TSCKP;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                /* Data on rising edge of bclk, frame high, 1clk before data */
+                strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
+                        CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                /* Data on rising edge of bclk, frame high */
+                strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
+                        CCSR_SSI_STCR_TXBIT0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* DAI clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                /* Nothing to do for both normal cases */
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                /* Invert bit clock */
+                strcr ^= CCSR_SSI_STCR_TSCKP;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                /* Invert frame clock */
+                strcr ^= CCSR_SSI_STCR_TFSI;
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                /* Invert both clocks */
+                strcr ^= CCSR_SSI_STCR_TSCKP;
+                strcr ^= CCSR_SSI_STCR_TFSI;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* DAI clock master masks */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                strcr |= CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR;
+                scr |= CCSR_SSI_SCR_SYS_CLK_EN;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        stcr |= strcr;
+        srcr |= strcr;
+
+        if (ssi_private->cpu_dai_drv.symmetric_rates) {
+                /* Need to clear RXDIR when using SYNC mode */
+                srcr &= ~CCSR_SSI_SRCR_RXDIR;
+                scr |= CCSR_SSI_SCR_SYN;
+        }
+
+        write_ssi(stcr, &ssi->stcr);
+        write_ssi(srcr, &ssi->srcr);
+        write_ssi(scr, &ssi->scr);
+
+        return 0;
+}
+
+/**
+ * fsl_ssi_set_dai_sysclk - configure Digital Audio Interface bit clock
+ *
+ * Note: This function can be only called when using SSI as DAI master
+ *
+ * Quick instruction for parameters:
+ * freq: Output BCLK frequency = samplerate * 32 (fixed) * channels
+ * dir: SND_SOC_CLOCK_OUT -> TxBCLK, SND_SOC_CLOCK_IN -> RxBCLK.
+ */
+static int fsl_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
+                                  int clk_id, unsigned int freq, int dir)
+{
+        struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
+        struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
+        int synchronous = ssi_private->cpu_dai_drv.symmetric_rates, ret;
+        u32 pm = 999, div2, psr, stccr, mask, afreq, factor, i;
+        unsigned long flags, clkrate, baudrate, tmprate;
+        u64 sub, savesub = 100000;
+
+        /* Don't apply it to any non-baudclk circumstance */
+        if (IS_ERR(ssi_private->baudclk))
+                return -EINVAL;
+
+        /* It should be already enough to divide clock by setting pm alone */
+        psr = 0;
+        div2 = 0;
+
+        factor = (div2 + 1) * (7 * psr + 1) * 2;
+
+        for (i = 0; i < 255; i++) {
+                /* The bclk rate must be smaller than 1/5 sysclk rate */
+                if (factor * (i + 1) < 5)
+                        continue;
+
+                tmprate = freq * factor * (i + 2);
+                clkrate = clk_round_rate(ssi_private->baudclk, tmprate);
+
+                do_div(clkrate, factor);
+                afreq = (u32)clkrate / (i + 1);
+
+                if (freq == afreq)
+                        sub = 0;
+                else if (freq / afreq == 1)
+                        sub = freq - afreq;
+                else if (afreq / freq == 1)
+                        sub = afreq - freq;
+                else
+                        continue;
+
+                /* Calculate the fraction */
+                sub *= 100000;
+                do_div(sub, freq);
+
+                if (sub < savesub) {
+                        baudrate = tmprate;
+                        savesub = sub;
+                        pm = i;
+                }
+
+                /* We are lucky */
+                if (savesub == 0)
+                        break;
+        }
+
+        /* No proper pm found if it is still remaining the initial value */
+        if (pm == 999) {
+                dev_err(cpu_dai->dev, "failed to handle the required sysclk\n");
+                return -EINVAL;
+        }
+
+        stccr = CCSR_SSI_SxCCR_PM(pm + 1) | (div2 ? CCSR_SSI_SxCCR_DIV2 : 0) |
+                (psr ? CCSR_SSI_SxCCR_PSR : 0);
+        mask = CCSR_SSI_SxCCR_PM_MASK | CCSR_SSI_SxCCR_DIV2 | CCSR_SSI_SxCCR_PSR;
+
+        if (dir == SND_SOC_CLOCK_OUT || synchronous)
+                write_ssi_mask(&ssi->stccr, mask, stccr);
+        else
+                write_ssi_mask(&ssi->srccr, mask, stccr);
+
+        spin_lock_irqsave(&ssi_private->baudclk_lock, flags);
+        if (!ssi_private->baudclk_locked) {
+                ret = clk_set_rate(ssi_private->baudclk, baudrate);
+                if (ret) {
+                        spin_unlock_irqrestore(&ssi_private->baudclk_lock, flags);
+                        dev_err(cpu_dai->dev, "failed to set baudclk rate\n");
+                        return -EINVAL;
+                }
+                ssi_private->baudclk_locked = true;
+        }
+        spin_unlock_irqrestore(&ssi_private->baudclk_lock, flags);
+
+        return 0;
+}
+
+/**
+ * fsl_ssi_set_dai_tdm_slot - set TDM slot number
+ *
+ * Note: This function can be only called when using SSI as DAI master
+ */
+static int fsl_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
+                                u32 rx_mask, int slots, int slot_width)
+{
+        struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
+        struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
+        u32 val;
+
+        /* The slot number should be >= 2 if using Network mode or I2S mode */
+        val = read_ssi(&ssi->scr) & (CCSR_SSI_SCR_I2S_MODE_MASK | CCSR_SSI_SCR_NET);
+        if (val && slots < 2) {
+                dev_err(cpu_dai->dev, "slot number should be >= 2 in I2S or NET\n");
+                return -EINVAL;
+        }
+
+        write_ssi_mask(&ssi->stccr, CCSR_SSI_SxCCR_DC_MASK,
+                        CCSR_SSI_SxCCR_DC(slots));
+        write_ssi_mask(&ssi->srccr, CCSR_SSI_SxCCR_DC_MASK,
+                        CCSR_SSI_SxCCR_DC(slots));
+
+        /* The register SxMSKs needs SSI to provide essential clock due to
+         * hardware design. So we here temporarily enable SSI to set them.
+         */
+        val = read_ssi(&ssi->scr) & CCSR_SSI_SCR_SSIEN;
+        write_ssi_mask(&ssi->scr, 0, CCSR_SSI_SCR_SSIEN);
+
+        write_ssi(tx_mask, &ssi->stmsk);
+        write_ssi(rx_mask, &ssi->srmsk);
+
+        write_ssi_mask(&ssi->scr, CCSR_SSI_SCR_SSIEN, val);
+
         return 0;
 }
 
@@ -549,6 +763,7 @@ static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(rtd->cpu_dai);
         struct ccsr_ssi __iomem *ssi = ssi_private->ssi;
         unsigned int sier_bits;
+        unsigned long flags;
 
         /*
          *  Enable only the interrupts and DMA requests
@@ -589,8 +804,12 @@ static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
                         write_ssi_mask(&ssi->scr, CCSR_SSI_SCR_RE, 0);
 
                 if (!ssi_private->imx_ac97 && (read_ssi(&ssi->scr) &
-                                        (CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE)) == 0)
+                                        (CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE)) == 0) {
                         write_ssi_mask(&ssi->scr, CCSR_SSI_SCR_SSIEN, 0);
+                        spin_lock_irqsave(&ssi_private->baudclk_lock, flags);
+                        ssi_private->baudclk_locked = false;
+                        spin_unlock_irqrestore(&ssi_private->baudclk_lock, flags);
+                }
                 break;
 
         default:
@@ -602,23 +821,6 @@ static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
         return 0;
 }
 
-/**
- * fsl_ssi_shutdown: shutdown the SSI
- *
- * Shutdown the SSI if there are no other substreams open.
- */
-static void fsl_ssi_shutdown(struct snd_pcm_substream *substream,
-                             struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(rtd->cpu_dai);
-
-        if (ssi_private->first_stream == substream)
-                ssi_private->first_stream = ssi_private->second_stream;
-
-        ssi_private->second_stream = NULL;
-}
-
 static int fsl_ssi_dai_probe(struct snd_soc_dai *dai)
 {
         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(dai);
@@ -634,7 +836,9 @@ static int fsl_ssi_dai_probe(struct snd_soc_dai *dai)
 static const struct snd_soc_dai_ops fsl_ssi_dai_ops = {
         .startup        = fsl_ssi_startup,
         .hw_params      = fsl_ssi_hw_params,
-        .shutdown       = fsl_ssi_shutdown,
+        .set_fmt        = fsl_ssi_set_dai_fmt,
+        .set_sysclk     = fsl_ssi_set_dai_sysclk,
+        .set_tdm_slot   = fsl_ssi_set_dai_tdm_slot,
         .trigger        = fsl_ssi_trigger,
 };
 
@@ -642,14 +846,13 @@ static const struct snd_soc_dai_ops fsl_ssi_dai_ops = {
 static struct snd_soc_dai_driver fsl_ssi_dai_template = {
         .probe = fsl_ssi_dai_probe,
         .playback = {
-                /* The SSI does not support monaural audio. */
-                .channels_min = 2,
+                .channels_min = 1,
                 .channels_max = 2,
                 .rates = FSLSSI_I2S_RATES,
                 .formats = FSLSSI_I2S_FORMATS,
         },
         .capture = {
-                .channels_min = 2,
+                .channels_min = 1,
                 .channels_max = 2,
                 .rates = FSLSSI_I2S_RATES,
                 .formats = FSLSSI_I2S_FORMATS,
@@ -710,7 +913,6 @@ static int fsl_ssi_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
 
 static const struct snd_soc_dai_ops fsl_ssi_ac97_dai_ops = {
         .startup        = fsl_ssi_startup,
-        .shutdown       = fsl_ssi_shutdown,
         .trigger        = fsl_ssi_ac97_trigger,
 };
 
@@ -935,8 +1137,11 @@ static int fsl_ssi_probe(struct platform_device *pdev)
         }
 
         /* Are the RX and the TX clocks locked? */
-        if (!of_find_property(np, "fsl,ssi-asynchronous", NULL))
+        if (!of_find_property(np, "fsl,ssi-asynchronous", NULL)) {
                 ssi_private->cpu_dai_drv.symmetric_rates = 1;
+                ssi_private->cpu_dai_drv.symmetric_channels = 1;
+                ssi_private->cpu_dai_drv.symmetric_samplebits = 1;
+        }
 
         /* Determine the FIFO depth. */
         iprop = of_get_property(np, "fsl,fifo-depth", NULL);
@@ -946,6 +1151,9 @@ static int fsl_ssi_probe(struct platform_device *pdev)
                 /* Older 8610 DTs didn't have the fifo-depth property */
                 ssi_private->fifo_depth = 8;
 
+        ssi_private->baudclk_locked = false;
+        spin_lock_init(&ssi_private->baudclk_lock);
+
         if (of_device_is_compatible(pdev->dev.of_node, "fsl,imx21-ssi")) {
                 u32 dma_events[2];
                 ssi_private->ssi_on_imx = true;
@@ -963,6 +1171,15 @@ static int fsl_ssi_probe(struct platform_device *pdev)
                         goto error_irqmap;
                 }
 
+                /* For those SLAVE implementations, we ingore non-baudclk cases
+                 * and, instead, abandon MASTER mode that needs baud clock.
+                 */
+                ssi_private->baudclk = devm_clk_get(&pdev->dev, "baud");
+                if (IS_ERR(ssi_private->baudclk))
+                        dev_warn(&pdev->dev, "could not get baud clock: %d\n", ret);
+                else
+                        clk_prepare_enable(ssi_private->baudclk);
+
                 /*
                  * We have burstsize be "fifo_depth - 2" to match the SSI
                  * watermark setting in fsl_ssi_startup().
@@ -1102,16 +1319,17 @@ done:
         return 0;
 
 error_dai:
-        if (ssi_private->ssi_on_imx)
-                imx_pcm_dma_exit(pdev);
         snd_soc_unregister_component(&pdev->dev);
 
 error_dev:
         device_remove_file(&pdev->dev, dev_attr);
 
 error_clk:
-        if (ssi_private->ssi_on_imx)
+        if (ssi_private->ssi_on_imx) {
+                if (!IS_ERR(ssi_private->baudclk))
+                        clk_disable_unprepare(ssi_private->baudclk);
                 clk_disable_unprepare(ssi_private->clk);
+        }
 
 error_irqmap:
         irq_dispose_mapping(ssi_private->irq);
@@ -1125,12 +1343,13 @@ static int fsl_ssi_remove(struct platform_device *pdev)
 
         if (!ssi_private->new_binding)
                 platform_device_unregister(ssi_private->pdev);
-        if (ssi_private->ssi_on_imx)
-                imx_pcm_dma_exit(pdev);
         snd_soc_unregister_component(&pdev->dev);
         device_remove_file(&pdev->dev, &ssi_private->dev_attr);
-        if (ssi_private->ssi_on_imx)
+        if (ssi_private->ssi_on_imx) {
+                if (!IS_ERR(ssi_private->baudclk))
+                        clk_disable_unprepare(ssi_private->baudclk);
                 clk_disable_unprepare(ssi_private->clk);
+        }
         irq_dispose_mapping(ssi_private->irq);
 
         return 0;
diff --git a/sound/soc/fsl/fsl_ssi.h b/sound/soc/fsl/fsl_ssi.h
index e6b9a69e2a68..e6b63240a3d7 100644
--- a/sound/soc/fsl/fsl_ssi.h
+++ b/sound/soc/fsl/fsl_ssi.h
@@ -125,7 +125,9 @@ struct ccsr_ssi {
 #define CCSR_SSI_SRCR_REFS              0x00000001
 
 /* STCCR and SRCCR */
+#define CCSR_SSI_SxCCR_DIV2_SHIFT       18
 #define CCSR_SSI_SxCCR_DIV2             0x00040000
+#define CCSR_SSI_SxCCR_PSR_SHIFT        17
 #define CCSR_SSI_SxCCR_PSR              0x00020000
 #define CCSR_SSI_SxCCR_WL_SHIFT         13
 #define CCSR_SSI_SxCCR_WL_MASK          0x0001E000
diff --git a/sound/soc/fsl/imx-pcm-dma.c b/sound/soc/fsl/imx-pcm-dma.c
index aee23077080a..c5e47f866b4b 100644
--- a/sound/soc/fsl/imx-pcm-dma.c
+++ b/sound/soc/fsl/imx-pcm-dma.c
@@ -61,16 +61,11 @@ static const struct snd_dmaengine_pcm_config imx_dmaengine_pcm_config = {
 
 int imx_pcm_dma_init(struct platform_device *pdev)
 {
-        return snd_dmaengine_pcm_register(&pdev->dev, &imx_dmaengine_pcm_config,
+        return devm_snd_dmaengine_pcm_register(&pdev->dev,
+                &imx_dmaengine_pcm_config,
                 SND_DMAENGINE_PCM_FLAG_NO_RESIDUE |
                 SND_DMAENGINE_PCM_FLAG_COMPAT);
 }
 EXPORT_SYMBOL_GPL(imx_pcm_dma_init);
 
-void imx_pcm_dma_exit(struct platform_device *pdev)
-{
-        snd_dmaengine_pcm_unregister(&pdev->dev);
-}
-EXPORT_SYMBOL_GPL(imx_pcm_dma_exit);
-
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/fsl/imx-pcm.h b/sound/soc/fsl/imx-pcm.h
index 5d5b73303e11..c79cb27473be 100644
--- a/sound/soc/fsl/imx-pcm.h
+++ b/sound/soc/fsl/imx-pcm.h
@@ -40,16 +40,11 @@ struct imx_pcm_fiq_params {
 
 #if IS_ENABLED(CONFIG_SND_SOC_IMX_PCM_DMA)
 int imx_pcm_dma_init(struct platform_device *pdev);
-void imx_pcm_dma_exit(struct platform_device *pdev);
 #else
 static inline int imx_pcm_dma_init(struct platform_device *pdev)
 {
         return -ENODEV;
 }
-
-static inline void imx_pcm_dma_exit(struct platform_device *pdev)
-{
-}
 #endif
 
 #if IS_ENABLED(CONFIG_SND_SOC_IMX_PCM_FIQ)
diff --git a/sound/soc/fsl/imx-spdif.c b/sound/soc/fsl/imx-spdif.c
index 8499d5292f08..e1dc40143600 100644
--- a/sound/soc/fsl/imx-spdif.c
+++ b/sound/soc/fsl/imx-spdif.c
@@ -14,17 +14,15 @@
 #include <sound/soc.h>
 
 struct imx_spdif_data {
-        struct snd_soc_dai_link dai[2];
+        struct snd_soc_dai_link dai;
         struct snd_soc_card card;
-        struct platform_device *txdev;
-        struct platform_device *rxdev;
 };
 
 static int imx_spdif_audio_probe(struct platform_device *pdev)
 {
         struct device_node *spdif_np, *np = pdev->dev.of_node;
         struct imx_spdif_data *data;
-        int ret = 0, num_links = 0;
+        int ret = 0;
 
         spdif_np = of_parse_phandle(np, "spdif-controller", 0);
         if (!spdif_np) {
@@ -35,74 +33,46 @@ static int imx_spdif_audio_probe(struct platform_device *pdev)
 
         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
         if (!data) {
-                dev_err(&pdev->dev, "failed to allocate memory\n");
                 ret = -ENOMEM;
                 goto end;
         }
 
-        if (of_property_read_bool(np, "spdif-out")) {
-                data->dai[num_links].name = "S/PDIF TX";
-                data->dai[num_links].stream_name = "S/PDIF PCM Playback";
-                data->dai[num_links].codec_dai_name = "dit-hifi";
-                data->dai[num_links].codec_name = "spdif-dit";
-                data->dai[num_links].cpu_of_node = spdif_np;
-                data->dai[num_links].platform_of_node = spdif_np;
-                num_links++;
-
-                data->txdev = platform_device_register_simple("spdif-dit", -1, NULL, 0);
-                if (IS_ERR(data->txdev)) {
-                        ret = PTR_ERR(data->txdev);
-                        dev_err(&pdev->dev, "register dit failed: %d\n", ret);
-                        goto end;
-                }
-        }
+        data->dai.name = "S/PDIF PCM";
+        data->dai.stream_name = "S/PDIF PCM";
+        data->dai.codec_dai_name = "snd-soc-dummy-dai";
+        data->dai.codec_name = "snd-soc-dummy";
+        data->dai.cpu_of_node = spdif_np;
+        data->dai.platform_of_node = spdif_np;
+        data->dai.playback_only = true;
+        data->dai.capture_only = true;
 
-        if (of_property_read_bool(np, "spdif-in")) {
-                data->dai[num_links].name = "S/PDIF RX";
-                data->dai[num_links].stream_name = "S/PDIF PCM Capture";
-                data->dai[num_links].codec_dai_name = "dir-hifi";
-                data->dai[num_links].codec_name = "spdif-dir";
-                data->dai[num_links].cpu_of_node = spdif_np;
-                data->dai[num_links].platform_of_node = spdif_np;
-                num_links++;
-
-                data->rxdev = platform_device_register_simple("spdif-dir", -1, NULL, 0);
-                if (IS_ERR(data->rxdev)) {
-                        ret = PTR_ERR(data->rxdev);
-                        dev_err(&pdev->dev, "register dir failed: %d\n", ret);
-                        goto error_dit;
-                }
-        }
+        if (of_property_read_bool(np, "spdif-out"))
+                data->dai.capture_only = false;
+
+        if (of_property_read_bool(np, "spdif-in"))
+                data->dai.playback_only = false;
 
-        if (!num_links) {
+        if (data->dai.playback_only && data->dai.capture_only) {
                 dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n");
-                goto error_dir;
+                goto end;
         }
 
         data->card.dev = &pdev->dev;
-        data->card.num_links = num_links;
-        data->card.dai_link = data->dai;
+        data->card.dai_link = &data->dai;
+        data->card.num_links = 1;
 
         ret = snd_soc_of_parse_card_name(&data->card, "model");
         if (ret)
-                goto error_dir;
+                goto end;
 
         ret = devm_snd_soc_register_card(&pdev->dev, &data->card);
         if (ret) {
                 dev_err(&pdev->dev, "snd_soc_register_card failed: %d\n", ret);
-                goto error_dir;
+                goto end;
         }
 
         platform_set_drvdata(pdev, data);
 
-        goto end;
-
-error_dir:
-        if (data->rxdev)
-                platform_device_unregister(data->rxdev);
-error_dit:
-        if (data->txdev)
-                platform_device_unregister(data->txdev);
 end:
         if (spdif_np)
                 of_node_put(spdif_np);
@@ -110,18 +80,6 @@ end:
         return ret;
 }
 
-static int imx_spdif_audio_remove(struct platform_device *pdev)
-{
-        struct imx_spdif_data *data = platform_get_drvdata(pdev);
-
-        if (data->rxdev)
-                platform_device_unregister(data->rxdev);
-        if (data->txdev)
-                platform_device_unregister(data->txdev);
-
-        return 0;
-}
-
 static const struct of_device_id imx_spdif_dt_ids[] = {
         { .compatible = "fsl,imx-audio-spdif", },
         { /* sentinel */ }
@@ -135,7 +93,6 @@ static struct platform_driver imx_spdif_driver = {
                 .of_match_table = imx_spdif_dt_ids,
         },
         .probe = imx_spdif_audio_probe,
-        .remove = imx_spdif_audio_remove,
 };
 
 module_platform_driver(imx_spdif_driver);
diff --git a/sound/soc/fsl/imx-ssi.c b/sound/soc/fsl/imx-ssi.c
index f5f248c91c16..df552fa1aa65 100644
--- a/sound/soc/fsl/imx-ssi.c
+++ b/sound/soc/fsl/imx-ssi.c
@@ -304,8 +304,7 @@ static int imx_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
                         scr |= SSI_SCR_RE;
                 sier |= sier_bits;
 
-                if (++ssi->enabled == 1)
-                        scr |= SSI_SCR_SSIEN;
+                scr |= SSI_SCR_SSIEN;
 
                 break;
 
@@ -318,7 +317,7 @@ static int imx_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
                         scr &= ~SSI_SCR_RE;
                 sier &= ~sier_bits;
 
-                if (--ssi->enabled == 0)
+                if (!(scr & (SSI_SCR_TE | SSI_SCR_RE)))
                         scr &= ~SSI_SCR_SSIEN;
 
                 break;
@@ -536,7 +535,9 @@ static int imx_ssi_probe(struct platform_device *pdev)
                         ret);
                 goto failed_clk;
         }
-        clk_prepare_enable(ssi->clk);
+        ret = clk_prepare_enable(ssi->clk);
+        if (ret)
+                goto failed_clk;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         ssi->base = devm_ioremap_resource(&pdev->dev, res);
@@ -624,9 +625,6 @@ static int imx_ssi_remove(struct platform_device *pdev)
 {
         struct imx_ssi *ssi = platform_get_drvdata(pdev);
 
-        if (!ssi->dma_init)
-                imx_pcm_dma_exit(pdev);
-
         if (!ssi->fiq_init)
                 imx_pcm_fiq_exit(pdev);
 
diff --git a/sound/soc/fsl/imx-ssi.h b/sound/soc/fsl/imx-ssi.h
index 560c40fc9ebb..be6562365b6a 100644
--- a/sound/soc/fsl/imx-ssi.h
+++ b/sound/soc/fsl/imx-ssi.h
@@ -213,7 +213,6 @@ struct imx_ssi {
 
         int fiq_init;
         int dma_init;
-        int enabled;
 };
 
 #endif /* _IMX_SSI_H */
diff --git a/sound/soc/generic/simple-card.c b/sound/soc/generic/simple-card.c
index b2fbb7075a6c..c0d928138c88 100644
--- a/sound/soc/generic/simple-card.c
+++ b/sound/soc/generic/simple-card.c
@@ -8,7 +8,8 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
-
+#include <linux/clk.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
 #include <sound/simple_card.h>
@@ -24,7 +25,7 @@ static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai,
 
         daifmt |= set->fmt;
 
-        if (!ret && daifmt)
+        if (daifmt)
                 ret = snd_soc_dai_set_fmt(dai, daifmt);
 
         if (ret == -ENOTSUPP) {
@@ -57,11 +58,170 @@ static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd)
         return 0;
 }
 
+static int
+asoc_simple_card_sub_parse_of(struct device_node *np,
+                              struct asoc_simple_dai *dai,
+                              struct device_node **node)
+{
+        struct clk *clk;
+        int ret;
+
+        /*
+         * get node via "sound-dai = <&phandle port>"
+         * it will be used as xxx_of_node on soc_bind_dai_link()
+         */
+        *node = of_parse_phandle(np, "sound-dai", 0);
+        if (!*node)
+                return -ENODEV;
+
+        /* get dai->name */
+        ret = snd_soc_of_get_dai_name(np, &dai->name);
+        if (ret < 0)
+                goto parse_error;
+
+        /*
+         * bitclock-inversion, frame-inversion
+         * bitclock-master,    frame-master
+         * and specific "format" if it has
+         */
+        dai->fmt = snd_soc_of_parse_daifmt(np, NULL);
+
+        /*
+         * dai->sysclk come from
+         *  "clocks = <&xxx>" (if system has common clock)
+         *  or "system-clock-frequency = <xxx>"
+         *  or device's module clock.
+         */
+        if (of_property_read_bool(np, "clocks")) {
+                clk = of_clk_get(np, 0);
+                if (IS_ERR(clk)) {
+                        ret = PTR_ERR(clk);
+                        goto parse_error;
+                }
+
+                dai->sysclk = clk_get_rate(clk);
+        } else if (of_property_read_bool(np, "system-clock-frequency")) {
+                of_property_read_u32(np,
+                                     "system-clock-frequency",
+                                     &dai->sysclk);
+        } else {
+                clk = of_clk_get(*node, 0);
+                if (IS_ERR(clk)) {
+                        ret = PTR_ERR(clk);
+                        goto parse_error;
+                }
+
+                dai->sysclk = clk_get_rate(clk);
+        }
+
+        ret = 0;
+
+parse_error:
+        of_node_put(*node);
+
+        return ret;
+}
+
+static int asoc_simple_card_parse_of(struct device_node *node,
+                                     struct asoc_simple_card_info *info,
+                                     struct device *dev,
+                                     struct device_node **of_cpu,
+                                     struct device_node **of_codec,
+                                     struct device_node **of_platform)
+{
+        struct device_node *np;
+        char *name;
+        int ret;
+
+        /* get CPU/CODEC common format via simple-audio-card,format */
+        info->daifmt = snd_soc_of_parse_daifmt(node, "simple-audio-card,") &
+                (SND_SOC_DAIFMT_FORMAT_MASK | SND_SOC_DAIFMT_INV_MASK);
+
+        /* DAPM routes */
+        ret = snd_soc_of_parse_audio_routing(&info->snd_card,
+                                        "simple-audio-routing");
+        if (ret)
+                return ret;
+
+        /* CPU sub-node */
+        ret = -EINVAL;
+        np = of_get_child_by_name(node, "simple-audio-card,cpu");
+        if (np)
+                ret = asoc_simple_card_sub_parse_of(np,
+                                                  &info->cpu_dai,
+                                                  of_cpu);
+        if (ret < 0)
+                return ret;
+
+        /* CODEC sub-node */
+        ret = -EINVAL;
+        np = of_get_child_by_name(node, "simple-audio-card,codec");
+        if (np)
+                ret = asoc_simple_card_sub_parse_of(np,
+                                                  &info->codec_dai,
+                                                  of_codec);
+        if (ret < 0)
+                return ret;
+
+        if (!info->cpu_dai.name || !info->codec_dai.name)
+                return -EINVAL;
+
+        /* card name is created from CPU/CODEC dai name */
+        name = devm_kzalloc(dev,
+                            strlen(info->cpu_dai.name)   +
+                            strlen(info->codec_dai.name) + 2,
+                            GFP_KERNEL);
+        sprintf(name, "%s-%s", info->cpu_dai.name, info->codec_dai.name);
+        info->name = info->card = name;
+
+        /* simple-card assumes platform == cpu */
+        *of_platform = *of_cpu;
+
+        dev_dbg(dev, "card-name : %s\n", info->card);
+        dev_dbg(dev, "platform : %04x\n", info->daifmt);
+        dev_dbg(dev, "cpu : %s / %04x / %d\n",
+                info->cpu_dai.name,
+                info->cpu_dai.fmt,
+                info->cpu_dai.sysclk);
+        dev_dbg(dev, "codec : %s / %04x / %d\n",
+                info->codec_dai.name,
+                info->codec_dai.fmt,
+                info->codec_dai.sysclk);
+
+        return 0;
+}
+
 static int asoc_simple_card_probe(struct platform_device *pdev)
 {
-        struct asoc_simple_card_info *cinfo = pdev->dev.platform_data;
+        struct asoc_simple_card_info *cinfo;
+        struct device_node *np = pdev->dev.of_node;
+        struct device_node *of_cpu, *of_codec, *of_platform;
         struct device *dev = &pdev->dev;
 
+        cinfo           = NULL;
+        of_cpu          = NULL;
+        of_codec        = NULL;
+        of_platform     = NULL;
+        if (np && of_device_is_available(np)) {
+                cinfo = devm_kzalloc(dev, sizeof(*cinfo), GFP_KERNEL);
+                if (cinfo) {
+                        int ret;
+                        cinfo->snd_card.dev = &pdev->dev;
+                        ret = asoc_simple_card_parse_of(np, cinfo, dev,
+                                                        &of_cpu,
+                                                        &of_codec,
+                                                        &of_platform);
+                        if (ret < 0) {
+                                if (ret != -EPROBE_DEFER)
+                                        dev_err(dev, "parse error %d\n", ret);
+                                return ret;
+                        }
+                }
+        } else {
+                cinfo->snd_card.dev = &pdev->dev;
+                cinfo = pdev->dev.platform_data;
+        }
+
         if (!cinfo) {
                 dev_err(dev, "no info for asoc-simple-card\n");
                 return -EINVAL;
@@ -69,10 +229,10 @@ static int asoc_simple_card_probe(struct platform_device *pdev)
 
         if (!cinfo->name        ||
             !cinfo->card        ||
-            !cinfo->codec       ||
-            !cinfo->platform    ||
-            !cinfo->cpu_dai.name ||
-            !cinfo->codec_dai.name) {
+            !cinfo->codec_dai.name      ||
+            !(cinfo->codec              || of_codec)    ||
+            !(cinfo->platform           || of_platform) ||
+            !(cinfo->cpu_dai.name       || of_cpu)) {
                 dev_err(dev, "insufficient asoc_simple_card_info settings\n");
                 return -EINVAL;
         }
@@ -86,6 +246,9 @@ static int asoc_simple_card_probe(struct platform_device *pdev)
         cinfo->snd_link.platform_name   = cinfo->platform;
         cinfo->snd_link.codec_name      = cinfo->codec;
         cinfo->snd_link.codec_dai_name  = cinfo->codec_dai.name;
+        cinfo->snd_link.cpu_of_node     = of_cpu;
+        cinfo->snd_link.codec_of_node   = of_codec;
+        cinfo->snd_link.platform_of_node = of_platform;
         cinfo->snd_link.init            = asoc_simple_card_dai_init;
 
         /*
@@ -95,25 +258,23 @@ static int asoc_simple_card_probe(struct platform_device *pdev)
         cinfo->snd_card.owner           = THIS_MODULE;
         cinfo->snd_card.dai_link        = &cinfo->snd_link;
         cinfo->snd_card.num_links       = 1;
-        cinfo->snd_card.dev             = &pdev->dev;
 
-        return snd_soc_register_card(&cinfo->snd_card);
+        return devm_snd_soc_register_card(&pdev->dev, &cinfo->snd_card);
 }
 
-static int asoc_simple_card_remove(struct platform_device *pdev)
-{
-        struct asoc_simple_card_info *cinfo = pdev->dev.platform_data;
-
-        return snd_soc_unregister_card(&cinfo->snd_card);
-}
+static const struct of_device_id asoc_simple_of_match[] = {
+        { .compatible = "simple-audio-card", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
 
 static struct platform_driver asoc_simple_card = {
         .driver = {
                 .name   = "asoc-simple-card",
                 .owner = THIS_MODULE,
+                .of_match_table = asoc_simple_of_match,
         },
         .probe          = asoc_simple_card_probe,
-        .remove         = asoc_simple_card_remove,
 };
 
 module_platform_driver(asoc_simple_card);
diff --git a/sound/soc/mid-x86/Kconfig b/sound/soc/intel/Kconfig
index 61c10bf503d2..61c10bf503d2 100644
--- a/sound/soc/mid-x86/Kconfig
+++ b/sound/soc/intel/Kconfig
diff --git a/sound/soc/mid-x86/Makefile b/sound/soc/intel/Makefile
index 639883339465..639883339465 100644
--- a/sound/soc/mid-x86/Makefile
+++ b/sound/soc/intel/Makefile
diff --git a/sound/soc/mid-x86/mfld_machine.c b/sound/soc/intel/mfld_machine.c
index d3d4c32434f7..d3d4c32434f7 100644
--- a/sound/soc/mid-x86/mfld_machine.c
+++ b/sound/soc/intel/mfld_machine.c
diff --git a/sound/soc/mid-x86/sst_dsp.h b/sound/soc/intel/sst_dsp.h
index 0fce1de284ff..0fce1de284ff 100644
--- a/sound/soc/mid-x86/sst_dsp.h
+++ b/sound/soc/intel/sst_dsp.h
diff --git a/sound/soc/mid-x86/sst_platform.c b/sound/soc/intel/sst_platform.c
index b6b5eb698d33..b6b5eb698d33 100644
--- a/sound/soc/mid-x86/sst_platform.c
+++ b/sound/soc/intel/sst_platform.c
diff --git a/sound/soc/mid-x86/sst_platform.h b/sound/soc/intel/sst_platform.h
index cacc9066ec52..cacc9066ec52 100644
--- a/sound/soc/mid-x86/sst_platform.h
+++ b/sound/soc/intel/sst_platform.h
diff --git a/sound/soc/jz4740/Kconfig b/sound/soc/jz4740/Kconfig
index 5351cba66c9e..29f76af5d963 100644
--- a/sound/soc/jz4740/Kconfig
+++ b/sound/soc/jz4740/Kconfig
@@ -1,6 +1,7 @@
 config SND_JZ4740_SOC
         tristate "SoC Audio for Ingenic JZ4740 SoC"
         depends on MACH_JZ4740 && SND_SOC
+        select SND_SOC_GENERIC_DMAENGINE_PCM
         help
           Say Y or M if you want to add support for codecs attached to
           the JZ4740 I2S interface. You will also need to select the audio
diff --git a/sound/soc/jz4740/jz4740-i2s.c b/sound/soc/jz4740/jz4740-i2s.c
index 4c849a49c72a..8f220009e0f6 100644
--- a/sound/soc/jz4740/jz4740-i2s.c
+++ b/sound/soc/jz4740/jz4740-i2s.c
@@ -29,9 +29,11 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include <sound/initval.h>
+#include <sound/dmaengine_pcm.h>
+
+#include <asm/mach-jz4740/dma.h>
 
 #include "jz4740-i2s.h"
-#include "jz4740-pcm.h"
 
 #define JZ_REG_AIC_CONF         0x00
 #define JZ_REG_AIC_CTRL         0x04
@@ -89,8 +91,8 @@ struct jz4740_i2s {
         struct clk *clk_aic;
         struct clk *clk_i2s;
 
-        struct jz4740_pcm_config pcm_config_playback;
-        struct jz4740_pcm_config pcm_config_capture;
+        struct snd_dmaengine_dai_dma_data playback_dma_data;
+        struct snd_dmaengine_dai_dma_data capture_dma_data;
 };
 
 static inline uint32_t jz4740_i2s_read(const struct jz4740_i2s *i2s,
@@ -233,8 +235,6 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
         struct jz4740_i2s *i2s = snd_soc_dai_get_drvdata(dai);
-        enum jz4740_dma_width dma_width;
-        struct jz4740_pcm_config *pcm_config;
         unsigned int sample_size;
         uint32_t ctrl;
 
@@ -243,11 +243,9 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S8:
                 sample_size = 0;
-                dma_width = JZ4740_DMA_WIDTH_8BIT;
                 break;
         case SNDRV_PCM_FORMAT_S16:
                 sample_size = 1;
-                dma_width = JZ4740_DMA_WIDTH_16BIT;
                 break;
         default:
                 return -EINVAL;
@@ -260,22 +258,13 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
                         ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO;
                 else
                         ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO;
-
-                pcm_config = &i2s->pcm_config_playback;
-                pcm_config->dma_config.dst_width = dma_width;
-
         } else {
                 ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK;
                 ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET;
-
-                pcm_config = &i2s->pcm_config_capture;
-                pcm_config->dma_config.src_width = dma_width;
         }
 
         jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
 
-        snd_soc_dai_set_dma_data(dai, substream, pcm_config);
-
         return 0;
 }
 
@@ -342,25 +331,19 @@ static int jz4740_i2s_resume(struct snd_soc_dai *dai)
 
 static void jz4740_i2c_init_pcm_config(struct jz4740_i2s *i2s)
 {
-        struct jz4740_dma_config *dma_config;
+        struct snd_dmaengine_dai_dma_data *dma_data;
 
         /* Playback */
-        dma_config = &i2s->pcm_config_playback.dma_config;
-        dma_config->src_width = JZ4740_DMA_WIDTH_32BIT;
-        dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE;
-        dma_config->request_type = JZ4740_DMA_TYPE_AIC_TRANSMIT;
-        dma_config->flags = JZ4740_DMA_SRC_AUTOINC;
-        dma_config->mode = JZ4740_DMA_MODE_SINGLE;
-        i2s->pcm_config_playback.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
+        dma_data = &i2s->playback_dma_data;
+        dma_data->maxburst = 16;
+        dma_data->slave_id = JZ4740_DMA_TYPE_AIC_TRANSMIT;
+        dma_data->addr = i2s->phys_base + JZ_REG_AIC_FIFO;
 
         /* Capture */
-        dma_config = &i2s->pcm_config_capture.dma_config;
-        dma_config->dst_width = JZ4740_DMA_WIDTH_32BIT;
-        dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE;
-        dma_config->request_type = JZ4740_DMA_TYPE_AIC_RECEIVE;
-        dma_config->flags = JZ4740_DMA_DST_AUTOINC;
-        dma_config->mode = JZ4740_DMA_MODE_SINGLE;
-        i2s->pcm_config_capture.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
+        dma_data = &i2s->capture_dma_data;
+        dma_data->maxburst = 16;
+        dma_data->slave_id = JZ4740_DMA_TYPE_AIC_RECEIVE;
+        dma_data->addr = i2s->phys_base + JZ_REG_AIC_FIFO;
 }
 
 static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai)
@@ -371,6 +354,8 @@ static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai)
         clk_prepare_enable(i2s->clk_aic);
 
         jz4740_i2c_init_pcm_config(i2s);
+        snd_soc_dai_init_dma_data(dai, &i2s->playback_dma_data,
+                &i2s->capture_dma_data);
 
         conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
                 (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
@@ -432,91 +417,41 @@ static const struct snd_soc_component_driver jz4740_i2s_component = {
 static int jz4740_i2s_dev_probe(struct platform_device *pdev)
 {
         struct jz4740_i2s *i2s;
+        struct resource *mem;
         int ret;
 
-        i2s = kzalloc(sizeof(*i2s), GFP_KERNEL);
-
+        i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
         if (!i2s)
                 return -ENOMEM;
 
-        i2s->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!i2s->mem) {
-                ret = -ENOENT;
-                goto err_free;
-        }
-
-        i2s->mem = request_mem_region(i2s->mem->start, resource_size(i2s->mem),
-                                pdev->name);
-        if (!i2s->mem) {
-                ret = -EBUSY;
-                goto err_free;
-        }
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        i2s->base = devm_ioremap_resource(&pdev->dev, mem);
+        if (IS_ERR(i2s->base))
+                return PTR_ERR(i2s->base);
 
-        i2s->base = ioremap_nocache(i2s->mem->start, resource_size(i2s->mem));
-        if (!i2s->base) {
-                ret = -EBUSY;
-                goto err_release_mem_region;
-        }
+        i2s->phys_base = mem->start;
 
-        i2s->phys_base = i2s->mem->start;
+        i2s->clk_aic = devm_clk_get(&pdev->dev, "aic");
+        if (IS_ERR(i2s->clk_aic))
+                return PTR_ERR(i2s->clk_aic);
 
-        i2s->clk_aic = clk_get(&pdev->dev, "aic");
-        if (IS_ERR(i2s->clk_aic)) {
-                ret = PTR_ERR(i2s->clk_aic);
-                goto err_iounmap;
-        }
-
-        i2s->clk_i2s = clk_get(&pdev->dev, "i2s");
-        if (IS_ERR(i2s->clk_i2s)) {
-                ret = PTR_ERR(i2s->clk_i2s);
-                goto err_clk_put_aic;
-        }
+        i2s->clk_i2s = devm_clk_get(&pdev->dev, "i2s");
+        if (IS_ERR(i2s->clk_i2s))
+                return PTR_ERR(i2s->clk_i2s);
 
         platform_set_drvdata(pdev, i2s);
-        ret = snd_soc_register_component(&pdev->dev, &jz4740_i2s_component,
-                                         &jz4740_i2s_dai, 1);
 
-        if (ret) {
-                dev_err(&pdev->dev, "Failed to register DAI\n");
-                goto err_clk_put_i2s;
-        }
-
-        return 0;
-
-err_clk_put_i2s:
-        clk_put(i2s->clk_i2s);
-err_clk_put_aic:
-        clk_put(i2s->clk_aic);
-err_iounmap:
-        iounmap(i2s->base);
-err_release_mem_region:
-        release_mem_region(i2s->mem->start, resource_size(i2s->mem));
-err_free:
-        kfree(i2s);
-
-        return ret;
-}
+        ret = devm_snd_soc_register_component(&pdev->dev,
+                &jz4740_i2s_component, &jz4740_i2s_dai, 1);
+        if (ret)
+                return ret;
 
-static int jz4740_i2s_dev_remove(struct platform_device *pdev)
-{
-        struct jz4740_i2s *i2s = platform_get_drvdata(pdev);
-
-        snd_soc_unregister_component(&pdev->dev);
-
-        clk_put(i2s->clk_i2s);
-        clk_put(i2s->clk_aic);
-
-        iounmap(i2s->base);
-        release_mem_region(i2s->mem->start, resource_size(i2s->mem));
-
-        kfree(i2s);
-
-        return 0;
+        return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
+                SND_DMAENGINE_PCM_FLAG_COMPAT);
 }
 
 static struct platform_driver jz4740_i2s_driver = {
         .probe = jz4740_i2s_dev_probe,
-        .remove = jz4740_i2s_dev_remove,
         .driver = {
                 .name = "jz4740-i2s",
                 .owner = THIS_MODULE,
diff --git a/sound/soc/jz4740/jz4740-pcm.c b/sound/soc/jz4740/jz4740-pcm.c
deleted file mode 100644
index 1d7ef28585e1..000000000000
--- a/sound/soc/jz4740/jz4740-pcm.c
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
- *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
- *
- *  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.
- *
- *  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.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-
-#include <linux/dma-mapping.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
-
-#include <asm/mach-jz4740/dma.h>
-#include "jz4740-pcm.h"
-
-struct jz4740_runtime_data {
-        unsigned long dma_period;
-        dma_addr_t dma_start;
-        dma_addr_t dma_pos;
-        dma_addr_t dma_end;
-
-        struct jz4740_dma_chan *dma;
-
-        dma_addr_t fifo_addr;
-};
-
-/* identify hardware playback capabilities */
-static const struct snd_pcm_hardware jz4740_pcm_hardware = {
-        .info = SNDRV_PCM_INFO_MMAP |
-                SNDRV_PCM_INFO_MMAP_VALID |
-                SNDRV_PCM_INFO_INTERLEAVED |
-                SNDRV_PCM_INFO_BLOCK_TRANSFER,
-        .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
-
-        .rates                  = SNDRV_PCM_RATE_8000_48000,
-        .channels_min           = 1,
-        .channels_max           = 2,
-        .period_bytes_min       = 16,
-        .period_bytes_max       = 2 * PAGE_SIZE,
-        .periods_min            = 2,
-        .periods_max            = 128,
-        .buffer_bytes_max       = 128 * 2 * PAGE_SIZE,
-        .fifo_size              = 32,
-};
-
-static void jz4740_pcm_start_transfer(struct jz4740_runtime_data *prtd,
-        struct snd_pcm_substream *substream)
-{
-        unsigned long count;
-
-        if (prtd->dma_pos == prtd->dma_end)
-                prtd->dma_pos = prtd->dma_start;
-
-        if (prtd->dma_pos + prtd->dma_period > prtd->dma_end)
-                count = prtd->dma_end - prtd->dma_pos;
-        else
-                count = prtd->dma_period;
-
-        jz4740_dma_disable(prtd->dma);
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                jz4740_dma_set_src_addr(prtd->dma, prtd->dma_pos);
-                jz4740_dma_set_dst_addr(prtd->dma, prtd->fifo_addr);
-        } else {
-                jz4740_dma_set_src_addr(prtd->dma, prtd->fifo_addr);
-                jz4740_dma_set_dst_addr(prtd->dma, prtd->dma_pos);
-        }
-
-        jz4740_dma_set_transfer_count(prtd->dma, count);
-
-        prtd->dma_pos += count;
-
-        jz4740_dma_enable(prtd->dma);
-}
-
-static void jz4740_pcm_dma_transfer_done(struct jz4740_dma_chan *dma, int err,
-        void *dev_id)
-{
-        struct snd_pcm_substream *substream = dev_id;
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd = runtime->private_data;
-
-        snd_pcm_period_elapsed(substream);
-
-        jz4740_pcm_start_transfer(prtd, substream);
-}
-
-static int jz4740_pcm_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd = runtime->private_data;
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct jz4740_pcm_config *config;
-
-        config = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
-
-        if (!config)
-                return 0;
-
-        if (!prtd->dma) {
-                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
-                        prtd->dma = jz4740_dma_request(substream, "PCM Capture");
-                else
-                        prtd->dma = jz4740_dma_request(substream, "PCM Playback");
-        }
-
-        if (!prtd->dma)
-                return -EBUSY;
-
-        jz4740_dma_configure(prtd->dma, &config->dma_config);
-        prtd->fifo_addr = config->fifo_addr;
-
-        jz4740_dma_set_complete_cb(prtd->dma, jz4740_pcm_dma_transfer_done);
-
-        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
-        runtime->dma_bytes = params_buffer_bytes(params);
-
-        prtd->dma_period = params_period_bytes(params);
-        prtd->dma_start = runtime->dma_addr;
-        prtd->dma_pos = prtd->dma_start;
-        prtd->dma_end = prtd->dma_start + runtime->dma_bytes;
-
-        return 0;
-}
-
-static int jz4740_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-        struct jz4740_runtime_data *prtd = substream->runtime->private_data;
-
-        snd_pcm_set_runtime_buffer(substream, NULL);
-        if (prtd->dma) {
-                jz4740_dma_free(prtd->dma);
-                prtd->dma = NULL;
-        }
-
-        return 0;
-}
-
-static int jz4740_pcm_prepare(struct snd_pcm_substream *substream)
-{
-        struct jz4740_runtime_data *prtd = substream->runtime->private_data;
-
-        if (!prtd->dma)
-                return -EBUSY;
-
-        prtd->dma_pos = prtd->dma_start;
-
-        return 0;
-}
-
-static int jz4740_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd = runtime->private_data;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                jz4740_pcm_start_transfer(prtd, substream);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                jz4740_dma_disable(prtd->dma);
-                break;
-        default:
-                break;
-        }
-
-        return 0;
-}
-
-static snd_pcm_uframes_t jz4740_pcm_pointer(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd = runtime->private_data;
-        unsigned long byte_offset;
-        snd_pcm_uframes_t offset;
-        struct jz4740_dma_chan *dma = prtd->dma;
-
-        /* prtd->dma_pos points to the end of the current transfer. So by
-         * subtracting prdt->dma_start we get the offset to the end of the
-         * current period in bytes. By subtracting the residue of the transfer
-         * we get the current offset in bytes. */
-        byte_offset = prtd->dma_pos - prtd->dma_start;
-        byte_offset -= jz4740_dma_get_residue(dma);
-
-        offset = bytes_to_frames(runtime, byte_offset);
-        if (offset >= runtime->buffer_size)
-                offset = 0;
-
-        return offset;
-}
-
-static int jz4740_pcm_open(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd;
-
-        prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
-        if (prtd == NULL)
-                return -ENOMEM;
-
-        snd_soc_set_runtime_hwparams(substream, &jz4740_pcm_hardware);
-
-        runtime->private_data = prtd;
-
-        return 0;
-}
-
-static int jz4740_pcm_close(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct jz4740_runtime_data *prtd = runtime->private_data;
-
-        kfree(prtd);
-
-        return 0;
-}
-
-static int jz4740_pcm_mmap(struct snd_pcm_substream *substream,
-        struct vm_area_struct *vma)
-{
-        return remap_pfn_range(vma, vma->vm_start,
-                        substream->dma_buffer.addr >> PAGE_SHIFT,
-                        vma->vm_end - vma->vm_start, vma->vm_page_prot);
-}
-
-static struct snd_pcm_ops jz4740_pcm_ops = {
-        .open           = jz4740_pcm_open,
-        .close          = jz4740_pcm_close,
-        .ioctl          = snd_pcm_lib_ioctl,
-        .hw_params      = jz4740_pcm_hw_params,
-        .hw_free        = jz4740_pcm_hw_free,
-        .prepare        = jz4740_pcm_prepare,
-        .trigger        = jz4740_pcm_trigger,
-        .pointer        = jz4740_pcm_pointer,
-        .mmap           = jz4740_pcm_mmap,
-};
-
-static int jz4740_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
-{
-        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
-        struct snd_dma_buffer *buf = &substream->dma_buffer;
-        size_t size = jz4740_pcm_hardware.buffer_bytes_max;
-
-        buf->dev.type = SNDRV_DMA_TYPE_DEV;
-        buf->dev.dev = pcm->card->dev;
-        buf->private_data = NULL;
-
-        buf->area = dma_alloc_noncoherent(pcm->card->dev, size,
-                                          &buf->addr, GFP_KERNEL);
-        if (!buf->area)
-                return -ENOMEM;
-
-        buf->bytes = size;
-
-        return 0;
-}
-
-static void jz4740_pcm_free(struct snd_pcm *pcm)
-{
-        struct snd_pcm_substream *substream;
-        struct snd_dma_buffer *buf;
-        int stream;
-
-        for (stream = 0; stream < SNDRV_PCM_STREAM_LAST; ++stream) {
-                substream = pcm->streams[stream].substream;
-                if (!substream)
-                        continue;
-
-                buf = &substream->dma_buffer;
-                if (!buf->area)
-                        continue;
-
-                dma_free_noncoherent(pcm->card->dev, buf->bytes, buf->area,
-                                buf->addr);
-                buf->area = NULL;
-        }
-}
-
-static int jz4740_pcm_new(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_card *card = rtd->card->snd_card;
-        struct snd_pcm *pcm = rtd->pcm;
-        int ret;
-
-        ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
-        if (ret)
-                return ret;
-
-        if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
-                ret = jz4740_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_PLAYBACK);
-                if (ret)
-                        goto err;
-        }
-
-        if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
-                ret = jz4740_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_CAPTURE);
-                if (ret)
-                        goto err;
-        }
-
-err:
-        return ret;
-}
-
-static struct snd_soc_platform_driver jz4740_soc_platform = {
-                .ops            = &jz4740_pcm_ops,
-                .pcm_new        = jz4740_pcm_new,
-                .pcm_free       = jz4740_pcm_free,
-};
-
-static int jz4740_pcm_probe(struct platform_device *pdev)
-{
-        return snd_soc_register_platform(&pdev->dev, &jz4740_soc_platform);
-}
-
-static int jz4740_pcm_remove(struct platform_device *pdev)
-{
-        snd_soc_unregister_platform(&pdev->dev);
-        return 0;
-}
-
-static struct platform_driver jz4740_pcm_driver = {
-        .probe = jz4740_pcm_probe,
-        .remove = jz4740_pcm_remove,
-        .driver = {
-                .name = "jz4740-pcm-audio",
-                .owner = THIS_MODULE,
-        },
-};
-
-module_platform_driver(jz4740_pcm_driver);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Ingenic SoC JZ4740 PCM driver");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/jz4740/jz4740-pcm.h b/sound/soc/jz4740/jz4740-pcm.h
deleted file mode 100644
index 1220cbb4382c..000000000000
--- a/sound/soc/jz4740/jz4740-pcm.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *
- * 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 _JZ4740_PCM_H
-#define _JZ4740_PCM_H
-
-#include <linux/dma-mapping.h>
-#include <asm/mach-jz4740/dma.h>
-
-
-struct jz4740_pcm_config {
-        struct jz4740_dma_config dma_config;
-        phys_addr_t fifo_addr;
-};
-
-#endif
diff --git a/sound/soc/jz4740/qi_lb60.c b/sound/soc/jz4740/qi_lb60.c
index 55fd6b5df55f..82b5f37cd2c7 100644
--- a/sound/soc/jz4740/qi_lb60.c
+++ b/sound/soc/jz4740/qi_lb60.c
@@ -73,7 +73,7 @@ static struct snd_soc_dai_link qi_lb60_dai = {
         .name = "jz4740",
         .stream_name = "jz4740",
         .cpu_dai_name = "jz4740-i2s",
-        .platform_name = "jz4740-pcm-audio",
+        .platform_name = "jz4740-i2s",
         .codec_dai_name = "jz4740-hifi",
         .codec_name = "jz4740-codec",
         .init = qi_lb60_codec_init,
diff --git a/sound/soc/mxs/mxs-pcm.c b/sound/soc/mxs/mxs-pcm.c
index b16abbbf7764..04a6b0d60944 100644
--- a/sound/soc/mxs/mxs-pcm.c
+++ b/sound/soc/mxs/mxs-pcm.c
@@ -56,16 +56,10 @@ static const struct snd_dmaengine_pcm_config mxs_dmaengine_pcm_config = {
 
 int mxs_pcm_platform_register(struct device *dev)
 {
-        return snd_dmaengine_pcm_register(dev, &mxs_dmaengine_pcm_config,
+        return devm_snd_dmaengine_pcm_register(dev, &mxs_dmaengine_pcm_config,
                 SND_DMAENGINE_PCM_FLAG_NO_RESIDUE |
                 SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX);
 }
 EXPORT_SYMBOL_GPL(mxs_pcm_platform_register);
 
-void mxs_pcm_platform_unregister(struct device *dev)
-{
-        snd_dmaengine_pcm_unregister(dev);
-}
-EXPORT_SYMBOL_GPL(mxs_pcm_platform_unregister);
-
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/mxs/mxs-pcm.h b/sound/soc/mxs/mxs-pcm.h
index bc685b67cac7..035ea0436ca5 100644
--- a/sound/soc/mxs/mxs-pcm.h
+++ b/sound/soc/mxs/mxs-pcm.h
@@ -20,6 +20,5 @@
 #define _MXS_PCM_H
 
 int mxs_pcm_platform_register(struct device *dev);
-void mxs_pcm_platform_unregister(struct device *dev);
 
 #endif
diff --git a/sound/soc/mxs/mxs-saif.c b/sound/soc/mxs/mxs-saif.c
index 54e622acac33..231d7e7b0711 100644
--- a/sound/soc/mxs/mxs-saif.c
+++ b/sound/soc/mxs/mxs-saif.c
@@ -50,9 +50,9 @@ static struct mxs_saif *mxs_saif[2];
  * This also means that both SAIFs must operate at the same sample rate.
  *
  * We abstract this as each saif has a master, the master could be
- * himself or other saifs. In the generic saif driver, saif does not need
- * to know the different clkmux. Saif only needs to know who is his master
- * and operating his master to generate the proper clock rate for him.
+ * itself or other saifs. In the generic saif driver, saif does not need
+ * to know the different clkmux. Saif only needs to know who is its master
+ * and operating its master to generate the proper clock rate for it.
  * The master id is provided in mach-specific layer according to different
  * clkmux setting.
  */
@@ -76,7 +76,7 @@ static int mxs_saif_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
  * Since SAIF may work on EXTMASTER mode, IOW, it's working BITCLK&LRCLK
  * is provided by other SAIF, we provide a interface here to get its master
  * from its master_id.
- * Note that the master could be himself.
+ * Note that the master could be itself.
  */
 static inline struct mxs_saif *mxs_saif_get_master(struct mxs_saif * saif)
 {
@@ -516,7 +516,7 @@ static int mxs_saif_trigger(struct snd_pcm_substream *substream, int cmd,
                 }
 
                 /*
-                 * If the saif's master is not himself, we also need to enable
+                 * If the saif's master is not itself, we also need to enable
                  * itself clk for its internal basic logic to work.
                  */
                 if (saif != master_saif) {
@@ -804,13 +804,6 @@ static int mxs_saif_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int mxs_saif_remove(struct platform_device *pdev)
-{
-        mxs_pcm_platform_unregister(&pdev->dev);
-
-        return 0;
-}
-
 static const struct of_device_id mxs_saif_dt_ids[] = {
         { .compatible = "fsl,imx28-saif", },
         { /* sentinel */ }
@@ -819,7 +812,6 @@ MODULE_DEVICE_TABLE(of, mxs_saif_dt_ids);
 
 static struct platform_driver mxs_saif_driver = {
         .probe = mxs_saif_probe,
-        .remove = mxs_saif_remove,
 
         .driver = {
                 .name = "mxs-saif",
diff --git a/sound/soc/omap/mcbsp.c b/sound/soc/omap/mcbsp.c
index 83433fdea32a..86c75384c3c8 100644
--- a/sound/soc/omap/mcbsp.c
+++ b/sound/soc/omap/mcbsp.c
@@ -36,10 +36,10 @@ static void omap_mcbsp_write(struct omap_mcbsp *mcbsp, u16 reg, u32 val)
 
         if (mcbsp->pdata->reg_size == 2) {
                 ((u16 *)mcbsp->reg_cache)[reg] = (u16)val;
-                __raw_writew((u16)val, addr);
+                writew_relaxed((u16)val, addr);
         } else {
                 ((u32 *)mcbsp->reg_cache)[reg] = val;
-                __raw_writel(val, addr);
+                writel_relaxed(val, addr);
         }
 }
 
@@ -48,22 +48,22 @@ static int omap_mcbsp_read(struct omap_mcbsp *mcbsp, u16 reg, bool from_cache)
         void __iomem *addr = mcbsp->io_base + reg * mcbsp->pdata->reg_step;
 
         if (mcbsp->pdata->reg_size == 2) {
-                return !from_cache ? __raw_readw(addr) :
+                return !from_cache ? readw_relaxed(addr) :
                                      ((u16 *)mcbsp->reg_cache)[reg];
         } else {
-                return !from_cache ? __raw_readl(addr) :
+                return !from_cache ? readl_relaxed(addr) :
                                      ((u32 *)mcbsp->reg_cache)[reg];
         }
 }
 
 static void omap_mcbsp_st_write(struct omap_mcbsp *mcbsp, u16 reg, u32 val)
 {
-        __raw_writel(val, mcbsp->st_data->io_base_st + reg);
+        writel_relaxed(val, mcbsp->st_data->io_base_st + reg);
 }
 
 static int omap_mcbsp_st_read(struct omap_mcbsp *mcbsp, u16 reg)
 {
-        return __raw_readl(mcbsp->st_data->io_base_st + reg);
+        return readl_relaxed(mcbsp->st_data->io_base_st + reg);
 }
 
 #define MCBSP_READ(mcbsp, reg) \
diff --git a/sound/soc/omap/omap-dmic.c b/sound/soc/omap/omap-dmic.c
index 12e566be3793..1bd531d718f9 100644
--- a/sound/soc/omap/omap-dmic.c
+++ b/sound/soc/omap/omap-dmic.c
@@ -61,12 +61,12 @@ struct omap_dmic {
 
 static inline void omap_dmic_write(struct omap_dmic *dmic, u16 reg, u32 val)
 {
-        __raw_writel(val, dmic->io_base + reg);
+        writel_relaxed(val, dmic->io_base + reg);
 }
 
 static inline int omap_dmic_read(struct omap_dmic *dmic, u16 reg)
 {
-        return __raw_readl(dmic->io_base + reg);
+        return readl_relaxed(dmic->io_base + reg);
 }
 
 static inline void omap_dmic_start(struct omap_dmic *dmic)
diff --git a/sound/soc/omap/omap-mcpdm.c b/sound/soc/omap/omap-mcpdm.c
index cd9ee167959d..2f5b1536477e 100644
--- a/sound/soc/omap/omap-mcpdm.c
+++ b/sound/soc/omap/omap-mcpdm.c
@@ -74,12 +74,12 @@ struct omap_mcpdm {
 
 static inline void omap_mcpdm_write(struct omap_mcpdm *mcpdm, u16 reg, u32 val)
 {
-        __raw_writel(val, mcpdm->io_base + reg);
+        writel_relaxed(val, mcpdm->io_base + reg);
 }
 
 static inline int omap_mcpdm_read(struct omap_mcpdm *mcpdm, u16 reg)
 {
-        return __raw_readl(mcpdm->io_base + reg);
+        return readl_relaxed(mcpdm->io_base + reg);
 }
 
 #ifdef DEBUG
diff --git a/sound/soc/omap/omap-pcm.c b/sound/soc/omap/omap-pcm.c
index b8fa9862e54c..07b8b7bc9d20 100644
--- a/sound/soc/omap/omap-pcm.c
+++ b/sound/soc/omap/omap-pcm.c
@@ -45,8 +45,6 @@ static const struct snd_pcm_hardware omap_pcm_hardware = {
                                   SNDRV_PCM_INFO_PAUSE |
                                   SNDRV_PCM_INFO_RESUME |
                                   SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE |
-                                  SNDRV_PCM_FMTBIT_S32_LE,
         .period_bytes_min       = 32,
         .period_bytes_max       = 64 * 1024,
         .periods_min            = 2,
diff --git a/sound/soc/pxa/Kconfig b/sound/soc/pxa/Kconfig
index 4db74a083db1..6473052b6899 100644
--- a/sound/soc/pxa/Kconfig
+++ b/sound/soc/pxa/Kconfig
@@ -11,7 +11,7 @@ config SND_PXA2XX_SOC
 config SND_MMP_SOC
         bool "Soc Audio for Marvell MMP chips"
         depends on ARCH_MMP
-        select SND_DMAENGINE_PCM
+        select SND_SOC_GENERIC_DMAENGINE_PCM
         select SND_ARM
         help
           Say Y if you want to add support for codecs attached to
diff --git a/sound/soc/pxa/mmp-pcm.c b/sound/soc/pxa/mmp-pcm.c
index 7929e19b0ef5..5e8d81330173 100644
--- a/sound/soc/pxa/mmp-pcm.c
+++ b/sound/soc/pxa/mmp-pcm.c
@@ -36,14 +36,9 @@ struct mmp_dma_data {
                 SNDRV_PCM_INFO_PAUSE |          \
                 SNDRV_PCM_INFO_RESUME)
 
-#define MMP_PCM_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \
-                         SNDRV_PCM_FMTBIT_S24_LE | \
-                         SNDRV_PCM_FMTBIT_S32_LE)
-
 static struct snd_pcm_hardware mmp_pcm_hardware[] = {
         {
                 .info                   = MMP_PCM_INFO,
-                .formats                = MMP_PCM_FORMATS,
                 .period_bytes_min       = 1024,
                 .period_bytes_max       = 2048,
                 .periods_min            = 2,
@@ -53,7 +48,6 @@ static struct snd_pcm_hardware mmp_pcm_hardware[] = {
         },
         {
                 .info                   = MMP_PCM_INFO,
-                .formats                = MMP_PCM_FORMATS,
                 .period_bytes_min       = 1024,
                 .period_bytes_max       = 2048,
                 .periods_min            = 2,
@@ -67,27 +61,15 @@ static int mmp_pcm_hw_params(struct snd_pcm_substream *substream,
                               struct snd_pcm_hw_params *params)
 {
         struct dma_chan *chan = snd_dmaengine_pcm_get_chan(substream);
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_dmaengine_dai_dma_data *dma_params;
         struct dma_slave_config slave_config;
         int ret;
 
-        dma_params = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
-        if (!dma_params)
-                return 0;
-
-        ret = snd_hwparams_to_dma_slave_config(substream, params, &slave_config);
+        ret =
+            snd_dmaengine_pcm_prepare_slave_config(substream, params,
+                                                   &slave_config);
         if (ret)
                 return ret;
 
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                slave_config.dst_addr     = dma_params->addr;
-                slave_config.dst_maxburst = 4;
-        } else {
-                slave_config.src_addr     = dma_params->addr;
-                slave_config.src_maxburst = 4;
-        }
-
         ret = dmaengine_slave_config(chan, &slave_config);
         if (ret)
                 return ret;
diff --git a/sound/soc/s6000/s6000-pcm.c b/sound/soc/s6000/s6000-pcm.c
index d219880815c0..fb8461e1b1f6 100644
--- a/sound/soc/s6000/s6000-pcm.c
+++ b/sound/soc/s6000/s6000-pcm.c
@@ -33,13 +33,6 @@ static struct snd_pcm_hardware s6000_pcm_hardware = {
         .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_JOINT_DUPLEX),
-        .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE),
-        .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_5512 | \
-                  SNDRV_PCM_RATE_8000_192000),
-        .rate_min = 0,
-        .rate_max = 1562500,
-        .channels_min = 2,
-        .channels_max = 8,
         .buffer_bytes_max = 0x7ffffff0,
         .period_bytes_min = 16,
         .period_bytes_max = 0xfffff0,
diff --git a/sound/soc/samsung/Kconfig b/sound/soc/samsung/Kconfig
index 37459dfd168d..27930fc432dc 100644
--- a/sound/soc/samsung/Kconfig
+++ b/sound/soc/samsung/Kconfig
@@ -1,13 +1,22 @@
 config SND_SOC_SAMSUNG
         tristate "ASoC support for Samsung"
         depends on PLAT_SAMSUNG
-        select S3C64XX_DMA if ARCH_S3C64XX
-        select S3C24XX_DMA if ARCH_S3C24XX
+        select S3C2410_DMA if ARCH_S3C24XX
+        select S3C64XX_PL080 if ARCH_S3C64XX
+        select SND_S3C_DMA if !ARCH_S3C24XX
+        select SND_S3C_DMA_LEGACY if ARCH_S3C24XX
+        select SND_SOC_GENERIC_DMAENGINE_PCM if !ARCH_S3C24XX
         help
           Say Y or M if you want to add support for codecs attached to
           the Samsung SoCs' Audio interfaces. You will also need to
           select the audio interfaces to support below.
 
+config SND_S3C_DMA
+        tristate
+
+config SND_S3C_DMA_LEGACY
+        tristate
+
 config SND_S3C24XX_I2S
         tristate
         select S3C2410_DMA
diff --git a/sound/soc/samsung/Makefile b/sound/soc/samsung/Makefile
index 709f6059ad67..86715d8efee6 100644
--- a/sound/soc/samsung/Makefile
+++ b/sound/soc/samsung/Makefile
@@ -1,5 +1,6 @@
 # S3c24XX Platform Support
-snd-soc-s3c24xx-objs := dma.o
+snd-soc-s3c-dma-objs := dmaengine.o
+snd-soc-s3c-dma-legacy-objs := dma.o
 snd-soc-idma-objs := idma.o
 snd-soc-s3c24xx-i2s-objs := s3c24xx-i2s.o
 snd-soc-s3c2412-i2s-objs := s3c2412-i2s.o
@@ -9,7 +10,8 @@ snd-soc-samsung-spdif-objs := spdif.o
 snd-soc-pcm-objs := pcm.o
 snd-soc-i2s-objs := i2s.o
 
-obj-$(CONFIG_SND_SOC_SAMSUNG) += snd-soc-s3c24xx.o
+obj-$(CONFIG_SND_S3C_DMA) += snd-soc-s3c-dma.o
+obj-$(CONFIG_SND_S3C_DMA_LEGACY) += snd-soc-s3c-dma-legacy.o
 obj-$(CONFIG_SND_S3C24XX_I2S) += snd-soc-s3c24xx-i2s.o
 obj-$(CONFIG_SND_SAMSUNG_AC97) += snd-soc-ac97.o
 obj-$(CONFIG_SND_S3C2412_SOC_I2S) += snd-soc-s3c2412-i2s.o
diff --git a/sound/soc/samsung/ac97.c b/sound/soc/samsung/ac97.c
index 350ba23a9893..4a88e36c82ec 100644
--- a/sound/soc/samsung/ac97.c
+++ b/sound/soc/samsung/ac97.c
@@ -221,24 +221,6 @@ static struct snd_ac97_bus_ops s3c_ac97_ops = {
         .reset      = s3c_ac97_cold_reset,
 };
 
-static int s3c_ac97_hw_params(struct snd_pcm_substream *substream,
-                                  struct snd_pcm_hw_params *params,
-                                  struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        struct s3c_dma_params *dma_data;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                dma_data = &s3c_ac97_pcm_out;
-        else
-                dma_data = &s3c_ac97_pcm_in;
-
-        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
-
-        return 0;
-}
-
 static int s3c_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
                                 struct snd_soc_dai *dai)
 {
@@ -279,21 +261,6 @@ static int s3c_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
         return 0;
 }
 
-static int s3c_ac97_hw_mic_params(struct snd_pcm_substream *substream,
-                                      struct snd_pcm_hw_params *params,
-                                      struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                return -ENODEV;
-        else
-                snd_soc_dai_set_dma_data(cpu_dai, substream, &s3c_ac97_mic_in);
-
-        return 0;
-}
-
 static int s3c_ac97_mic_trigger(struct snd_pcm_substream *substream,
                                     int cmd, struct snd_soc_dai *dai)
 {
@@ -329,15 +296,27 @@ static int s3c_ac97_mic_trigger(struct snd_pcm_substream *substream,
 }
 
 static const struct snd_soc_dai_ops s3c_ac97_dai_ops = {
-        .hw_params      = s3c_ac97_hw_params,
         .trigger        = s3c_ac97_trigger,
 };
 
 static const struct snd_soc_dai_ops s3c_ac97_mic_dai_ops = {
-        .hw_params      = s3c_ac97_hw_mic_params,
         .trigger        = s3c_ac97_mic_trigger,
 };
 
+static int s3c_ac97_dai_probe(struct snd_soc_dai *dai)
+{
+        samsung_asoc_init_dma_data(dai, &s3c_ac97_pcm_out, &s3c_ac97_pcm_in);
+
+        return 0;
+}
+
+static int s3c_ac97_mic_dai_probe(struct snd_soc_dai *dai)
+{
+        samsung_asoc_init_dma_data(dai, NULL, &s3c_ac97_mic_in);
+
+        return 0;
+}
+
 static struct snd_soc_dai_driver s3c_ac97_dai[] = {
         [S3C_AC97_DAI_PCM] = {
                 .name = "samsung-ac97",
@@ -354,6 +333,7 @@ static struct snd_soc_dai_driver s3c_ac97_dai[] = {
                         .channels_max = 2,
                         .rates = SNDRV_PCM_RATE_8000_48000,
                         .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .probe = s3c_ac97_dai_probe,
                 .ops = &s3c_ac97_dai_ops,
         },
         [S3C_AC97_DAI_MIC] = {
@@ -365,6 +345,7 @@ static struct snd_soc_dai_driver s3c_ac97_dai[] = {
                         .channels_max = 1,
                         .rates = SNDRV_PCM_RATE_8000_48000,
                         .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .probe = s3c_ac97_mic_dai_probe,
                 .ops = &s3c_ac97_mic_dai_ops,
         },
 };
diff --git a/sound/soc/samsung/dma.c b/sound/soc/samsung/dma.c
index fe2748b494d4..dc09b71b7d9f 100644
--- a/sound/soc/samsung/dma.c
+++ b/sound/soc/samsung/dma.c
@@ -35,12 +35,6 @@ static const struct snd_pcm_hardware dma_hardware = {
                                     SNDRV_PCM_INFO_BLOCK_TRANSFER |
                                     SNDRV_PCM_INFO_MMAP |
                                     SNDRV_PCM_INFO_MMAP_VALID,
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE |
-                                    SNDRV_PCM_FMTBIT_U16_LE |
-                                    SNDRV_PCM_FMTBIT_U8 |
-                                    SNDRV_PCM_FMTBIT_S8,
-        .channels_min           = 2,
-        .channels_max           = 2,
         .buffer_bytes_max       = 128*1024,
         .period_bytes_min       = PAGE_SIZE,
         .period_bytes_max       = PAGE_SIZE*2,
@@ -441,6 +435,14 @@ static struct snd_soc_platform_driver samsung_asoc_platform = {
         .pcm_free       = dma_free_dma_buffers,
 };
 
+void samsung_asoc_init_dma_data(struct snd_soc_dai *dai,
+                                struct s3c_dma_params *playback,
+                                struct s3c_dma_params *capture)
+{
+        snd_soc_dai_init_dma_data(dai, playback, capture);
+}
+EXPORT_SYMBOL_GPL(samsung_asoc_init_dma_data);
+
 int samsung_asoc_dma_platform_register(struct device *dev)
 {
         return snd_soc_register_platform(dev, &samsung_asoc_platform);
diff --git a/sound/soc/samsung/dma.h b/sound/soc/samsung/dma.h
index 0e86315a3eaf..225e5378014e 100644
--- a/sound/soc/samsung/dma.h
+++ b/sound/soc/samsung/dma.h
@@ -12,6 +12,8 @@
 #ifndef _S3C_AUDIO_H
 #define _S3C_AUDIO_H
 
+#include <sound/dmaengine_pcm.h>
+
 struct s3c_dma_params {
         struct s3c2410_dma_client *client;      /* stream identifier */
         int channel;                            /* Channel ID */
@@ -20,8 +22,12 @@ struct s3c_dma_params {
         unsigned ch;
         struct samsung_dma_ops *ops;
         char *ch_name;
+        struct snd_dmaengine_dai_dma_data dma_data;
 };
 
+void samsung_asoc_init_dma_data(struct snd_soc_dai *dai,
+                                struct s3c_dma_params *playback,
+                                struct s3c_dma_params *capture);
 int samsung_asoc_dma_platform_register(struct device *dev);
 void samsung_asoc_dma_platform_unregister(struct device *dev);
 
diff --git a/sound/soc/samsung/dmaengine.c b/sound/soc/samsung/dmaengine.c
new file mode 100644
index 000000000000..3be479d51b9b
--- /dev/null
+++ b/sound/soc/samsung/dmaengine.c
@@ -0,0 +1,84 @@
+/*
+ * dmaengine.c - Samsung dmaengine wrapper
+ *
+ * Author: Mark Brown <broonie@linaro.org>
+ * Copyright 2013 Linaro
+ *
+ * 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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/amba/pl08x.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/dmaengine_pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dai.h>
+
+#include "dma.h"
+
+#ifdef CONFIG_ARCH_S3C64XX
+#define filter_fn pl08x_filter_id
+#else
+#define filter_fn NULL
+#endif
+
+static const struct snd_dmaengine_pcm_config samsung_dmaengine_pcm_config = {
+        .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
+        .compat_filter_fn = filter_fn,
+};
+
+void samsung_asoc_init_dma_data(struct snd_soc_dai *dai,
+                                struct s3c_dma_params *playback,
+                                struct s3c_dma_params *capture)
+{
+        struct snd_dmaengine_dai_dma_data *playback_data = NULL;
+        struct snd_dmaengine_dai_dma_data *capture_data = NULL;
+
+        if (playback) {
+                playback_data = &playback->dma_data;
+                playback_data->filter_data = (void *)playback->channel;
+                playback_data->chan_name = playback->ch_name;
+                playback_data->addr = playback->dma_addr;
+                playback_data->addr_width = playback->dma_size;
+        }
+        if (capture) {
+                capture_data = &capture->dma_data;
+                capture_data->filter_data = (void *)capture->channel;
+                capture_data->chan_name = capture->ch_name;
+                capture_data->addr = capture->dma_addr;
+                capture_data->addr_width = capture->dma_size;
+        }
+
+        snd_soc_dai_init_dma_data(dai, playback_data, capture_data);
+}
+EXPORT_SYMBOL_GPL(samsung_asoc_init_dma_data);
+
+int samsung_asoc_dma_platform_register(struct device *dev)
+{
+        return snd_dmaengine_pcm_register(dev, &samsung_dmaengine_pcm_config,
+                                          SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME |
+                                          SND_DMAENGINE_PCM_FLAG_NO_RESIDUE |
+                                          SND_DMAENGINE_PCM_FLAG_COMPAT);
+}
+EXPORT_SYMBOL_GPL(samsung_asoc_dma_platform_register);
+
+void samsung_asoc_dma_platform_unregister(struct device *dev)
+{
+        return snd_dmaengine_pcm_unregister(dev);
+}
+EXPORT_SYMBOL_GPL(samsung_asoc_dma_platform_unregister);
+
+MODULE_AUTHOR("Mark Brown <broonie@linaro.org>");
+MODULE_DESCRIPTION("Samsung dmaengine ASoC driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/samsung/i2s.c b/sound/soc/samsung/i2s.c
index a5cbdb4f1655..92f64363427d 100644
--- a/sound/soc/samsung/i2s.c
+++ b/sound/soc/samsung/i2s.c
@@ -702,6 +702,8 @@ static int i2s_hw_params(struct snd_pcm_substream *substream,
         }
         writel(mod, i2s->addr + I2SMOD);
 
+        samsung_asoc_init_dma_data(dai, &i2s->dma_playback, &i2s->dma_capture);
+
         i2s->frmclk = params_rate(params);
 
         return 0;
@@ -946,8 +948,11 @@ static int samsung_i2s_dai_probe(struct snd_soc_dai *dai)
         struct i2s_dai *i2s = to_info(dai);
         struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
 
-        if (other && other->clk) /* If this is probe on secondary */
+        if (other && other->clk) { /* If this is probe on secondary */
+                samsung_asoc_init_dma_data(dai, &other->sec_dai->dma_playback,
+                                           NULL);
                 goto probe_exit;
+        }
 
         i2s->addr = ioremap(i2s->base, 0x100);
         if (i2s->addr == NULL) {
@@ -963,7 +968,7 @@ static int samsung_i2s_dai_probe(struct snd_soc_dai *dai)
         }
         clk_prepare_enable(i2s->clk);
 
-        snd_soc_dai_init_dma_data(dai, &i2s->dma_playback, &i2s->dma_capture);
+        samsung_asoc_init_dma_data(dai, &i2s->dma_playback, &i2s->dma_capture);
 
         if (other) {
                 other->addr = i2s->addr;
diff --git a/sound/soc/samsung/idma.c b/sound/soc/samsung/idma.c
index e4f318fc2f82..3d5cf1530b6f 100644
--- a/sound/soc/samsung/idma.c
+++ b/sound/soc/samsung/idma.c
@@ -35,14 +35,6 @@ static const struct snd_pcm_hardware idma_hardware = {
                     SNDRV_PCM_INFO_MMAP_VALID |
                     SNDRV_PCM_INFO_PAUSE |
                     SNDRV_PCM_INFO_RESUME,
-        .formats = SNDRV_PCM_FMTBIT_S16_LE |
-                    SNDRV_PCM_FMTBIT_U16_LE |
-                    SNDRV_PCM_FMTBIT_S24_LE |
-                    SNDRV_PCM_FMTBIT_U24_LE |
-                    SNDRV_PCM_FMTBIT_U8 |
-                    SNDRV_PCM_FMTBIT_S8,
-        .channels_min = 2,
-        .channels_max = 2,
         .buffer_bytes_max = MAX_IDMA_BUFFER,
         .period_bytes_min = 128,
         .period_bytes_max = MAX_IDMA_PERIOD,
diff --git a/sound/soc/samsung/pcm.c b/sound/soc/samsung/pcm.c
index e54256fc4b2c..6a5e4bf6ac96 100644
--- a/sound/soc/samsung/pcm.c
+++ b/sound/soc/samsung/pcm.c
@@ -275,7 +275,6 @@ static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(rtd->cpu_dai);
-        struct s3c_dma_params *dma_data;
         void __iomem *regs = pcm->regs;
         struct clk *clk;
         int sclk_div, sync_div;
@@ -284,13 +283,6 @@ static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
 
         dev_dbg(pcm->dev, "Entered %s\n", __func__);
 
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                dma_data = pcm->dma_playback;
-        else
-                dma_data = pcm->dma_capture;
-
-        snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data);
-
         /* Strictly check for sample size */
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -461,10 +453,20 @@ static const struct snd_soc_dai_ops s3c_pcm_dai_ops = {
         .set_fmt        = s3c_pcm_set_fmt,
 };
 
+static int s3c_pcm_dai_probe(struct snd_soc_dai *dai)
+{
+        struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(dai);
+
+        snd_soc_dai_init_dma_data(dai, pcm->dma_playback, pcm->dma_capture);
+
+        return 0;
+}
+
 #define S3C_PCM_RATES  SNDRV_PCM_RATE_8000_96000
 
 #define S3C_PCM_DAI_DECLARE                     \
         .symmetric_rates = 1,                                   \
+        .probe = s3c_pcm_dai_probe,                             \
         .ops = &s3c_pcm_dai_ops,                                \
         .playback = {                                           \
                 .channels_min   = 2,                            \
diff --git a/sound/soc/samsung/regs-ac97.h b/sound/soc/samsung/regs-ac97.h
index c3878f7acb83..a71be45bbffc 100644
--- a/sound/soc/samsung/regs-ac97.h
+++ b/sound/soc/samsung/regs-ac97.h
@@ -1,5 +1,4 @@
-/* arch/arm/mach-s3c2410/include/mach/regs-ac97.h
- *
+/*
  * Copyright (c) 2006 Simtec Electronics <linux@simtec.co.uk>
  *              http://www.simtec.co.uk/products/SWLINUX/
  *
@@ -10,8 +9,8 @@
  * S3C2440 AC97 Controller
 */
 
-#ifndef __ASM_ARCH_REGS_AC97_H
-#define __ASM_ARCH_REGS_AC97_H __FILE__
+#ifndef __SAMSUNG_REGS_AC97_H__
+#define __SAMSUNG_REGS_AC97_H__
 
 #define S3C_AC97_GLBCTRL                                (0x00)
 
@@ -64,4 +63,4 @@
 #define S3C_AC97_PCM_DATA                               (0x18)
 #define S3C_AC97_MIC_DATA                               (0x1C)
 
-#endif /* __ASM_ARCH_REGS_AC97_H */
+#endif /* __SAMSUNG_REGS_AC97_H__ */
diff --git a/sound/soc/samsung/regs-iis.h b/sound/soc/samsung/regs-iis.h
index a18d35e7a735..dc6cbbe9c4f0 100644
--- a/sound/soc/samsung/regs-iis.h
+++ b/sound/soc/samsung/regs-iis.h
@@ -1,5 +1,4 @@
-/* arch/arm/plat-samsung/include/plat/regs-iis.h
- *
+/*
  * Copyright (c) 2003 Simtec Electronics <linux@simtec.co.uk>
  *                    http://www.simtec.co.uk/products/SWLINUX/
  *
@@ -10,8 +9,8 @@
  * S3C2410 IIS register definition
 */
 
-#ifndef __ASM_ARCH_REGS_IIS_H
-#define __ASM_ARCH_REGS_IIS_H
+#ifndef __SAMSUNG_REGS_IIS_H__
+#define __SAMSUNG_REGS_IIS_H__
 
 #define S3C2410_IISCON                  (0x00)
 
@@ -67,4 +66,4 @@
 
 #define S3C2410_IISFIFO                 (0x10)
 
-#endif /* __ASM_ARCH_REGS_IIS_H */
+#endif /* __SAMSUNG_REGS_IIS_H__ */
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index b33ca7cd085b..6101055aae1d 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -232,9 +232,9 @@ struct fsi_stream {
          * these are for DMAEngine
          */
         struct dma_chan         *chan;
-        struct sh_dmae_slave    slave; /* see fsi_handler_init() */
         struct work_struct      work;
         dma_addr_t              dma;
+        int                     dma_id;
         int                     loop_cnt;
         int                     additional_pos;
 };
@@ -1410,15 +1410,6 @@ static void fsi_dma_do_work(struct work_struct *work)
         }
 }
 
-static bool fsi_dma_filter(struct dma_chan *chan, void *param)
-{
-        struct sh_dmae_slave *slave = param;
-
-        chan->private = slave;
-
-        return true;
-}
-
 static int fsi_dma_transfer(struct fsi_priv *fsi, struct fsi_stream *io)
 {
         schedule_work(&io->work);
@@ -1446,15 +1437,34 @@ static int fsi_dma_push_start_stop(struct fsi_priv *fsi, struct fsi_stream *io,
 static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io, struct device *dev)
 {
         dma_cap_mask_t mask;
+        int is_play = fsi_stream_is_play(fsi, io);
 
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
 
-        io->chan = dma_request_channel(mask, fsi_dma_filter, &io->slave);
+        io->chan = dma_request_slave_channel_compat(mask,
+                                shdma_chan_filter, (void *)io->dma_id,
+                                dev, is_play ? "tx" : "rx");
+        if (io->chan) {
+                struct dma_slave_config cfg;
+                int ret;
+
+                cfg.slave_id    = io->dma_id;
+                cfg.dst_addr    = 0; /* use default addr */
+                cfg.src_addr    = 0; /* use default addr */
+                cfg.direction   = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
+
+                ret = dmaengine_slave_config(io->chan, &cfg);
+                if (ret < 0) {
+                        dma_release_channel(io->chan);
+                        io->chan = NULL;
+                }
+        }
+
         if (!io->chan) {
 
                 /* switch to PIO handler */
-                if (fsi_stream_is_play(fsi, io))
+                if (is_play)
                         fsi->playback.handler   = &fsi_pio_push_handler;
                 else
                         fsi->capture.handler    = &fsi_pio_pop_handler;
@@ -1960,7 +1970,7 @@ static void fsi_handler_init(struct fsi_priv *fsi,
         fsi->capture.priv       = fsi;
 
         if (info->tx_id) {
-                fsi->playback.slave.shdma_slave.slave_id = info->tx_id;
+                fsi->playback.dma_id  = info->tx_id;
                 fsi->playback.handler = &fsi_dma_push_handler;
         }
 }
diff --git a/sound/soc/sh/rcar/adg.c b/sound/soc/sh/rcar/adg.c
index 9430097979a5..a53235c4d1b0 100644
--- a/sound/soc/sh/rcar/adg.c
+++ b/sound/soc/sh/rcar/adg.c
@@ -19,8 +19,8 @@
 struct rsnd_adg {
         struct clk *clk[CLKMAX];
 
-        int rate_of_441khz_div_6;
-        int rate_of_48khz_div_6;
+        int rbga_rate_for_441khz_div_6; /* RBGA */
+        int rbgb_rate_for_48khz_div_6;  /* RBGB */
         u32 ckr;
 };
 
@@ -30,41 +30,114 @@ struct rsnd_adg {
              i++, (pos) = adg->clk[i])
 #define rsnd_priv_to_adg(priv) ((struct rsnd_adg *)(priv)->adg)
 
-static enum rsnd_reg rsnd_adg_ssi_reg_get(int id)
+static int rsnd_adg_set_convert_clk_gen1(struct rsnd_priv *priv,
+                                         struct rsnd_mod *mod,
+                                         unsigned int src_rate,
+                                         unsigned int dst_rate)
 {
-        enum rsnd_reg reg;
+        struct rsnd_adg *adg = rsnd_priv_to_adg(priv);
+        struct device *dev = rsnd_priv_to_dev(priv);
+        int idx, sel, div, shift;
+        u32 mask, val;
+        int id = rsnd_mod_id(mod);
+        unsigned int sel_rate [] = {
+                clk_get_rate(adg->clk[CLKA]),   /* 000: CLKA */
+                clk_get_rate(adg->clk[CLKB]),   /* 001: CLKB */
+                clk_get_rate(adg->clk[CLKC]),   /* 010: CLKC */
+                0,                              /* 011: MLBCLK (not used) */
+                adg->rbga_rate_for_441khz_div_6,/* 100: RBGA */
+                adg->rbgb_rate_for_48khz_div_6, /* 101: RBGB */
+        };
+
+        /* find div (= 1/128, 1/256, 1/512, 1/1024, 1/2048 */
+        for (sel = 0; sel < ARRAY_SIZE(sel_rate); sel++) {
+                for (div  = 128,        idx = 0;
+                     div <= 2048;
+                     div *= 2,          idx++) {
+                        if (src_rate == sel_rate[sel] / div) {
+                                val = (idx << 4) | sel;
+                                goto find_rate;
+                        }
+                }
+        }
+        dev_err(dev, "can't find convert src clk\n");
+        return -EINVAL;
+
+find_rate:
+        shift   = (id % 4) * 8;
+        mask    = 0xFF << shift;
+        val     = val << shift;
+
+        dev_dbg(dev, "adg convert src clk = %02x\n", val);
+
+        switch (id / 4) {
+        case 0:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL3, mask, val);
+                break;
+        case 1:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL4, mask, val);
+                break;
+        case 2:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL5, mask, val);
+                break;
+        }
+
+        /*
+         * Gen1 doesn't need dst_rate settings,
+         * since it uses SSI WS pin.
+         * see also rsnd_src_set_route_if_gen1()
+         */
+
+        return 0;
+}
+
+int rsnd_adg_set_convert_clk(struct rsnd_priv *priv,
+                             struct rsnd_mod *mod,
+                             unsigned int src_rate,
+                             unsigned int dst_rate)
+{
+        if (rsnd_is_gen1(priv))
+                return rsnd_adg_set_convert_clk_gen1(priv, mod,
+                                                     src_rate, dst_rate);
+
+        return -EINVAL;
+}
+
+static void rsnd_adg_set_ssi_clk(struct rsnd_mod *mod, u32 val)
+{
+        int id = rsnd_mod_id(mod);
+        int shift = (id % 4) * 8;
+        u32 mask = 0xFF << shift;
+
+        val = val << shift;
 
         /*
          * SSI 8 is not connected to ADG.
          * it works with SSI 7
          */
         if (id == 8)
-                return RSND_REG_MAX;
-
-        if (0 <= id && id <= 3)
-                reg = RSND_REG_AUDIO_CLK_SEL0;
-        else if (4 <= id && id <= 7)
-                reg = RSND_REG_AUDIO_CLK_SEL1;
-        else
-                reg = RSND_REG_AUDIO_CLK_SEL2;
-
-        return reg;
+                return;
+
+        switch (id / 4) {
+        case 0:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL0, mask, val);
+                break;
+        case 1:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL1, mask, val);
+                break;
+        case 2:
+                rsnd_mod_bset(mod, AUDIO_CLK_SEL2, mask, val);
+                break;
+        }
 }
 
 int rsnd_adg_ssi_clk_stop(struct rsnd_mod *mod)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
-        enum rsnd_reg reg;
-        int id;
-
         /*
          * "mod" = "ssi" here.
          * we can get "ssi id" from mod
          */
-        id  = rsnd_mod_id(mod);
-        reg = rsnd_adg_ssi_reg_get(id);
-
-        rsnd_write(priv, mod, reg, 0);
+        rsnd_adg_set_ssi_clk(mod, 0);
 
         return 0;
 }
@@ -75,8 +148,7 @@ int rsnd_adg_ssi_clk_try_start(struct rsnd_mod *mod, unsigned int rate)
         struct rsnd_adg *adg = rsnd_priv_to_adg(priv);
         struct device *dev = rsnd_priv_to_dev(priv);
         struct clk *clk;
-        enum rsnd_reg reg;
-        int id, shift, i;
+        int i;
         u32 data;
         int sel_table[] = {
                 [CLKA] = 0x1,
@@ -102,12 +174,12 @@ int rsnd_adg_ssi_clk_try_start(struct rsnd_mod *mod, unsigned int rate)
         /*
          * find 1/6 clock from BRGA/BRGB
          */
-        if (rate == adg->rate_of_441khz_div_6) {
+        if (rate == adg->rbga_rate_for_441khz_div_6) {
                 data = 0x10;
                 goto found_clock;
         }
 
-        if (rate == adg->rate_of_48khz_div_6) {
+        if (rate == adg->rbgb_rate_for_48khz_div_6) {
                 data = 0x20;
                 goto found_clock;
         }
@@ -125,19 +197,10 @@ found_clock:
          * This "mod" = "ssi" here.
          * we can get "ssi id" from mod
          */
-        id  = rsnd_mod_id(mod);
-        reg = rsnd_adg_ssi_reg_get(id);
-
-        dev_dbg(dev, "ADG: ssi%d selects clk%d = %d", id, i, rate);
-
-        /*
-         * Enable SSIx clock
-         */
-        shift = (id % 4) * 8;
+        rsnd_adg_set_ssi_clk(mod, data);
 
-        rsnd_bset(priv, mod, reg,
-                   0xFF << shift,
-                   data << shift);
+        dev_dbg(dev, "ADG: ssi%d selects clk%d = %d",
+                rsnd_mod_id(mod), i, rate);
 
         return 0;
 }
@@ -166,8 +229,8 @@ static void rsnd_adg_ssi_clk_init(struct rsnd_priv *priv, struct rsnd_adg *adg)
          *      rsnd_adg_ssi_clk_try_start()
          */
         ckr = 0;
-        adg->rate_of_441khz_div_6 = 0;
-        adg->rate_of_48khz_div_6  = 0;
+        adg->rbga_rate_for_441khz_div_6 = 0;
+        adg->rbgb_rate_for_48khz_div_6  = 0;
         for_each_rsnd_clk(clk, adg, i) {
                 rate = clk_get_rate(clk);
 
@@ -175,14 +238,14 @@ static void rsnd_adg_ssi_clk_init(struct rsnd_priv *priv, struct rsnd_adg *adg)
                         continue;
 
                 /* RBGA */
-                if (!adg->rate_of_441khz_div_6 && (0 == rate % 44100)) {
-                        adg->rate_of_441khz_div_6 = rate / 6;
+                if (!adg->rbga_rate_for_441khz_div_6 && (0 == rate % 44100)) {
+                        adg->rbga_rate_for_441khz_div_6 = rate / 6;
                         ckr |= brg_table[i] << 20;
                 }
 
                 /* RBGB */
-                if (!adg->rate_of_48khz_div_6 && (0 == rate % 48000)) {
-                        adg->rate_of_48khz_div_6 = rate / 6;
+                if (!adg->rbgb_rate_for_48khz_div_6 && (0 == rate % 48000)) {
+                        adg->rbgb_rate_for_48khz_div_6 = rate / 6;
                         ckr |= brg_table[i] << 16;
                 }
         }
diff --git a/sound/soc/sh/rcar/gen.c b/sound/soc/sh/rcar/gen.c
index 61212ee97c28..add088bd4b2a 100644
--- a/sound/soc/sh/rcar/gen.c
+++ b/sound/soc/sh/rcar/gen.c
@@ -10,20 +10,6 @@
  */
 #include "rsnd.h"
 
-struct rsnd_gen_ops {
-        int (*probe)(struct platform_device *pdev,
-                     struct rcar_snd_info *info,
-                     struct rsnd_priv *priv);
-        void (*remove)(struct platform_device *pdev,
-                      struct rsnd_priv *priv);
-        int (*path_init)(struct rsnd_priv *priv,
-                         struct rsnd_dai *rdai,
-                         struct rsnd_dai_stream *io);
-        int (*path_exit)(struct rsnd_priv *priv,
-                         struct rsnd_dai *rdai,
-                         struct rsnd_dai_stream *io);
-};
-
 struct rsnd_gen {
         void __iomem *base[RSND_BASE_MAX];
 
@@ -86,12 +72,28 @@ static struct regmap_bus rsnd_regmap_bus = {
         .val_format_endian_default      = REGMAP_ENDIAN_NATIVE,
 };
 
+static int rsnd_is_accessible_reg(struct rsnd_priv *priv,
+                                  struct rsnd_gen *gen, enum rsnd_reg reg)
+{
+        if (!gen->regs[reg]) {
+                struct device *dev = rsnd_priv_to_dev(priv);
+
+                dev_err(dev, "unsupported register access %x\n", reg);
+                return 0;
+        }
+
+        return 1;
+}
+
 u32 rsnd_read(struct rsnd_priv *priv,
               struct rsnd_mod *mod, enum rsnd_reg reg)
 {
         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
         u32 val;
 
+        if (!rsnd_is_accessible_reg(priv, gen, reg))
+                return 0;
+
         regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val);
 
         return val;
@@ -103,6 +105,9 @@ void rsnd_write(struct rsnd_priv *priv,
 {
         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
 
+        if (!rsnd_is_accessible_reg(priv, gen, reg))
+                return;
+
         regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data);
 }
 
@@ -111,21 +116,48 @@ void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod,
 {
         struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
 
+        if (!rsnd_is_accessible_reg(priv, gen, reg))
+                return;
+
         regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),
                                   mask, data);
 }
 
-/*
- *              Gen2
- *              will be filled in the future
- */
+static int rsnd_gen_regmap_init(struct rsnd_priv *priv,
+                                struct rsnd_gen  *gen,
+                                struct reg_field *regf)
+{
+        int i;
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct regmap_config regc;
 
-/*
- *              Gen1
- */
-static int rsnd_gen1_path_init(struct rsnd_priv *priv,
-                               struct rsnd_dai *rdai,
-                               struct rsnd_dai_stream *io)
+        memset(&regc, 0, sizeof(regc));
+        regc.reg_bits = 32;
+        regc.val_bits = 32;
+
+        gen->regmap = devm_regmap_init(dev, &rsnd_regmap_bus, priv, &regc);
+        if (IS_ERR(gen->regmap)) {
+                dev_err(dev, "regmap error %ld\n", PTR_ERR(gen->regmap));
+                return PTR_ERR(gen->regmap);
+        }
+
+        for (i = 0; i < RSND_REG_MAX; i++) {
+                gen->regs[i] = NULL;
+                if (!regf[i].reg)
+                        continue;
+
+                gen->regs[i] = devm_regmap_field_alloc(dev, gen->regmap, regf[i]);
+                if (IS_ERR(gen->regs[i]))
+                        return PTR_ERR(gen->regs[i]);
+
+        }
+
+        return 0;
+}
+
+int rsnd_gen_path_init(struct rsnd_priv *priv,
+                       struct rsnd_dai *rdai,
+                       struct rsnd_dai_stream *io)
 {
         struct rsnd_mod *mod;
         int ret;
@@ -163,9 +195,9 @@ static int rsnd_gen1_path_init(struct rsnd_priv *priv,
         return ret;
 }
 
-static int rsnd_gen1_path_exit(struct rsnd_priv *priv,
-                               struct rsnd_dai *rdai,
-                               struct rsnd_dai_stream *io)
+int rsnd_gen_path_exit(struct rsnd_priv *priv,
+                       struct rsnd_dai *rdai,
+                       struct rsnd_dai_stream *io)
 {
         struct rsnd_mod *mod, *n;
         int ret = 0;
@@ -179,6 +211,94 @@ static int rsnd_gen1_path_exit(struct rsnd_priv *priv,
         return ret;
 }
 
+/*
+ *              Gen2
+ */
+
+/* single address mapping */
+#define RSND_GEN2_S_REG(gen, reg, id, offset)                           \
+        RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, 0, 10)
+
+/* multi address mapping */
+#define RSND_GEN2_M_REG(gen, reg, id, offset, _id_offset)               \
+        RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN2_##reg, offset, _id_offset, 10)
+
+static int rsnd_gen2_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
+{
+        struct reg_field regf[RSND_REG_MAX] = {
+                RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE0,      0x800),
+                RSND_GEN2_S_REG(gen, SSIU,      SSI_MODE1,      0x804),
+                /* FIXME: it needs SSI_MODE2/3 in the future */
+                RSND_GEN2_M_REG(gen, SSIU,      INT_ENABLE,     0x18,   0x80),
+
+                RSND_GEN2_S_REG(gen, ADG,       BRRA,           0x00),
+                RSND_GEN2_S_REG(gen, ADG,       BRRB,           0x04),
+                RSND_GEN2_S_REG(gen, ADG,       SSICKR,         0x08),
+                RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL0, 0x0c),
+                RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL1, 0x10),
+                RSND_GEN2_S_REG(gen, ADG,       AUDIO_CLK_SEL2, 0x14),
+
+                RSND_GEN2_M_REG(gen, SSI,       SSICR,          0x00,   0x40),
+                RSND_GEN2_M_REG(gen, SSI,       SSISR,          0x04,   0x40),
+                RSND_GEN2_M_REG(gen, SSI,       SSITDR,         0x08,   0x40),
+                RSND_GEN2_M_REG(gen, SSI,       SSIRDR,         0x0c,   0x40),
+                RSND_GEN2_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
+        };
+
+        return rsnd_gen_regmap_init(priv, gen, regf);
+}
+
+static int rsnd_gen2_probe(struct platform_device *pdev,
+                           struct rcar_snd_info *info,
+                           struct rsnd_priv *priv)
+{
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
+        struct resource *scu_res;
+        struct resource *adg_res;
+        struct resource *ssiu_res;
+        struct resource *ssi_res;
+        int ret;
+
+        /*
+         * map address
+         */
+        scu_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SCU);
+        adg_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_ADG);
+        ssiu_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSIU);
+        ssi_res  = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN2_SSI);
+
+        gen->base[RSND_GEN2_SCU]  = devm_ioremap_resource(dev, scu_res);
+        gen->base[RSND_GEN2_ADG]  = devm_ioremap_resource(dev, adg_res);
+        gen->base[RSND_GEN2_SSIU] = devm_ioremap_resource(dev, ssiu_res);
+        gen->base[RSND_GEN2_SSI]  = devm_ioremap_resource(dev, ssi_res);
+        if (IS_ERR(gen->base[RSND_GEN2_SCU])  ||
+            IS_ERR(gen->base[RSND_GEN2_ADG])  ||
+            IS_ERR(gen->base[RSND_GEN2_SSIU]) ||
+            IS_ERR(gen->base[RSND_GEN2_SSI]))
+                return -ENODEV;
+
+        ret = rsnd_gen2_regmap_init(priv, gen);
+        if (ret < 0)
+                return ret;
+
+        dev_dbg(dev, "Gen2 device probed\n");
+        dev_dbg(dev, "SRU  : %08x => %p\n", scu_res->start,
+                gen->base[RSND_GEN2_SCU]);
+        dev_dbg(dev, "ADG  : %08x => %p\n", adg_res->start,
+                gen->base[RSND_GEN2_ADG]);
+        dev_dbg(dev, "SSIU : %08x => %p\n", ssiu_res->start,
+                gen->base[RSND_GEN2_SSIU]);
+        dev_dbg(dev, "SSI  : %08x => %p\n", ssi_res->start,
+                gen->base[RSND_GEN2_SSI]);
+
+        return 0;
+}
+
+/*
+ *              Gen1
+ */
+
 /* single address mapping */
 #define RSND_GEN1_S_REG(gen, reg, id, offset)   \
         RSND_REG_SET(gen, RSND_REG_##id, RSND_GEN1_##reg, offset, 0, 9)
@@ -189,19 +309,23 @@ static int rsnd_gen1_path_exit(struct rsnd_priv *priv,
 
 static int rsnd_gen1_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
 {
-        int i;
-        struct device *dev = rsnd_priv_to_dev(priv);
-        struct regmap_config regc;
         struct reg_field regf[RSND_REG_MAX] = {
                 RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_SEL,  0x00),
                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL0,   0x08),
                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL1,   0x0c),
                 RSND_GEN1_S_REG(gen, SRU,       SRC_TMG_SEL2,   0x10),
-                RSND_GEN1_S_REG(gen, SRU,       SRC_CTRL,       0xc0),
+                RSND_GEN1_S_REG(gen, SRU,       SRC_ROUTE_CTRL, 0xc0),
                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE0,      0xD0),
                 RSND_GEN1_S_REG(gen, SRU,       SSI_MODE1,      0xD4),
                 RSND_GEN1_M_REG(gen, SRU,       BUSIF_MODE,     0x20,   0x4),
-                RSND_GEN1_M_REG(gen, SRU,       BUSIF_ADINR,    0x214,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_ROUTE_MODE0,0x50,   0x8),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_SWRSR,      0x200,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_SRCIR,      0x204,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_ADINR,      0x214,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_IFSCR,      0x21c,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_IFSVR,      0x220,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_SRCCR,      0x224,  0x40),
+                RSND_GEN1_M_REG(gen, SRU,       SRC_MNFSR,      0x228,  0x40),
 
                 RSND_GEN1_S_REG(gen, ADG,       BRRA,           0x00),
                 RSND_GEN1_S_REG(gen, ADG,       BRRB,           0x04),
@@ -219,24 +343,7 @@ static int rsnd_gen1_regmap_init(struct rsnd_priv *priv, struct rsnd_gen *gen)
                 RSND_GEN1_M_REG(gen, SSI,       SSIWSR,         0x20,   0x40),
         };
 
-        memset(&regc, 0, sizeof(regc));
-        regc.reg_bits = 32;
-        regc.val_bits = 32;
-
-        gen->regmap = devm_regmap_init(dev, &rsnd_regmap_bus, priv, &regc);
-        if (IS_ERR(gen->regmap)) {
-                dev_err(dev, "regmap error %ld\n", PTR_ERR(gen->regmap));
-                return PTR_ERR(gen->regmap);
-        }
-
-        for (i = 0; i < RSND_REG_MAX; i++) {
-                gen->regs[i] = devm_regmap_field_alloc(dev, gen->regmap, regf[i]);
-                if (IS_ERR(gen->regs[i]))
-                        return PTR_ERR(gen->regs[i]);
-
-        }
-
-        return 0;
+        return rsnd_gen_regmap_init(priv, gen, regf);
 }
 
 static int rsnd_gen1_probe(struct platform_device *pdev,
@@ -281,45 +388,16 @@ static int rsnd_gen1_probe(struct platform_device *pdev,
 
 }
 
-static void rsnd_gen1_remove(struct platform_device *pdev,
-                             struct rsnd_priv *priv)
-{
-}
-
-static struct rsnd_gen_ops rsnd_gen1_ops = {
-        .probe          = rsnd_gen1_probe,
-        .remove         = rsnd_gen1_remove,
-        .path_init      = rsnd_gen1_path_init,
-        .path_exit      = rsnd_gen1_path_exit,
-};
-
 /*
  *              Gen
  */
-int rsnd_gen_path_init(struct rsnd_priv *priv,
-                       struct rsnd_dai *rdai,
-                       struct rsnd_dai_stream *io)
-{
-        struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
-
-        return gen->ops->path_init(priv, rdai, io);
-}
-
-int rsnd_gen_path_exit(struct rsnd_priv *priv,
-                       struct rsnd_dai *rdai,
-                       struct rsnd_dai_stream *io)
-{
-        struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
-
-        return gen->ops->path_exit(priv, rdai, io);
-}
-
 int rsnd_gen_probe(struct platform_device *pdev,
                    struct rcar_snd_info *info,
                    struct rsnd_priv *priv)
 {
         struct device *dev = rsnd_priv_to_dev(priv);
         struct rsnd_gen *gen;
+        int ret;
 
         gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
         if (!gen) {
@@ -327,23 +405,21 @@ int rsnd_gen_probe(struct platform_device *pdev,
                 return -ENOMEM;
         }
 
+        priv->gen = gen;
+
+        ret = -ENODEV;
         if (rsnd_is_gen1(priv))
-                gen->ops = &rsnd_gen1_ops;
+                ret = rsnd_gen1_probe(pdev, info, priv);
+        else if (rsnd_is_gen2(priv))
+                ret = rsnd_gen2_probe(pdev, info, priv);
 
-        if (!gen->ops) {
+        if (ret < 0)
                 dev_err(dev, "unknown generation R-Car sound device\n");
-                return -ENODEV;
-        }
-
-        priv->gen = gen;
 
-        return gen->ops->probe(pdev, info, priv);
+        return ret;
 }
 
 void rsnd_gen_remove(struct platform_device *pdev,
                      struct rsnd_priv *priv)
 {
-        struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
-
-        gen->ops->remove(pdev, priv);
 }
diff --git a/sound/soc/sh/rcar/rsnd.h b/sound/soc/sh/rcar/rsnd.h
index 9e463e50e7e6..4ca66cd899c8 100644
--- a/sound/soc/sh/rcar/rsnd.h
+++ b/sound/soc/sh/rcar/rsnd.h
@@ -31,16 +31,24 @@
  * see gen1/gen2 for detail
  */
 enum rsnd_reg {
-        /* SRU/SCU */
-        RSND_REG_SRC_ROUTE_SEL,
-        RSND_REG_SRC_TMG_SEL0,
-        RSND_REG_SRC_TMG_SEL1,
-        RSND_REG_SRC_TMG_SEL2,
-        RSND_REG_SRC_CTRL,
+        /* SRU/SCU/SSIU */
+        RSND_REG_SRC_ROUTE_SEL,         /* for Gen1 */
+        RSND_REG_SRC_TMG_SEL0,          /* for Gen1 */
+        RSND_REG_SRC_TMG_SEL1,          /* for Gen1 */
+        RSND_REG_SRC_TMG_SEL2,          /* for Gen1 */
+        RSND_REG_SRC_ROUTE_CTRL,        /* for Gen1 */
         RSND_REG_SSI_MODE0,
         RSND_REG_SSI_MODE1,
         RSND_REG_BUSIF_MODE,
-        RSND_REG_BUSIF_ADINR,
+        RSND_REG_INT_ENABLE,            /* for Gen2 */
+        RSND_REG_SRC_ROUTE_MODE0,
+        RSND_REG_SRC_SWRSR,
+        RSND_REG_SRC_SRCIR,
+        RSND_REG_SRC_ADINR,
+        RSND_REG_SRC_IFSCR,
+        RSND_REG_SRC_IFSVR,
+        RSND_REG_SRC_SRCCR,
+        RSND_REG_SRC_MNFSR,
 
         /* ADG */
         RSND_REG_BRRA,
@@ -49,9 +57,9 @@ enum rsnd_reg {
         RSND_REG_AUDIO_CLK_SEL0,
         RSND_REG_AUDIO_CLK_SEL1,
         RSND_REG_AUDIO_CLK_SEL2,
-        RSND_REG_AUDIO_CLK_SEL3,
-        RSND_REG_AUDIO_CLK_SEL4,
-        RSND_REG_AUDIO_CLK_SEL5,
+        RSND_REG_AUDIO_CLK_SEL3,        /* for Gen1 */
+        RSND_REG_AUDIO_CLK_SEL4,        /* for Gen1 */
+        RSND_REG_AUDIO_CLK_SEL5,        /* for Gen1 */
 
         /* SSI */
         RSND_REG_SSICR,
@@ -174,11 +182,11 @@ struct rsnd_dai {
         struct rsnd_dai_stream playback;
         struct rsnd_dai_stream capture;
 
-        int clk_master:1;
-        int bit_clk_inv:1;
-        int frm_clk_inv:1;
-        int sys_delay:1;
-        int data_alignment:1;
+        unsigned int clk_master:1;
+        unsigned int bit_clk_inv:1;
+        unsigned int frm_clk_inv:1;
+        unsigned int sys_delay:1;
+        unsigned int data_alignment:1;
 };
 
 #define rsnd_dai_nr(priv) ((priv)->dai_nr)
@@ -229,6 +237,10 @@ int rsnd_adg_probe(struct platform_device *pdev,
                    struct rsnd_priv *priv);
 void rsnd_adg_remove(struct platform_device *pdev,
                    struct rsnd_priv *priv);
+int rsnd_adg_set_convert_clk(struct rsnd_priv *priv,
+                             struct rsnd_mod *mod,
+                             unsigned int src_rate,
+                             unsigned int dst_rate);
 
 /*
  *      R-Car sound priv
@@ -282,6 +294,10 @@ void rsnd_scu_remove(struct platform_device *pdev,
                      struct rsnd_priv *priv);
 struct rsnd_mod *rsnd_scu_mod_get(struct rsnd_priv *priv, int id);
 bool rsnd_scu_hpbif_is_enable(struct rsnd_mod *mod);
+unsigned int rsnd_scu_get_ssi_rate(struct rsnd_priv *priv,
+                                   struct rsnd_mod *ssi_mod,
+                                   struct snd_pcm_runtime *runtime);
+
 #define rsnd_scu_nr(priv) ((priv)->scu_nr)
 
 /*
diff --git a/sound/soc/sh/rcar/scu.c b/sound/soc/sh/rcar/scu.c
index fa8fa15860b9..9bb08bb1d455 100644
--- a/sound/soc/sh/rcar/scu.c
+++ b/sound/soc/sh/rcar/scu.c
@@ -13,9 +13,13 @@
 struct rsnd_scu {
         struct rsnd_scu_platform_info *info; /* rcar_snd.h */
         struct rsnd_mod mod;
+        struct clk *clk;
 };
 
 #define rsnd_scu_mode_flags(p) ((p)->info->flags)
+#define rsnd_scu_convert_rate(p) ((p)->info->convert_rate)
+
+#define RSND_SCU_NAME_SIZE 16
 
 /*
  * ADINR
@@ -26,6 +30,15 @@ struct rsnd_scu {
 #define OTBL_18         (6 << 16)
 #define OTBL_16         (8 << 16)
 
+/*
+ *              image of SRC (Sampling Rate Converter)
+ *
+ * 96kHz   <-> +-----+  48kHz   +-----+  48kHz  +-------+
+ * 48kHz   <-> | SRC | <------> | SSI | <-----> | codec |
+ * 44.1kHz <-> +-----+          +-----+         +-------+
+ * ...
+ *
+ */
 
 #define rsnd_mod_to_scu(_mod)   \
         container_of((_mod), struct rsnd_scu, mod)
@@ -36,7 +49,8 @@ struct rsnd_scu {
                      ((pos) = (struct rsnd_scu *)(priv)->scu + i);      \
              i++)
 
-static int rsnd_scu_set_route(struct rsnd_priv *priv,
+/* Gen1 only */
+static int rsnd_src_set_route_if_gen1(struct rsnd_priv *priv,
                               struct rsnd_mod *mod,
                               struct rsnd_dai *rdai,
                               struct rsnd_dai_stream *io)
@@ -55,7 +69,7 @@ static int rsnd_scu_set_route(struct rsnd_priv *priv,
                 { 0x3, 28, }, /* 7 */
                 { 0x3, 30, }, /* 8 */
         };
-
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
         u32 mask;
         u32 val;
         int shift;
@@ -85,9 +99,18 @@ static int rsnd_scu_set_route(struct rsnd_priv *priv,
          */
         shift   = (id % 4) * 8;
         mask    = 0x1F << shift;
-        if (8 == id) /* SRU8 is very special */
+
+        /*
+         * ADG is used as source clock if SRC was used,
+         * then, SSI WS is used as destination clock.
+         * SSI WS is used as source clock if SRC is not used
+         * (when playback, source/destination become reverse when capture)
+         */
+        if (rsnd_scu_convert_rate(scu)) /* use ADG */
+                val = 0;
+        else if (8 == id)               /* use SSI WS, but SRU8 is special */
                 val = id << shift;
-        else
+        else                            /* use SSI WS */
                 val = (id + 1) << shift;
 
         switch (id / 4) {
@@ -105,30 +128,45 @@ static int rsnd_scu_set_route(struct rsnd_priv *priv,
         return 0;
 }
 
-static int rsnd_scu_set_mode(struct rsnd_priv *priv,
-                             struct rsnd_mod *mod,
-                             struct rsnd_dai *rdai,
-                             struct rsnd_dai_stream *io)
+unsigned int rsnd_scu_get_ssi_rate(struct rsnd_priv *priv,
+                                   struct rsnd_mod *ssi_mod,
+                                   struct snd_pcm_runtime *runtime)
 {
-        int id = rsnd_mod_id(mod);
-        u32 val;
+        struct rsnd_scu *scu;
+        unsigned int rate;
 
-        if (rsnd_is_gen1(priv)) {
-                val = (1 << id);
-                rsnd_mod_bset(mod, SRC_CTRL, val, val);
-        }
+        /* this function is assuming SSI id = SCU id here */
+        scu = rsnd_mod_to_scu(rsnd_scu_mod_get(priv, rsnd_mod_id(ssi_mod)));
 
-        return 0;
+        /*
+         * return convert rate if SRC is used,
+         * otherwise, return runtime->rate as usual
+         */
+        rate = rsnd_scu_convert_rate(scu);
+        if (!rate)
+                rate = runtime->rate;
+
+        return rate;
 }
 
-static int rsnd_scu_set_hpbif(struct rsnd_priv *priv,
+static int rsnd_scu_convert_rate_ctrl(struct rsnd_priv *priv,
                               struct rsnd_mod *mod,
                               struct rsnd_dai *rdai,
                               struct rsnd_dai_stream *io)
 {
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
+        u32 convert_rate = rsnd_scu_convert_rate(scu);
         u32 adinr = runtime->channels;
 
+        /* set/clear soft reset */
+        rsnd_mod_write(mod, SRC_SWRSR, 0);
+        rsnd_mod_write(mod, SRC_SWRSR, 1);
+
+        /* Initialize the operation of the SRC internal circuits */
+        rsnd_mod_write(mod, SRC_SRCIR, 1);
+
+        /* Set channel number and output bit length */
         switch (runtime->sample_bits) {
         case 16:
                 adinr |= OTBL_16;
@@ -139,9 +177,81 @@ static int rsnd_scu_set_hpbif(struct rsnd_priv *priv,
         default:
                 return -EIO;
         }
+        rsnd_mod_write(mod, SRC_ADINR, adinr);
+
+        if (convert_rate) {
+                u32 fsrate = 0x0400000 / convert_rate * runtime->rate;
+                int ret;
+
+                /* Enable the initial value of IFS */
+                rsnd_mod_write(mod, SRC_IFSCR, 1);
+
+                /* Set initial value of IFS */
+                rsnd_mod_write(mod, SRC_IFSVR, fsrate);
+
+                /* Select SRC mode (fixed value) */
+                rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
+
+                /* Set the restriction value of the FS ratio (98%) */
+                rsnd_mod_write(mod, SRC_MNFSR, fsrate / 100 * 98);
+
+                if (rsnd_is_gen1(priv)) {
+                        /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
+                }
 
+                /* set convert clock */
+                ret = rsnd_adg_set_convert_clk(priv, mod,
+                                               runtime->rate,
+                                               convert_rate);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /* Cancel the initialization and operate the SRC function */
+        rsnd_mod_write(mod, SRC_SRCIR, 0);
+
+        /* use DMA transfer */
         rsnd_mod_write(mod, BUSIF_MODE, 1);
-        rsnd_mod_write(mod, BUSIF_ADINR, adinr);
+
+        return 0;
+}
+
+static int rsnd_scu_transfer_start(struct rsnd_priv *priv,
+                                   struct rsnd_mod *mod,
+                                   struct rsnd_dai *rdai,
+                                   struct rsnd_dai_stream *io)
+{
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
+        int id = rsnd_mod_id(mod);
+        u32 val;
+
+        if (rsnd_is_gen1(priv)) {
+                val = (1 << id);
+                rsnd_mod_bset(mod, SRC_ROUTE_CTRL, val, val);
+        }
+
+        if (rsnd_scu_convert_rate(scu))
+                rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
+
+        return 0;
+}
+
+static int rsnd_scu_transfer_stop(struct rsnd_priv *priv,
+                                  struct rsnd_mod *mod,
+                                  struct rsnd_dai *rdai,
+                                  struct rsnd_dai_stream *io)
+{
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
+        int id = rsnd_mod_id(mod);
+        u32 mask;
+
+        if (rsnd_is_gen1(priv)) {
+                mask = (1 << id);
+                rsnd_mod_bset(mod, SRC_ROUTE_CTRL, mask, 0);
+        }
+
+        if (rsnd_scu_convert_rate(scu))
+                rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0);
 
         return 0;
 }
@@ -159,6 +269,7 @@ static int rsnd_scu_start(struct rsnd_mod *mod,
                           struct rsnd_dai_stream *io)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
         int ret;
 
@@ -173,16 +284,19 @@ static int rsnd_scu_start(struct rsnd_mod *mod,
                 return 0;
         }
 
+        clk_enable(scu->clk);
+
         /* it use DMA transter */
-        ret = rsnd_scu_set_route(priv, mod, rdai, io);
+
+        ret = rsnd_src_set_route_if_gen1(priv, mod, rdai, io);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_scu_set_mode(priv, mod, rdai, io);
+        ret = rsnd_scu_convert_rate_ctrl(priv, mod, rdai, io);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_scu_set_hpbif(priv, mod, rdai, io);
+        ret = rsnd_scu_transfer_start(priv, mod, rdai, io);
         if (ret < 0)
                 return ret;
 
@@ -191,9 +305,27 @@ static int rsnd_scu_start(struct rsnd_mod *mod,
         return 0;
 }
 
+static int rsnd_scu_stop(struct rsnd_mod *mod,
+                          struct rsnd_dai *rdai,
+                          struct rsnd_dai_stream *io)
+{
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
+
+        if (!rsnd_scu_hpbif_is_enable(mod))
+                return 0;
+
+        rsnd_scu_transfer_stop(priv, mod, rdai, io);
+
+        clk_disable(scu->clk);
+
+        return 0;
+}
+
 static struct rsnd_mod_ops rsnd_scu_ops = {
         .name   = "scu",
         .start  = rsnd_scu_start,
+        .stop   = rsnd_scu_stop,
 };
 
 struct rsnd_mod *rsnd_scu_mod_get(struct rsnd_priv *priv, int id)
@@ -210,6 +342,8 @@ int rsnd_scu_probe(struct platform_device *pdev,
 {
         struct device *dev = rsnd_priv_to_dev(priv);
         struct rsnd_scu *scu;
+        struct clk *clk;
+        char name[RSND_SCU_NAME_SIZE];
         int i, nr;
 
         /*
@@ -226,9 +360,16 @@ int rsnd_scu_probe(struct platform_device *pdev,
         priv->scu       = scu;
 
         for_each_rsnd_scu(scu, priv, i) {
+                snprintf(name, RSND_SCU_NAME_SIZE, "scu.%d", i);
+
+                clk = devm_clk_get(dev, name);
+                if (IS_ERR(clk))
+                        return PTR_ERR(clk);
+
                 rsnd_mod_init(priv, &scu->mod,
                               &rsnd_scu_ops, i);
                 scu->info = &info->scu_info[i];
+                scu->clk = clk;
 
                 dev_dbg(dev, "SCU%d probed\n", i);
         }
diff --git a/sound/soc/sh/rcar/ssi.c b/sound/soc/sh/rcar/ssi.c
index 5ac20cd5e006..4b8cf7ca9d19 100644
--- a/sound/soc/sh/rcar/ssi.c
+++ b/sound/soc/sh/rcar/ssi.c
@@ -187,9 +187,10 @@ static void rsnd_ssi_status_check(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
-                                     unsigned int rate)
+                                     struct rsnd_dai_stream *io)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
+        struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         int i, j, ret;
         int adg_clk_div_table[] = {
@@ -199,6 +200,7 @@ static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
                 1, 2, 4, 8, 16, 6, 12,
         };
         unsigned int main_rate;
+        unsigned int rate = rsnd_scu_get_ssi_rate(priv, &ssi->mod, runtime);
 
         /*
          * Find best clock, and try to start ADG
@@ -209,7 +211,7 @@ static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
                         /*
                          * this driver is assuming that
                          * system word is 64fs (= 2 x 32bit)
-                         * see rsnd_ssi_start()
+                         * see rsnd_ssi_init()
                          */
                         main_rate = rate / adg_clk_div_table[i]
                                 * 32 * 2 * ssi_clk_mul_table[j];
@@ -251,14 +253,10 @@ static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
                 clk_enable(ssi->clk);
 
                 if (rsnd_rdai_is_clk_master(rdai)) {
-                        struct snd_pcm_runtime *runtime;
-
-                        runtime = rsnd_io_to_runtime(io);
-
                         if (rsnd_ssi_clk_from_parent(ssi))
                                 rsnd_ssi_hw_start(ssi->parent, rdai, io);
                         else
-                                rsnd_ssi_master_clk_start(ssi, runtime->rate);
+                                rsnd_ssi_master_clk_start(ssi, io);
                 }
         }
 
@@ -457,6 +455,10 @@ static int rsnd_ssi_pio_start(struct rsnd_mod *mod,
         /* enable PIO IRQ */
         ssi->cr_etc = UIEN | OIEN | DIEN;
 
+        /* enable PIO interrupt if gen2 */
+        if (rsnd_is_gen2(priv))
+                rsnd_mod_write(&ssi->mod, INT_ENABLE, 0x0f000000);
+
         rsnd_ssi_hw_start(ssi, rdai, io);
 
         dev_dbg(dev, "%s.%d start\n", rsnd_mod_name(mod), rsnd_mod_id(mod));
@@ -650,7 +652,7 @@ int rsnd_ssi_probe(struct platform_device *pdev,
 
                 snprintf(name, RSND_SSI_NAME_SIZE, "ssi.%d", i);
 
-                clk = clk_get(dev, name);
+                clk = devm_clk_get(dev, name);
                 if (IS_ERR(clk))
                         return PTR_ERR(clk);
 
@@ -711,7 +713,6 @@ void rsnd_ssi_remove(struct platform_device *pdev,
         int i;
 
         for_each_rsnd_ssi(ssi, priv, i) {
-                clk_put(ssi->clk);
                 if (rsnd_ssi_dma_available(ssi))
                         rsnd_dma_quit(priv, rsnd_mod_to_dma(&ssi->mod));
         }
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index a66783e13a9c..be88df5eeaf7 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -4617,10 +4617,14 @@ int snd_soc_of_get_dai_name(struct device_node *of_node,
 
                         if (id < 0 || id >= pos->num_dai) {
                                 ret = -EINVAL;
-                        } else {
-                                *dai_name = pos->dai_drv[id].name;
-                                ret = 0;
+                                break;
                         }
+
+                        ret = 0;
+
+                        *dai_name = pos->dai_drv[id].name;
+                        if (!*dai_name)
+                                *dai_name = pos->name;
                 }
 
                 break;
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index dcade130157f..67e63ab1f11e 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -2868,6 +2868,7 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
         unsigned int val;
         int connect, change;
         struct snd_soc_dapm_update update;
+        int ret = 0;
 
         if (snd_soc_volsw_is_stereo(mc))
                 dev_warn(codec->dapm.dev,
@@ -2901,12 +2902,16 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
                         card->update = &update;
                 }
 
-                soc_dapm_mixer_update_power(card, kcontrol, connect);
+                ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
 
                 card->update = NULL;
         }
 
         mutex_unlock(&card->dapm_mutex);
+
+        if (ret > 0)
+                soc_dpcm_runtime_update(card);
+
         return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
@@ -2955,6 +2960,7 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
         unsigned int val, mux, change;
         unsigned int mask;
         struct snd_soc_dapm_update update;
+        int ret = 0;
 
         if (ucontrol->value.enumerated.item[0] > e->max - 1)
                 return -EINVAL;
@@ -2978,12 +2984,16 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
                 update.val = val;
                 card->update = &update;
 
-                soc_dapm_mux_update_power(card, kcontrol, mux, e);
+                ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
 
                 card->update = NULL;
         }
 
         mutex_unlock(&card->dapm_mutex);
+
+        if (ret > 0)
+                soc_dpcm_runtime_update(card);
+
         return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
@@ -3019,6 +3029,7 @@ int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
         struct soc_enum *e =
                 (struct soc_enum *)kcontrol->private_value;
         int change;
+        int ret = 0;
 
         if (ucontrol->value.enumerated.item[0] >= e->max)
                 return -EINVAL;
@@ -3028,9 +3039,13 @@ int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
         value = ucontrol->value.enumerated.item[0];
         change = dapm_kcontrol_set_value(kcontrol, value);
         if (change)
-                soc_dapm_mux_update_power(card, kcontrol, value, e);
+                ret = soc_dapm_mux_update_power(card, kcontrol, value, e);
 
         mutex_unlock(&card->dapm_mutex);
+
+        if (ret > 0)
+                soc_dpcm_runtime_update(card);
+
         return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
@@ -3097,6 +3112,7 @@ int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
         unsigned int val, mux, change;
         unsigned int mask;
         struct snd_soc_dapm_update update;
+        int ret = 0;
 
         if (ucontrol->value.enumerated.item[0] > e->max - 1)
                 return -EINVAL;
@@ -3120,12 +3136,16 @@ int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
                 update.val = val;
                 card->update = &update;
 
-                soc_dapm_mux_update_power(card, kcontrol, mux, e);
+                ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
 
                 card->update = NULL;
         }
 
         mutex_unlock(&card->dapm_mutex);
+
+        if (ret > 0)
+                soc_dpcm_runtime_update(card);
+
         return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
diff --git a/sound/soc/soc-devres.c b/sound/soc/soc-devres.c
index 3449c1e909ae..7ac745df1412 100644
--- a/sound/soc/soc-devres.c
+++ b/sound/soc/soc-devres.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
 
 static void devm_component_release(struct device *dev, void *res)
 {
@@ -84,3 +85,43 @@ int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card)
         return ret;
 }
 EXPORT_SYMBOL_GPL(devm_snd_soc_register_card);
+
+#ifdef CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM
+
+static void devm_dmaengine_pcm_release(struct device *dev, void *res)
+{
+        snd_dmaengine_pcm_unregister(*(struct device **)res);
+}
+
+/**
+ * devm_snd_dmaengine_pcm_register - resource managed dmaengine PCM registration
+ * @dev: The parent device for the PCM device
+ * @config: Platform specific PCM configuration
+ * @flags: Platform specific quirks
+ *
+ * Register a dmaengine based PCM device with automatic unregistration when the
+ * device is unregistered.
+ */
+int devm_snd_dmaengine_pcm_register(struct device *dev,
+        const struct snd_dmaengine_pcm_config *config, unsigned int flags)
+{
+        struct device **ptr;
+        int ret;
+
+        ptr = devres_alloc(devm_dmaengine_pcm_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return -ENOMEM;
+
+        ret = snd_dmaengine_pcm_register(dev, config, flags);
+        if (ret == 0) {
+                *ptr = dev;
+                devres_add(dev, ptr);
+        } else {
+                devres_free(ptr);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(devm_snd_dmaengine_pcm_register);
+
+#endif
diff --git a/sound/soc/soc-generic-dmaengine-pcm.c b/sound/soc/soc-generic-dmaengine-pcm.c
index 41949af3baae..2a6c569d991f 100644
--- a/sound/soc/soc-generic-dmaengine-pcm.c
+++ b/sound/soc/soc-generic-dmaengine-pcm.c
@@ -137,6 +137,9 @@ static int dmaengine_pcm_set_runtime_hwparams(struct snd_pcm_substream *substrea
         hw.buffer_bytes_max = SIZE_MAX;
         hw.fifo_size = dma_data->fifo_size;
 
+        if (pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_RESIDUE)
+                hw.info |= SNDRV_PCM_INFO_BATCH;
+
         ret = dma_get_slave_caps(chan, &dma_caps);
         if (ret == 0) {
                 if (dma_caps.cmd_pause)
@@ -284,25 +287,54 @@ static const char * const dmaengine_pcm_dma_channel_names[] = {
         [SNDRV_PCM_STREAM_CAPTURE] = "rx",
 };
 
-static void dmaengine_pcm_request_chan_of(struct dmaengine_pcm *pcm,
-        struct device *dev)
+static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm *pcm,
+        struct device *dev, const struct snd_dmaengine_pcm_config *config)
 {
         unsigned int i;
+        const char *name;
+        struct dma_chan *chan;
 
         if ((pcm->flags & (SND_DMAENGINE_PCM_FLAG_NO_DT |
                            SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME)) ||
             !dev->of_node)
-                return;
+                return 0;
+
+        if (config && config->dma_dev) {
+                /*
+                 * If this warning is seen, it probably means that your Linux
+                 * device structure does not match your HW device structure.
+                 * It would be best to refactor the Linux device structure to
+                 * correctly match the HW structure.
+                 */
+                dev_warn(dev, "DMA channels sourced from device %s",
+                         dev_name(config->dma_dev));
+                dev = config->dma_dev;
+        }
 
-        if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX) {
-                pcm->chan[0] = dma_request_slave_channel(dev, "rx-tx");
-                pcm->chan[1] = pcm->chan[0];
-        } else {
-                for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_CAPTURE; i++) {
-                        pcm->chan[i] = dma_request_slave_channel(dev,
-                                        dmaengine_pcm_dma_channel_names[i]);
+        for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_CAPTURE;
+             i++) {
+                if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
+                        name = "rx-tx";
+                else
+                        name = dmaengine_pcm_dma_channel_names[i];
+                if (config && config->chan_names[i])
+                        name = config->chan_names[i];
+                chan = dma_request_slave_channel_reason(dev, name);
+                if (IS_ERR(chan)) {
+                        if (PTR_ERR(chan) == -EPROBE_DEFER)
+                                return -EPROBE_DEFER;
+                        pcm->chan[i] = NULL;
+                } else {
+                        pcm->chan[i] = chan;
                 }
+                if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
+                        break;
         }
+
+        if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
+                pcm->chan[1] = pcm->chan[0];
+
+        return 0;
 }
 
 static void dmaengine_pcm_release_chan(struct dmaengine_pcm *pcm)
@@ -338,7 +370,9 @@ int snd_dmaengine_pcm_register(struct device *dev,
         pcm->config = config;
         pcm->flags = flags;
 
-        dmaengine_pcm_request_chan_of(pcm, dev);
+        ret = dmaengine_pcm_request_chan_of(pcm, dev, config);
+        if (ret)
+                goto err_free_dma;
 
         if (flags & SND_DMAENGINE_PCM_FLAG_NO_RESIDUE)
                 ret = snd_soc_add_platform(dev, &pcm->platform,
diff --git a/sound/soc/soc-io.c b/sound/soc/soc-io.c
index 4f11d23f2062..aa886cca3ecf 100644
--- a/sound/soc/soc-io.c
+++ b/sound/soc/soc-io.c
@@ -99,14 +99,14 @@ int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
         config.val_bits = data_bits;
 
         switch (control) {
-#if defined(CONFIG_REGMAP_I2C) || defined(CONFIG_REGMAP_I2C_MODULE)
+#if IS_ENABLED(CONFIG_REGMAP_I2C)
         case SND_SOC_I2C:
                 codec->control_data = regmap_init_i2c(to_i2c_client(codec->dev),
                                                       &config);
                 break;
 #endif
 
-#if defined(CONFIG_REGMAP_SPI) || defined(CONFIG_REGMAP_SPI_MODULE)
+#if IS_ENABLED(CONFIG_REGMAP_SPI)
         case SND_SOC_SPI:
                 codec->control_data = regmap_init_spi(to_spi_device(codec->dev),
                                                       &config);
diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index 891b9a9bcbf8..604e7e9a2ef8 100644
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -84,35 +84,117 @@ static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         int ret;
 
-        if (!soc_dai->driver->symmetric_rates &&
-            !rtd->dai_link->symmetric_rates)
-                return 0;
+        if (soc_dai->rate && (soc_dai->driver->symmetric_rates ||
+                                rtd->dai_link->symmetric_rates)) {
+                dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %dHz rate\n",
+                                soc_dai->rate);
+
+                ret = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                SNDRV_PCM_HW_PARAM_RATE,
+                                                soc_dai->rate, soc_dai->rate);
+                if (ret < 0) {
+                        dev_err(soc_dai->dev,
+                                "ASoC: Unable to apply rate constraint: %d\n",
+                                ret);
+                        return ret;
+                }
+        }
 
-        /* This can happen if multiple streams are starting simultaneously -
-         * the second can need to get its constraints before the first has
-         * picked a rate.  Complain and allow the application to carry on.
-         */
-        if (!soc_dai->rate) {
-                dev_warn(soc_dai->dev,
-                         "ASoC: Not enforcing symmetric_rates due to race\n");
-                return 0;
+        if (soc_dai->channels && (soc_dai->driver->symmetric_channels ||
+                                rtd->dai_link->symmetric_channels)) {
+                dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d channel(s)\n",
+                                soc_dai->channels);
+
+                ret = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                SNDRV_PCM_HW_PARAM_CHANNELS,
+                                                soc_dai->channels,
+                                                soc_dai->channels);
+                if (ret < 0) {
+                        dev_err(soc_dai->dev,
+                                "ASoC: Unable to apply channel symmetry constraint: %d\n",
+                                ret);
+                        return ret;
+                }
         }
 
-        dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %dHz rate\n", soc_dai->rate);
+        if (soc_dai->sample_bits && (soc_dai->driver->symmetric_samplebits ||
+                                rtd->dai_link->symmetric_samplebits)) {
+                dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d sample bits\n",
+                                soc_dai->sample_bits);
 
-        ret = snd_pcm_hw_constraint_minmax(substream->runtime,
-                                           SNDRV_PCM_HW_PARAM_RATE,
-                                           soc_dai->rate, soc_dai->rate);
-        if (ret < 0) {
-                dev_err(soc_dai->dev,
-                        "ASoC: Unable to apply rate symmetry constraint: %d\n",
-                        ret);
-                return ret;
+                ret = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+                                                soc_dai->sample_bits,
+                                                soc_dai->sample_bits);
+                if (ret < 0) {
+                        dev_err(soc_dai->dev,
+                                "ASoC: Unable to apply sample bits symmetry constraint: %d\n",
+                                ret);
+                        return ret;
+                }
         }
 
         return 0;
 }
 
+static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        unsigned int rate, channels, sample_bits, symmetry;
+
+        rate = params_rate(params);
+        channels = params_channels(params);
+        sample_bits = snd_pcm_format_physical_width(params_format(params));
+
+        /* reject unmatched parameters when applying symmetry */
+        symmetry = cpu_dai->driver->symmetric_rates ||
+                codec_dai->driver->symmetric_rates ||
+                rtd->dai_link->symmetric_rates;
+        if (symmetry && cpu_dai->rate && cpu_dai->rate != rate) {
+                dev_err(rtd->dev, "ASoC: unmatched rate symmetry: %d - %d\n",
+                                cpu_dai->rate, rate);
+                return -EINVAL;
+        }
+
+        symmetry = cpu_dai->driver->symmetric_channels ||
+                codec_dai->driver->symmetric_channels ||
+                rtd->dai_link->symmetric_channels;
+        if (symmetry && cpu_dai->channels && cpu_dai->channels != channels) {
+                dev_err(rtd->dev, "ASoC: unmatched channel symmetry: %d - %d\n",
+                                cpu_dai->channels, channels);
+                return -EINVAL;
+        }
+
+        symmetry = cpu_dai->driver->symmetric_samplebits ||
+                codec_dai->driver->symmetric_samplebits ||
+                rtd->dai_link->symmetric_samplebits;
+        if (symmetry && cpu_dai->sample_bits && cpu_dai->sample_bits != sample_bits) {
+                dev_err(rtd->dev, "ASoC: unmatched sample bits symmetry: %d - %d\n",
+                                cpu_dai->sample_bits, sample_bits);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static bool soc_pcm_has_symmetry(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai_driver *cpu_driver = rtd->cpu_dai->driver;
+        struct snd_soc_dai_driver *codec_driver = rtd->codec_dai->driver;
+        struct snd_soc_dai_link *link = rtd->dai_link;
+
+        return cpu_driver->symmetric_rates || codec_driver->symmetric_rates ||
+                link->symmetric_rates || cpu_driver->symmetric_channels ||
+                codec_driver->symmetric_channels || link->symmetric_channels ||
+                cpu_driver->symmetric_samplebits ||
+                codec_driver->symmetric_samplebits ||
+                link->symmetric_samplebits;
+}
+
 /*
  * List of sample sizes that might go over the bus for parameter
  * application.  There ought to be a wildcard sample size for things
@@ -249,6 +331,9 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
                         &cpu_dai_drv->capture);
         }
 
+        if (soc_pcm_has_symmetry(substream))
+                runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
+
         ret = -EINVAL;
         if (!runtime->hw.rates) {
                 printk(KERN_ERR "ASoC: %s <-> %s No matching rates\n",
@@ -396,11 +481,6 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
         if (!codec_dai->active)
                 codec_dai->rate = 0;
 
-        /* Muting the DAC suppresses artifacts caused during digital
-         * shutdown, for example from stopping clocks.
-         */
-        snd_soc_dai_digital_mute(codec_dai, 1, substream->stream);
-
         if (cpu_dai->driver->ops->shutdown)
                 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
 
@@ -531,6 +611,10 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
 
         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
+        ret = soc_pcm_params_symmetry(substream, params);
+        if (ret)
+                goto out;
+
         if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
                 ret = rtd->dai_link->ops->hw_params(substream, params);
                 if (ret < 0) {
@@ -567,9 +651,16 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
                 }
         }
 
-        /* store the rate for each DAIs */
+        /* store the parameters for each DAIs */
         cpu_dai->rate = params_rate(params);
+        cpu_dai->channels = params_channels(params);
+        cpu_dai->sample_bits =
+                snd_pcm_format_physical_width(params_format(params));
+
         codec_dai->rate = params_rate(params);
+        codec_dai->channels = params_channels(params);
+        codec_dai->sample_bits =
+                snd_pcm_format_physical_width(params_format(params));
 
 out:
         mutex_unlock(&rtd->pcm_mutex);
@@ -604,6 +695,19 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
 
         mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
+        /* clear the corresponding DAIs parameters when going to be inactive */
+        if (cpu_dai->active == 1) {
+                cpu_dai->rate = 0;
+                cpu_dai->channels = 0;
+                cpu_dai->sample_bits = 0;
+        }
+
+        if (codec_dai->active == 1) {
+                codec_dai->rate = 0;
+                codec_dai->channels = 0;
+                codec_dai->sample_bits = 0;
+        }
+
         /* apply codec digital mute */
         if ((playback && codec_dai->playback_active == 1) ||
             (!playback && codec_dai->capture_active == 1))
diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c
index 5e633659c1b3..6ebdfd9a1a1d 100644
--- a/sound/soc/soc-utils.c
+++ b/sound/soc/soc-utils.c
@@ -59,10 +59,6 @@ int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
 EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);
 
 static const struct snd_pcm_hardware dummy_dma_hardware = {
-        .formats                = 0xffffffff,
-        .channels_min           = 1,
-        .channels_max           = UINT_MAX,
-
         /* Random values to keep userspace happy when checking constraints */
         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
                                   SNDRV_PCM_INFO_BLOCK_TRANSFER,
diff --git a/sound/soc/spear/spdif_in.c b/sound/soc/spear/spdif_in.c
index 21a8c954af1c..4ab442a63d7e 100644
--- a/sound/soc/spear/spdif_in.c
+++ b/sound/soc/spear/spdif_in.c
@@ -18,12 +18,14 @@
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <sound/dmaengine_pcm.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include <sound/spear_dma.h>
 #include <sound/spear_spdif.h>
 #include "spdif_in_regs.h"
+#include "spear_pcm.h"
 
 struct spdif_in_params {
         u32 format;
@@ -37,6 +39,8 @@ struct spdif_in_dev {
         struct device *dev;
         void (*reset_perip)(void);
         int irq;
+        struct snd_dmaengine_dai_dma_data dma_params_rx;
+        struct snd_dmaengine_pcm_config config;
 };
 
 static void spdif_in_configure(struct spdif_in_dev *host)
@@ -53,7 +57,8 @@ static int spdif_in_dai_probe(struct snd_soc_dai *dai)
 {
         struct spdif_in_dev *host = snd_soc_dai_get_drvdata(dai);
 
-        dai->capture_dma_data = &host->dma_params;
+        host->dma_params_rx.filter_data = &host->dma_params;
+        dai->capture_dma_data = &host->dma_params_rx;
 
         return 0;
 }
@@ -244,7 +249,6 @@ static int spdif_in_probe(struct platform_device *pdev)
         host->dma_params.addr = res_fifo->start;
         host->dma_params.max_burst = 16;
         host->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-        host->dma_params.filter = pdata->filter;
         host->reset_perip = pdata->reset_perip;
 
         host->dev = &pdev->dev;
@@ -257,8 +261,13 @@ static int spdif_in_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        return devm_snd_soc_register_component(&pdev->dev, &spdif_in_component,
-                                               &spdif_in_dai, 1);
+        ret = devm_snd_soc_register_component(&pdev->dev, &spdif_in_component,
+                                              &spdif_in_dai, 1);
+        if (ret)
+                return ret;
+
+        return devm_spear_pcm_platform_register(&pdev->dev, &host->config,
+                                                pdata->filter);
 }
 
 static struct platform_driver spdif_in_driver = {
diff --git a/sound/soc/spear/spdif_out.c b/sound/soc/spear/spdif_out.c
index b6ef6f78dc78..fe99f461aff0 100644
--- a/sound/soc/spear/spdif_out.c
+++ b/sound/soc/spear/spdif_out.c
@@ -18,10 +18,12 @@
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <sound/dmaengine_pcm.h>
 #include <sound/soc.h>
 #include <sound/spear_dma.h>
 #include <sound/spear_spdif.h>
 #include "spdif_out_regs.h"
+#include "spear_pcm.h"
 
 struct spdif_out_params {
         u32 rate;
@@ -35,6 +37,8 @@ struct spdif_out_dev {
         struct spdif_out_params saved_params;
         u32 running;
         void __iomem *io_base;
+        struct snd_dmaengine_dai_dma_data dma_params_tx;
+        struct snd_dmaengine_pcm_config config;
 };
 
 static void spdif_out_configure(struct spdif_out_dev *host)
@@ -244,7 +248,8 @@ static int spdif_soc_dai_probe(struct snd_soc_dai *dai)
 {
         struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai);
 
-        dai->playback_dma_data = &host->dma_params;
+        host->dma_params_tx.filter_data = &host->dma_params;
+        dai->playback_dma_data = &host->dma_params_tx;
 
         return snd_soc_add_dai_controls(dai, spdif_out_controls,
                                 ARRAY_SIZE(spdif_out_controls));
@@ -280,6 +285,7 @@ static int spdif_out_probe(struct platform_device *pdev)
         struct spdif_out_dev *host;
         struct spear_spdif_platform_data *pdata;
         struct resource *res;
+        int ret;
 
         host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
         if (!host) {
@@ -302,12 +308,16 @@ static int spdif_out_probe(struct platform_device *pdev)
         host->dma_params.addr = res->start + SPDIF_OUT_FIFO_DATA;
         host->dma_params.max_burst = 16;
         host->dma_params.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-        host->dma_params.filter = pdata->filter;
 
         dev_set_drvdata(&pdev->dev, host);
 
-        return devm_snd_soc_register_component(&pdev->dev, &spdif_out_component,
-                                               &spdif_out_dai, 1);
+        ret = devm_snd_soc_register_component(&pdev->dev, &spdif_out_component,
+                                              &spdif_out_dai, 1);
+        if (ret)
+                return ret;
+
+        return devm_spear_pcm_platform_register(&pdev->dev, &host->config,
+                                                pdata->filter);
 }
 
 #ifdef CONFIG_PM
diff --git a/sound/soc/spear/spear_pcm.c b/sound/soc/spear/spear_pcm.c
index 4707f2b862c3..0e5a8f35d0ad 100644
--- a/sound/soc/spear/spear_pcm.c
+++ b/sound/soc/spear/spear_pcm.c
@@ -18,6 +18,7 @@
 #include <sound/pcm.h>
 #include <sound/soc.h>
 #include <sound/spear_dma.h>
+#include "spear_pcm.h"
 
 static const struct snd_pcm_hardware spear_pcm_hardware = {
         .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -31,49 +32,24 @@ static const struct snd_pcm_hardware spear_pcm_hardware = {
         .fifo_size = 0, /* fifo size in bytes */
 };
 
-static struct dma_chan *spear_pcm_request_chan(struct snd_soc_pcm_runtime *rtd,
-        struct snd_pcm_substream *substream)
-{
-        struct spear_dma_data *dma_data;
-
-        dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
-
-        return snd_dmaengine_pcm_request_channel(dma_data->filter, dma_data);
-}
-
 static const struct snd_dmaengine_pcm_config spear_dmaengine_pcm_config = {
         .pcm_hardware = &spear_pcm_hardware,
-        .compat_request_channel = spear_pcm_request_chan,
         .prealloc_buffer_size = 16 * 1024,
 };
 
-static int spear_soc_platform_probe(struct platform_device *pdev)
+int devm_spear_pcm_platform_register(struct device *dev,
+                        struct snd_dmaengine_pcm_config *config,
+                        bool (*filter)(struct dma_chan *chan, void *slave))
 {
-        return snd_dmaengine_pcm_register(&pdev->dev,
-                &spear_dmaengine_pcm_config,
+        *config = spear_dmaengine_pcm_config;
+        config->compat_filter_fn = filter;
+
+        return snd_dmaengine_pcm_register(dev, config,
                 SND_DMAENGINE_PCM_FLAG_NO_DT |
                 SND_DMAENGINE_PCM_FLAG_COMPAT);
 }
-
-static int spear_soc_platform_remove(struct platform_device *pdev)
-{
-        snd_dmaengine_pcm_unregister(&pdev->dev);
-        return 0;
-}
-
-static struct platform_driver spear_pcm_driver = {
-        .driver = {
-                .name = "spear-pcm-audio",
-                .owner = THIS_MODULE,
-        },
-
-        .probe = spear_soc_platform_probe,
-        .remove = spear_soc_platform_remove,
-};
-
-module_platform_driver(spear_pcm_driver);
+EXPORT_SYMBOL_GPL(devm_spear_pcm_platform_register);
 
 MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>");
 MODULE_DESCRIPTION("SPEAr PCM DMA module");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:spear-pcm-audio");
diff --git a/sound/soc/spear/spear_pcm.h b/sound/soc/spear/spear_pcm.h
new file mode 100644
index 000000000000..9b0ca62d6f02
--- /dev/null
+++ b/sound/soc/spear/spear_pcm.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SPEAR_PCM_H__
+#define __SPEAR_PCM_H__
+
+int devm_spear_pcm_platform_register(struct device *dev,
+                        struct snd_dmaengine_pcm_config *config,
+                        bool (*filter)(struct dma_chan *chan, void *slave));
+
+#endif
diff --git a/sound/soc/tegra/Kconfig b/sound/soc/tegra/Kconfig
index 8fc653ca3ab4..65a85f542521 100644
--- a/sound/soc/tegra/Kconfig
+++ b/sound/soc/tegra/Kconfig
@@ -116,3 +116,13 @@ config SND_SOC_TEGRA_ALC5632
         help
           Say Y or M here if you want to add support for SoC audio on the
           Toshiba AC100 netbook.
+
+config SND_SOC_TEGRA_MAX98090
+        tristate "SoC Audio support for Tegra boards using a MAX98090 codec"
+        depends on SND_SOC_TEGRA && I2C && GPIOLIB
+        select SND_SOC_TEGRA20_I2S if ARCH_TEGRA_2x_SOC
+        select SND_SOC_TEGRA30_I2S if ARCH_TEGRA_3x_SOC
+        select SND_SOC_MAX98090
+        help
+          Say Y or M here if you want to add support for SoC audio on Tegra
+          boards using the MAX98090 codec, such as Venice2.
diff --git a/sound/soc/tegra/Makefile b/sound/soc/tegra/Makefile
index 21d2550a08a4..5ae588cd96c4 100644
--- a/sound/soc/tegra/Makefile
+++ b/sound/soc/tegra/Makefile
@@ -24,6 +24,7 @@ snd-soc-tegra-wm8903-objs := tegra_wm8903.o
 snd-soc-tegra-wm9712-objs := tegra_wm9712.o
 snd-soc-tegra-trimslice-objs := trimslice.o
 snd-soc-tegra-alc5632-objs := tegra_alc5632.o
+snd-soc-tegra-max98090-objs := tegra_max98090.o
 
 obj-$(CONFIG_SND_SOC_TEGRA_RT5640) += snd-soc-tegra-rt5640.o
 obj-$(CONFIG_SND_SOC_TEGRA_WM8753) += snd-soc-tegra-wm8753.o
@@ -31,3 +32,4 @@ obj-$(CONFIG_SND_SOC_TEGRA_WM8903) += snd-soc-tegra-wm8903.o
 obj-$(CONFIG_SND_SOC_TEGRA_WM9712) += snd-soc-tegra-wm9712.o
 obj-$(CONFIG_SND_SOC_TEGRA_TRIMSLICE) += snd-soc-tegra-trimslice.o
 obj-$(CONFIG_SND_SOC_TEGRA_ALC5632) += snd-soc-tegra-alc5632.o
+obj-$(CONFIG_SND_SOC_TEGRA_MAX98090) += snd-soc-tegra-max98090.o
diff --git a/sound/soc/tegra/tegra20_ac97.c b/sound/soc/tegra/tegra20_ac97.c
index ae27bcd586d2..088518d7694a 100644
--- a/sound/soc/tegra/tegra20_ac97.c
+++ b/sound/soc/tegra/tegra20_ac97.c
@@ -404,7 +404,7 @@ static int tegra20_ac97_platform_probe(struct platform_device *pdev)
         ret = snd_soc_set_ac97_ops(&tegra20_ac97_ops);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to set AC'97 ops: %d\n", ret);
-                goto err_asoc_utils_fini;
+                goto err_clk_disable_unprepare;
         }
 
         ret = snd_soc_register_component(&pdev->dev, &tegra20_ac97_component,
@@ -412,7 +412,7 @@ static int tegra20_ac97_platform_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(&pdev->dev, "Could not register DAI: %d\n", ret);
                 ret = -ENOMEM;
-                goto err_asoc_utils_fini;
+                goto err_clk_disable_unprepare;
         }
 
         ret = tegra_pcm_platform_register(&pdev->dev);
@@ -428,6 +428,8 @@ static int tegra20_ac97_platform_probe(struct platform_device *pdev)
 
 err_unregister_component:
         snd_soc_unregister_component(&pdev->dev);
+err_clk_disable_unprepare:
+        clk_disable_unprepare(ac97->clk_ac97);
 err_asoc_utils_fini:
         tegra_asoc_utils_fini(&ac97->util_data);
 err_clk_put:
diff --git a/sound/soc/tegra/tegra_max98090.c b/sound/soc/tegra/tegra_max98090.c
new file mode 100644
index 000000000000..0283cfb7c031
--- /dev/null
+++ b/sound/soc/tegra/tegra_max98090.c
@@ -0,0 +1,275 @@
+/*
+ * Tegra machine ASoC driver for boards using a MAX90809 CODEC.
+ *
+ * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Based on code copyright/by:
+ *
+ * Copyright (C) 2010-2012 - NVIDIA, Inc.
+ * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.lauchpad.net>
+ * (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
+ * Copyright 2007 Wolfson Microelectronics PLC.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+
+#include <sound/core.h>
+#include <sound/jack.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include "tegra_asoc_utils.h"
+
+#define DRV_NAME "tegra-snd-max98090"
+
+struct tegra_max98090 {
+        struct tegra_asoc_utils_data util_data;
+        int gpio_hp_det;
+};
+
+static int tegra_max98090_asoc_hw_params(struct snd_pcm_substream *substream,
+                                        struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct snd_soc_card *card = codec->card;
+        struct tegra_max98090 *machine = snd_soc_card_get_drvdata(card);
+        int srate, mclk;
+        int err;
+
+        srate = params_rate(params);
+        switch (srate) {
+        case 8000:
+        case 16000:
+        case 24000:
+        case 32000:
+        case 48000:
+        case 64000:
+        case 96000:
+                mclk = 12288000;
+                break;
+        case 11025:
+        case 22050:
+        case 44100:
+        case 88200:
+                mclk = 11289600;
+                break;
+        default:
+                mclk = 12000000;
+                break;
+        }
+
+        err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
+        if (err < 0) {
+                dev_err(card->dev, "Can't configure clocks\n");
+                return err;
+        }
+
+        err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
+                                        SND_SOC_CLOCK_IN);
+        if (err < 0) {
+                dev_err(card->dev, "codec_dai clock not set\n");
+                return err;
+        }
+
+        return 0;
+}
+
+static struct snd_soc_ops tegra_max98090_ops = {
+        .hw_params = tegra_max98090_asoc_hw_params,
+};
+
+static struct snd_soc_jack tegra_max98090_hp_jack;
+
+static struct snd_soc_jack_pin tegra_max98090_hp_jack_pins[] = {
+        {
+                .pin = "Headphones",
+                .mask = SND_JACK_HEADPHONE,
+        },
+};
+
+static struct snd_soc_jack_gpio tegra_max98090_hp_jack_gpio = {
+        .name = "Headphone detection",
+        .report = SND_JACK_HEADPHONE,
+        .debounce_time = 150,
+        .invert = 1,
+};
+
+static const struct snd_soc_dapm_widget tegra_max98090_dapm_widgets[] = {
+        SND_SOC_DAPM_HP("Headphones", NULL),
+        SND_SOC_DAPM_SPK("Speakers", NULL),
+        SND_SOC_DAPM_MIC("Mic Jack", NULL),
+};
+
+static const struct snd_kcontrol_new tegra_max98090_controls[] = {
+        SOC_DAPM_PIN_SWITCH("Speakers"),
+};
+
+static int tegra_max98090_asoc_init(struct snd_soc_pcm_runtime *rtd)
+{
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct tegra_max98090 *machine = snd_soc_card_get_drvdata(codec->card);
+
+        if (gpio_is_valid(machine->gpio_hp_det)) {
+                snd_soc_jack_new(codec, "Headphones", SND_JACK_HEADPHONE,
+                                &tegra_max98090_hp_jack);
+                snd_soc_jack_add_pins(&tegra_max98090_hp_jack,
+                                ARRAY_SIZE(tegra_max98090_hp_jack_pins),
+                                tegra_max98090_hp_jack_pins);
+
+                tegra_max98090_hp_jack_gpio.gpio = machine->gpio_hp_det;
+                snd_soc_jack_add_gpios(&tegra_max98090_hp_jack,
+                                        1,
+                                        &tegra_max98090_hp_jack_gpio);
+        }
+
+        return 0;
+}
+
+static struct snd_soc_dai_link tegra_max98090_dai = {
+        .name = "max98090",
+        .stream_name = "max98090 PCM",
+        .codec_dai_name = "HiFi",
+        .init = tegra_max98090_asoc_init,
+        .ops = &tegra_max98090_ops,
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                        SND_SOC_DAIFMT_CBS_CFS,
+};
+
+static struct snd_soc_card snd_soc_tegra_max98090 = {
+        .name = "tegra-max98090",
+        .owner = THIS_MODULE,
+        .dai_link = &tegra_max98090_dai,
+        .num_links = 1,
+        .controls = tegra_max98090_controls,
+        .num_controls = ARRAY_SIZE(tegra_max98090_controls),
+        .dapm_widgets = tegra_max98090_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(tegra_max98090_dapm_widgets),
+        .fully_routed = true,
+};
+
+static int tegra_max98090_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct snd_soc_card *card = &snd_soc_tegra_max98090;
+        struct tegra_max98090 *machine;
+        int ret;
+
+        machine = devm_kzalloc(&pdev->dev,
+                        sizeof(struct tegra_max98090), GFP_KERNEL);
+        if (!machine) {
+                dev_err(&pdev->dev, "Can't allocate tegra_max98090\n");
+                return -ENOMEM;
+        }
+
+        card->dev = &pdev->dev;
+        platform_set_drvdata(pdev, card);
+        snd_soc_card_set_drvdata(card, machine);
+
+        machine->gpio_hp_det = of_get_named_gpio(np, "nvidia,hp-det-gpios", 0);
+        if (machine->gpio_hp_det == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+
+        ret = snd_soc_of_parse_card_name(card, "nvidia,model");
+        if (ret)
+                goto err;
+
+        ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");
+        if (ret)
+                goto err;
+
+        tegra_max98090_dai.codec_of_node = of_parse_phandle(np,
+                        "nvidia,audio-codec", 0);
+        if (!tegra_max98090_dai.codec_of_node) {
+                dev_err(&pdev->dev,
+                        "Property 'nvidia,audio-codec' missing or invalid\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        tegra_max98090_dai.cpu_of_node = of_parse_phandle(np,
+                        "nvidia,i2s-controller", 0);
+        if (!tegra_max98090_dai.cpu_of_node) {
+                dev_err(&pdev->dev,
+                        "Property 'nvidia,i2s-controller' missing or invalid\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        tegra_max98090_dai.platform_of_node = tegra_max98090_dai.cpu_of_node;
+
+        ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
+        if (ret)
+                goto err;
+
+        ret = snd_soc_register_card(card);
+        if (ret) {
+                dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
+                        ret);
+                goto err_fini_utils;
+        }
+
+        return 0;
+
+err_fini_utils:
+        tegra_asoc_utils_fini(&machine->util_data);
+err:
+        return ret;
+}
+
+static int tegra_max98090_remove(struct platform_device *pdev)
+{
+        struct snd_soc_card *card = platform_get_drvdata(pdev);
+        struct tegra_max98090 *machine = snd_soc_card_get_drvdata(card);
+
+        snd_soc_jack_free_gpios(&tegra_max98090_hp_jack, 1,
+                                &tegra_max98090_hp_jack_gpio);
+
+        snd_soc_unregister_card(card);
+
+        tegra_asoc_utils_fini(&machine->util_data);
+
+        return 0;
+}
+
+static const struct of_device_id tegra_max98090_of_match[] = {
+        { .compatible = "nvidia,tegra-audio-max98090", },
+        {},
+};
+
+static struct platform_driver tegra_max98090_driver = {
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+                .pm = &snd_soc_pm_ops,
+                .of_match_table = tegra_max98090_of_match,
+        },
+        .probe = tegra_max98090_probe,
+        .remove = tegra_max98090_remove,
+};
+module_platform_driver(tegra_max98090_driver);
+
+MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
+MODULE_DESCRIPTION("Tegra max98090 machine ASoC driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRV_NAME);
+MODULE_DEVICE_TABLE(of, tegra_max98090_of_match);
diff --git a/sound/soc/tegra/tegra_pcm.c b/sound/soc/tegra/tegra_pcm.c
index 7b2d23ba69b3..c09ffd18791b 100644
--- a/sound/soc/tegra/tegra_pcm.c
+++ b/sound/soc/tegra/tegra_pcm.c
@@ -42,9 +42,6 @@ static const struct snd_pcm_hardware tegra_pcm_hardware = {
         .info                   = SNDRV_PCM_INFO_MMAP |
                                   SNDRV_PCM_INFO_MMAP_VALID |
                                   SNDRV_PCM_INFO_INTERLEAVED,
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
-        .channels_min           = 2,
-        .channels_max           = 2,
         .period_bytes_min       = 1024,
         .period_bytes_max       = PAGE_SIZE,
         .periods_min            = 2,
diff --git a/sound/soc/tegra/tegra_wm9712.c b/sound/soc/tegra/tegra_wm9712.c
index 5e119630b0e0..45b57892b6a5 100644
--- a/sound/soc/tegra/tegra_wm9712.c
+++ b/sound/soc/tegra/tegra_wm9712.c
@@ -55,7 +55,6 @@ static int tegra_wm9712_init(struct snd_soc_pcm_runtime *rtd)
 static struct snd_soc_dai_link tegra_wm9712_dai = {
         .name = "AC97 HiFi",
         .stream_name = "AC97 HiFi",
-        .cpu_dai_name = "tegra20-ac97",
         .codec_dai_name = "wm9712-hifi",
         .codec_name = "wm9712-codec",
         .init = tegra_wm9712_init,
diff --git a/sound/soc/txx9/txx9aclc.c b/sound/soc/txx9/txx9aclc.c
index fbd077f4de72..f0829de28708 100644
--- a/sound/soc/txx9/txx9aclc.c
+++ b/sound/soc/txx9/txx9aclc.c
@@ -40,11 +40,6 @@ static const struct snd_pcm_hardware txx9aclc_pcm_hardware = {
         .info             = SNDRV_PCM_INFO_INTERLEAVED |
                             SNDRV_PCM_INFO_BATCH |
                             SNDRV_PCM_INFO_PAUSE,
-#ifdef __BIG_ENDIAN
-        .formats          = SNDRV_PCM_FMTBIT_S16_BE,
-#else
-        .formats          = SNDRV_PCM_FMTBIT_S16_LE,
-#endif
         .period_bytes_min = 1024,
         .period_bytes_max = 8 * 1024,
         .periods_min      = 2,
diff --git a/tools/power/cpupower/utils/cpupower-set.c b/tools/power/cpupower/utils/cpupower-set.c
index dc4de3762111..bcf1d2f0b791 100644
--- a/tools/power/cpupower/utils/cpupower-set.c
+++ b/tools/power/cpupower/utils/cpupower-set.c
@@ -18,9 +18,9 @@
 #include "helpers/bitmask.h"
 
 static struct option set_opts[] = {
-        { .name = "perf-bias",  .has_arg = optional_argument,   .flag = NULL,   .val = 'b'},
-        { .name = "sched-mc",   .has_arg = optional_argument,   .flag = NULL,   .val = 'm'},
-        { .name = "sched-smt",  .has_arg = optional_argument,   .flag = NULL,   .val = 's'},
+        { .name = "perf-bias",  .has_arg = required_argument,   .flag = NULL,   .val = 'b'},
+        { .name = "sched-mc",   .has_arg = required_argument,   .flag = NULL,   .val = 'm'},
+        { .name = "sched-smt",  .has_arg = required_argument,   .flag = NULL,   .val = 's'},
         { },
 };