Merge tag 'pinctrl-v5.3-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl

Pull pin control updates from Linus Walleij:
 "This is the bulk of pin control changes for the v5.3 kernel cycle:

  Core changes:

   - Device links can optionally be added between a pin control producer
     and its consumers. This will affect how the system power management
     is handled: a pin controller will not suspend before all of its
     consumers have been suspended.

     This was necessary for the ST Microelectronics STMFX expander and
     need to be tested on other systems as well: it makes sense to make
     this default in the long run.

     Right now it is opt-in per driver.

   - Drive strength can be specified in microamps. With decreases in
     silicon technology, milliamps isn't granular enough, let's make it
     possible to select drive strengths in microamps.

     Right now the Meson (AMlogic) driver needs this.

  New drivers:

   - New subdriver for the Tegra 194 SoC.

   - New subdriver for the Qualcomm SDM845.

   - New subdriver for the Qualcomm SM8150.

   - New subdriver for the Freescale i.MX8MN (Freescale is now a product
     line of NXP).

   - New subdriver for Marvell MV98DX1135.

  Driver improvements:

   - The Bitmain BM1880 driver now supports pin config in addition to
     muxing.

   - The Qualcomm drivers can now reserve some GPIOs as taken aside and
     not usable for users. This is used in ACPI systems to take out some
     GPIO lines used by the BIOS so that noone else (neither kernel nor
     userspace) will play with them by mistake and crash the machine.

   - A slew of refurbishing around the Aspeed drivers (board management
     controllers for servers) in preparation for the new Aspeed AST2600
     SoC.

   - A slew of improvements over the SH PFC drivers as usual.

   - Misc cleanups and fixes"

* tag 'pinctrl-v5.3-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl: (106 commits)
  pinctrl: aspeed: Strip moved macros and structs from private header
  pinctrl: aspeed: Fix missed include
  pinctrl: baytrail: Use GENMASK() consistently
  pinctrl: baytrail: Re-use data structures from pinctrl-intel.h
  pinctrl: baytrail: Use defined macro instead of magic in byt_get_gpio_mux()
  pinctrl: qcom: Add SM8150 pinctrl driver
  dt-bindings: pinctrl: qcom: Add SM8150 pinctrl binding
  dt-bindings: pinctrl: qcom: Document missing gpio nodes
  pinctrl: aspeed: Add implementation-related documentation
  pinctrl: aspeed: Split out pinmux from general pinctrl
  pinctrl: aspeed: Clarify comment about strapping W1C
  pinctrl: aspeed: Correct comment that is no longer true
  MAINTAINERS: Add entry for ASPEED pinctrl drivers
  dt-bindings: pinctrl: aspeed: Convert AST2500 bindings to json-schema
  dt-bindings: pinctrl: aspeed: Convert AST2400 bindings to json-schema
  dt-bindings: pinctrl: aspeed: Split bindings document in two
  pinctrl: qcom: Add irq_enable callback for msm gpio
  pinctrl: madera: Fixup SPDX headers
  pinctrl: qcom: sdm845: Fix CONFIG preprocessor guard
  pinctrl: tegra: Add bitmask support for parked bits
  ...

109 files changed, 7689 insertions, 3198 deletions

diff --git a/Documentation/devicetree/bindings/pinctrl/allwinner,sunxi-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/allwinner,sunxi-pinctrl.txt
index cf96b7c20e4d..328585c6da58 100644
--- a/Documentation/devicetree/bindings/pinctrl/allwinner,sunxi-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/allwinner,sunxi-pinctrl.txt
@@ -24,6 +24,8 @@ Required properties:
   "allwinner,sun8i-h3-pinctrl"
   "allwinner,sun8i-h3-r-pinctrl"
   "allwinner,sun8i-r40-pinctrl"
+  "allwinner,sun8i-v3-pinctrl"
+  "allwinner,sun8i-v3s-pinctrl"
   "allwinner,sun50i-a64-pinctrl"
   "allwinner,sun50i-a64-r-pinctrl"
   "allwinner,sun50i-h5-pinctrl"
diff --git a/Documentation/devicetree/bindings/pinctrl/aspeed,ast2400-pinctrl.yaml b/Documentation/devicetree/bindings/pinctrl/aspeed,ast2400-pinctrl.yaml
new file mode 100644
index 000000000000..61a110a7db8a
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/aspeed,ast2400-pinctrl.yaml
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/pinctrl/aspeed,ast2400-pinctrl.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: ASPEED AST2400 Pin Controller
+
+maintainers:
+  - Andrew Jeffery <andrew@aj.id.au>
+
+description: |+
+  The pin controller node should be the child of a syscon node with the
+  required property:
+
+  - compatible:     Should be one of the following:
+                    "aspeed,ast2400-scu", "syscon", "simple-mfd"
+                    "aspeed,g4-scu", "syscon", "simple-mfd"
+
+  Refer to the the bindings described in
+  Documentation/devicetree/bindings/mfd/syscon.txt
+
+properties:
+  compatible:
+    enum: [ aspeed,ast2400-pinctrl, aspeed,g4-pinctrl ]
+
+patternProperties:
+  '^.*$':
+    if:
+      type: object
+    then:
+      patternProperties:
+        "^function|groups$":
+          allOf:
+            - $ref: "/schemas/types.yaml#/definitions/string"
+            - enum: [ "ACPI", "ADC0", "ADC1", "ADC10", "ADC11", "ADC12", "ADC13",
+              "ADC14", "ADC15", "ADC2", "ADC3", "ADC4", "ADC5", "ADC6", "ADC7",
+              "ADC8", "ADC9", "BMCINT", "DDCCLK", "DDCDAT", "EXTRST", "FLACK",
+              "FLBUSY", "FLWP", "GPID", "GPID0", "GPID2", "GPID4", "GPID6",
+              "GPIE0", "GPIE2", "GPIE4", "GPIE6", "I2C10", "I2C11", "I2C12",
+              "I2C13", "I2C14", "I2C3", "I2C4", "I2C5", "I2C6", "I2C7", "I2C8",
+              "I2C9", "LPCPD", "LPCPME", "LPCRST", "LPCSMI", "MAC1LINK",
+              "MAC2LINK", "MDIO1", "MDIO2", "NCTS1", "NCTS2", "NCTS3", "NCTS4",
+              "NDCD1", "NDCD2", "NDCD3", "NDCD4", "NDSR1", "NDSR2", "NDSR3",
+              "NDSR4", "NDTR1", "NDTR2", "NDTR3", "NDTR4", "NDTS4", "NRI1",
+              "NRI2", "NRI3", "NRI4", "NRTS1", "NRTS2", "NRTS3", "OSCCLK",
+              "PWM0", "PWM1", "PWM2", "PWM3", "PWM4", "PWM5", "PWM6", "PWM7",
+              "RGMII1", "RGMII2", "RMII1", "RMII2", "ROM16", "ROM8", "ROMCS1",
+              "ROMCS2", "ROMCS3", "ROMCS4", "RXD1", "RXD2", "RXD3", "RXD4",
+              "SALT1", "SALT2", "SALT3", "SALT4", "SD1", "SD2", "SGPMCK",
+              "SGPMI", "SGPMLD", "SGPMO", "SGPSCK", "SGPSI0", "SGPSI1", "SGPSLD",
+              "SIOONCTRL", "SIOPBI", "SIOPBO", "SIOPWREQ", "SIOPWRGD", "SIOS3",
+              "SIOS5", "SIOSCI", "SPI1", "SPI1DEBUG", "SPI1PASSTHRU", "SPICS1",
+              "TIMER3", "TIMER4", "TIMER5", "TIMER6", "TIMER7", "TIMER8", "TXD1",
+              "TXD2", "TXD3", "TXD4", "UART6", "USB11D1", "USB11H2", "USB2D1",
+              "USB2H1", "USBCKI", "VGABIOS_ROM", "VGAHS", "VGAVS", "VPI18",
+              "VPI24", "VPI30", "VPO12", "VPO24", "WDTRST1", "WDTRST2" ]
+
+required:
+  - compatible
+
+examples:
+  - |
+    syscon: scu@1e6e2000 {
+        compatible = "aspeed,ast2400-scu", "syscon", "simple-mfd";
+        reg = <0x1e6e2000 0x1a8>;
+
+        pinctrl: pinctrl {
+            compatible = "aspeed,g4-pinctrl";
+
+            pinctrl_i2c3_default: i2c3_default {
+                function = "I2C3";
+                groups = "I2C3";
+            };
+
+            pinctrl_gpioh0_unbiased_default: gpioh0 {
+                pins = "A8";
+                bias-disable;
+            };
+        };
+    };
diff --git a/Documentation/devicetree/bindings/pinctrl/aspeed,ast2500-pinctrl.yaml b/Documentation/devicetree/bindings/pinctrl/aspeed,ast2500-pinctrl.yaml
new file mode 100644
index 000000000000..cf561bd55128
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/aspeed,ast2500-pinctrl.yaml
@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/pinctrl/aspeed,ast2500-pinctrl.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: ASPEED AST2500 Pin Controller
+
+maintainers:
+  - Andrew Jeffery <andrew@aj.id.au>
+
+description: |+
+  The pin controller node should be the child of a syscon node with the
+  required property:
+
+  - compatible:         Should be one of the following:
+                        "aspeed,ast2500-scu", "syscon", "simple-mfd"
+                        "aspeed,g5-scu", "syscon", "simple-mfd"
+
+  Refer to the the bindings described in
+  Documentation/devicetree/bindings/mfd/syscon.txt
+
+properties:
+  compatible:
+    enum: [ aspeed,ast2500-pinctrl, aspeed,g5-pinctrl ]
+  aspeed,external-nodes:
+    minItems: 2
+    maxItems: 2
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/phandle-array
+    description: |
+      A cell of phandles to external controller nodes:
+      0: compatible with "aspeed,ast2500-gfx", "syscon"
+      1: compatible with "aspeed,ast2500-lhc", "syscon"
+
+patternProperties:
+  '^.*$':
+    if:
+      type: object
+    then:
+      patternProperties:
+        "^function|groups$":
+          allOf:
+            - $ref: "/schemas/types.yaml#/definitions/string"
+            - enum: [ "ACPI", "ADC0", "ADC1", "ADC10", "ADC11", "ADC12", "ADC13",
+              "ADC14", "ADC15", "ADC2", "ADC3", "ADC4", "ADC5", "ADC6", "ADC7",
+              "ADC8", "ADC9", "BMCINT", "DDCCLK", "DDCDAT", "ESPI", "FWSPICS1",
+              "FWSPICS2", "GPID0", "GPID2", "GPID4", "GPID6", "GPIE0", "GPIE2",
+              "GPIE4", "GPIE6", "I2C10", "I2C11", "I2C12", "I2C13", "I2C14",
+              "I2C3", "I2C4", "I2C5", "I2C6", "I2C7", "I2C8", "I2C9", "LAD0",
+              "LAD1", "LAD2", "LAD3", "LCLK", "LFRAME", "LPCHC", "LPCPD",
+              "LPCPLUS", "LPCPME", "LPCRST", "LPCSMI", "LSIRQ", "MAC1LINK",
+              "MAC2LINK", "MDIO1", "MDIO2", "NCTS1", "NCTS2", "NCTS3", "NCTS4",
+              "NDCD1", "NDCD2", "NDCD3", "NDCD4", "NDSR1", "NDSR2", "NDSR3",
+              "NDSR4", "NDTR1", "NDTR2", "NDTR3", "NDTR4", "NRI1", "NRI2",
+              "NRI3", "NRI4", "NRTS1", "NRTS2", "NRTS3", "NRTS4", "OSCCLK",
+              "PEWAKE", "PNOR", "PWM0", "PWM1", "PWM2", "PWM3", "PWM4", "PWM5",
+              "PWM6", "PWM7", "RGMII1", "RGMII2", "RMII1", "RMII2", "RXD1",
+              "RXD2", "RXD3", "RXD4", "SALT1", "SALT10", "SALT11", "SALT12",
+              "SALT13", "SALT14", "SALT2", "SALT3", "SALT4", "SALT5", "SALT6",
+              "SALT7", "SALT8", "SALT9", "SCL1", "SCL2", "SD1", "SD2", "SDA1",
+              "SDA2", "SGPS1", "SGPS2", "SIOONCTRL", "SIOPBI", "SIOPBO",
+              "SIOPWREQ", "SIOPWRGD", "SIOS3", "SIOS5", "SIOSCI", "SPI1",
+              "SPI1CS1", "SPI1DEBUG", "SPI1PASSTHRU", "SPI2CK", "SPI2CS0",
+              "SPI2CS1", "SPI2MISO", "SPI2MOSI", "TIMER3", "TIMER4", "TIMER5",
+              "TIMER6", "TIMER7", "TIMER8", "TXD1", "TXD2", "TXD3", "TXD4",
+              "UART6", "USB11BHID", "USB2AD", "USB2AH", "USB2BD", "USB2BH",
+              "USBCKI", "VGABIOSROM", "VGAHS", "VGAVS", "VPI24", "VPO",
+              "WDTRST1", "WDTRST2", ]
+
+required:
+  - compatible
+  - aspeed,external-nodes
+
+examples:
+  - |
+    compatible = "simple-bus";
+    ranges;
+
+    apb {
+        compatible = "simple-bus";
+        #address-cells = <1>;
+        #size-cells = <1>;
+        ranges;
+
+        syscon: scu@1e6e2000 {
+            compatible = "aspeed,ast2500-scu", "syscon", "simple-mfd";
+            reg = <0x1e6e2000 0x1a8>;
+
+            pinctrl: pinctrl {
+                compatible = "aspeed,g5-pinctrl";
+                aspeed,external-nodes = <&gfx &lhc>;
+
+                pinctrl_i2c3_default: i2c3_default {
+                    function = "I2C3";
+                    groups = "I2C3";
+                };
+
+                pinctrl_gpioh0_unbiased_default: gpioh0 {
+                    pins = "A18";
+                    bias-disable;
+                };
+            };
+        };
+
+        gfx: display@1e6e6000 {
+            compatible = "aspeed,ast2500-gfx", "syscon";
+            reg = <0x1e6e6000 0x1000>;
+        };
+    };
+
+    lpc: lpc@1e789000 {
+        compatible = "aspeed,ast2500-lpc", "simple-mfd";
+        reg = <0x1e789000 0x1000>;
+
+        #address-cells = <1>;
+        #size-cells = <1>;
+        ranges = <0x0 0x1e789000 0x1000>;
+
+        lpc_host: lpc-host@80 {
+            compatible = "aspeed,ast2500-lpc-host", "simple-mfd", "syscon";
+            reg = <0x80 0x1e0>;
+            reg-io-width = <4>;
+
+            #address-cells = <1>;
+            #size-cells = <1>;
+            ranges = <0x0 0x80 0x1e0>;
+
+            lhc: lhc@20 {
+                   compatible = "aspeed,ast2500-lhc";
+                   reg = <0x20 0x24 0x48 0x8>;
+            };
+        };
+    };
diff --git a/Documentation/devicetree/bindings/pinctrl/bitmain,bm1880-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/bitmain,bm1880-pinctrl.txt
index ed34bb1ee81c..4980776122cc 100644
--- a/Documentation/devicetree/bindings/pinctrl/bitmain,bm1880-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/bitmain,bm1880-pinctrl.txt
@@ -14,7 +14,8 @@ phrase "pin configuration node".
 The pin configuration nodes act as a container for an arbitrary number of
 subnodes. Each of these subnodes represents some desired configuration for a
 pin, a group, or a list of pins or groups. This configuration for BM1880 SoC
-includes only pinmux as there is no pinconf support available in SoC.
+includes pinmux and various pin configuration parameters, such as pull-up,
+slew rate etc...
 
 Each configuration node can consist of multiple nodes describing the pinmux
 options. The name of each subnode is not important; all subnodes should be
@@ -84,10 +85,37 @@ Required Properties:
                   gpio66, gpio67, eth1, i2s0, i2s0_mclkin, i2s1, i2s1_mclkin,
                   spi0
 
+Optional Properties:
+
+- bias-disable:  No arguments. Disable pin bias.
+- bias-pull-down: No arguments. The specified pins should be configured as
+                  pull down.
+- bias-pull-up:   No arguments. The specified pins should be configured as
+                  pull up.
+- input-schmitt-enable: No arguments: Enable schmitt trigger for the specified
+                  pins
+- input-schmitt-disable: No arguments: Disable schmitt trigger for the specified
+                  pins
+- slew-rate:      Integer. Sets slew rate for the specified pins.
+                  Valid values are:
+                  <0>  - Slow
+                  <1>  - Fast
+- drive-strength: Integer. Selects the drive strength for the specified
+                  pins in mA.
+                  Valid values are:
+                  <4>
+                  <8>
+                  <12>
+                  <16>
+                  <20>
+                  <24>
+                  <28>
+                  <32>
+
 Example:
-        pinctrl: pinctrl@50 {
+        pinctrl: pinctrl@400 {
                 compatible = "bitmain,bm1880-pinctrl";
-                reg = <0x50 0x4B0>;
+                reg = <0x400 0x120>;
 
                 pinctrl_uart0_default: uart0-default {
                         pinmux {
diff --git a/Documentation/devicetree/bindings/pinctrl/brcm,bcm2835-gpio.txt b/Documentation/devicetree/bindings/pinctrl/brcm,bcm2835-gpio.txt
index 3fac0a061bcc..ac6d614d74e0 100644
--- a/Documentation/devicetree/bindings/pinctrl/brcm,bcm2835-gpio.txt
+++ b/Documentation/devicetree/bindings/pinctrl/brcm,bcm2835-gpio.txt
@@ -5,6 +5,9 @@ controller, and pinmux/control device.
 
 Required properties:
 - compatible: "brcm,bcm2835-gpio"
+- compatible: should be one of:
+  "brcm,bcm2835-gpio" - BCM2835 compatible pinctrl
+  "brcm,bcm7211-gpio" - BCM7211 compatible pinctrl
 - reg: Should contain the physical address of the GPIO module's registers.
 - gpio-controller: Marks the device node as a GPIO controller.
 - #gpio-cells : Should be two. The first cell is the pin number and the
diff --git a/Documentation/devicetree/bindings/pinctrl/fsl,imx8mm-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/fsl,imx8mm-pinctrl.txt
index 524a16fca666..e4e01c05cf83 100644
--- a/Documentation/devicetree/bindings/pinctrl/fsl,imx8mm-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/fsl,imx8mm-pinctrl.txt
@@ -12,7 +12,7 @@ Required properties in sub-nodes:
 - fsl,pins: each entry consists of 6 integers and represents the mux and config
   setting for one pin.  The first 5 integers <mux_reg conf_reg input_reg mux_val
   input_val> are specified using a PIN_FUNC_ID macro, which can be found in
-  <dt-bindings/pinctrl/imx8mm-pinfunc.h>. The last integer CONFIG is
+  <arch/arm64/boot/dts/freescale/imx8mm-pinfunc.h>. The last integer CONFIG is
   the pad setting value like pull-up on this pin.  Please refer to i.MX8M Mini
   Reference Manual for detailed CONFIG settings.
 
diff --git a/Documentation/devicetree/bindings/pinctrl/fsl,imx8mn-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/fsl,imx8mn-pinctrl.txt
new file mode 100644
index 000000000000..330716c971b9
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/fsl,imx8mn-pinctrl.txt
@@ -0,0 +1,39 @@
+* Freescale IMX8MN IOMUX Controller
+
+Please refer to fsl,imx-pinctrl.txt and pinctrl-bindings.txt in this directory
+for common binding part and usage.
+
+Required properties:
+- compatible: "fsl,imx8mn-iomuxc"
+- reg: should contain the base physical address and size of the iomuxc
+  registers.
+
+Required properties in sub-nodes:
+- fsl,pins: each entry consists of 6 integers and represents the mux and config
+  setting for one pin.  The first 5 integers <mux_reg conf_reg input_reg mux_val
+  input_val> are specified using a PIN_FUNC_ID macro, which can be found in
+  <arch/arm64/boot/dts/freescale/imx8mn-pinfunc.h>. The last integer CONFIG is
+  the pad setting value like pull-up on this pin. Please refer to i.MX8M Nano
+  Reference Manual for detailed CONFIG settings.
+
+Examples:
+
+&uart1 {
+       pinctrl-names = "default";
+       pinctrl-0 = <&pinctrl_uart1>;
+};
+
+iomuxc: pinctrl@30330000 {
+        compatible = "fsl,imx8mn-iomuxc";
+        reg = <0x0 0x30330000 0x0 0x10000>;
+
+        pinctrl_uart1: uart1grp {
+                fsl,pins = <
+                        MX8MN_IOMUXC_UART1_RXD_UART1_DCE_RX     0x140
+                        MX8MN_IOMUXC_UART1_TXD_UART1_DCE_TX     0x140
+                        MX8MN_IOMUXC_UART3_RXD_UART1_DCE_CTS_B  0x140
+                        MX8MN_IOMUXC_UART3_TXD_UART1_DCE_RTS_B  0x140
+                        MX8MN_IOMUXC_SD1_DATA4_GPIO2_IO6        0x19
+                >;
+        };
+};
diff --git a/Documentation/devicetree/bindings/pinctrl/marvell,kirkwood-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/marvell,kirkwood-pinctrl.txt
index 6c0ea155b708..2932f171ee85 100644
--- a/Documentation/devicetree/bindings/pinctrl/marvell,kirkwood-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/marvell,kirkwood-pinctrl.txt
@@ -6,8 +6,8 @@ part and usage.
 Required properties:
 - compatible: "marvell,88f6180-pinctrl",
               "marvell,88f6190-pinctrl", "marvell,88f6192-pinctrl",
-              "marvell,88f6281-pinctrl", "marvell,88f6282-pinctrl"
-              "marvell,98dx4122-pinctrl"
+              "marvell,88f6281-pinctrl", "marvell,88f6282-pinctrl",
+              "marvell,98dx4122-pinctrl", "marvell,98dx1135-pinctrl"
 - reg: register specifier of MPP registers
 
 This driver supports all kirkwood variants, i.e. 88f6180, 88f619x, and 88f628x.
@@ -317,3 +317,43 @@ mpp44         44       gpio
 mpp45         45       gpio
 mpp49         49       gpio
 
+* Marvell Poncat2 98dx1135
+
+name          pins     functions
+================================================================================
+
+mpp0          0        gpio, nand(io2), spi(cs)
+mpp1          1        gpo, nand(io3), spi(mosi)
+mpp2          2        gpo, nand(io4), spi(sck)
+mpp3          3        gpo, nand(io5), spi(miso)
+mpp4          4        gpio, nand(io6), uart0(rxd)
+mpp5          5        gpo, nand(io7), uart0(txd)
+mpp6          6        sysrst(out)
+mpp7          7        gpo, spi(cs)
+mpp8          8        gpio, twsi0(sda), uart1(rts)
+mpp9          9        gpio, twsi(sck), uart1(cts)
+mpp10         10       gpo, uart0(txd)
+mpp11         11       gpio, uart0(rxd)
+mpp13         13       gpio, uart1(txd)
+mpp14         14       gpio, uart1(rxd)
+mpp15         15       gpio, uart0(rts)
+mpp16         16       gpio, uart0(cts)
+mpp17         17       gpio, nand(cle)
+mpp18         18       gpo, nand(io0)
+mpp19         19       gpo, nand(io1)
+mpp20         20       gpio
+mpp21         21       gpio
+mpp22         22       gpio
+mpp23         23       gpio
+mpp24         24       gpio
+mpp25         25       gpio
+mpp26         26       gpio
+mpp27         27       gpio
+mpp28         28       gpio, nand(ren)
+mpp29         29       gpio, nand(wen)
+mpp30         30       gpio
+mpp31         31       gpio
+mpp32         32       gpio
+mpp33         33       gpio
+mpp34         34       gpio, nand(ale)
+mpp35         35       gpio, nand(cen)
diff --git a/Documentation/devicetree/bindings/pinctrl/meson,pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/meson,pinctrl.txt
index a47dd990a8d3..10dc4f7176ca 100644
--- a/Documentation/devicetree/bindings/pinctrl/meson,pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/meson,pinctrl.txt
@@ -47,9 +47,19 @@ Required properties for pinmux nodes are:
 Required properties for configuration nodes:
  - pins: a list of pin names
 
-Configuration nodes support the generic properties "bias-disable",
-"bias-pull-up" and "bias-pull-down", described in file
-pinctrl-bindings.txt
+Configuration nodes support the following generic properties, as
+described in file pinctrl-bindings.txt:
+ - "bias-disable"
+ - "bias-pull-up"
+ - "bias-pull-down"
+ - "output-enable"
+ - "output-disable"
+ - "output-low"
+ - "output-high"
+
+Optional properties :
+ - drive-strength-microamp: Drive strength for the specified pins in uA.
+                            This property is only valid for G12A and newer.
 
 === Example ===
 
diff --git a/Documentation/devicetree/bindings/pinctrl/microchip,pic32-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/microchip,pic32-pinctrl.txt
index 29b72e303ebf..51efd2085113 100644
--- a/Documentation/devicetree/bindings/pinctrl/microchip,pic32-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/microchip,pic32-pinctrl.txt
@@ -5,7 +5,7 @@ Please refer to pinctrl-bindings.txt, ../gpio/gpio.txt, and
 pin controller, GPIO, and interrupt bindings.
 
 PIC32 'pin configuration node' is a node of a group of pins which can be
-used for a specific device or function. This node represents configuraions of
+used for a specific device or function. This node represents configurations of
 pins, optional function, and optional mux related configuration.
 
 Required properties for pin controller node:
diff --git a/Documentation/devicetree/bindings/pinctrl/nvidia,tegra194-pinmux.txt b/Documentation/devicetree/bindings/pinctrl/nvidia,tegra194-pinmux.txt
new file mode 100644
index 000000000000..8763f448c376
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/nvidia,tegra194-pinmux.txt
@@ -0,0 +1,107 @@
+NVIDIA Tegra194 pinmux controller
+
+Required properties:
+- compatible: "nvidia,tegra194-pinmux"
+- reg: Should contain a list of base address and size pairs for:
+  - first entry: The APB_MISC_GP_*_PADCTRL registers (pad control)
+  - second entry: The PINMUX_AUX_* registers (pinmux)
+
+Please refer to pinctrl-bindings.txt in this directory for details of the
+common pinctrl bindings used by client devices, including the meaning of the
+phrase "pin configuration node".
+
+Tegra's pin configuration nodes act as a container for an arbitrary number of
+subnodes. Each of these subnodes represents some desired configuration for a
+pin, a group, or a list of pins or groups. This configuration can include the
+mux function to select on those pin(s)/group(s), and various pin configuration
+parameters, such as pull-up, tristate, drive strength, etc.
+
+See the TRM to determine which properties and values apply to each pin/group.
+Macro values for property values are defined in
+include/dt-binding/pinctrl/pinctrl-tegra.h.
+
+Required subnode-properties:
+- nvidia,pins : An array of strings. Each string contains the name of a pin or
+    group. Valid values for these names are listed below.
+
+Optional subnode-properties:
+- nvidia,function: A string containing the name of the function to mux to the
+    pin or group.
+- nvidia,pull: Integer, representing the pull-down/up to apply to the pin.
+    0: none, 1: down, 2: up.
+- nvidia,tristate: Integer.
+    0: drive, 1: tristate.
+- nvidia,enable-input: Integer. Enable the pin's input path.
+    enable :TEGRA_PIN_ENABLE and
+    disable or output only: TEGRA_PIN_DISABLE.
+- nvidia,open-drain: Integer.
+    enable: TEGRA_PIN_ENABLE.
+    disable: TEGRA_PIN_DISABLE.
+- nvidia,lock: Integer. Lock the pin configuration against further changes
+    until reset.
+    enable: TEGRA_PIN_ENABLE.
+    disable: TEGRA_PIN_DISABLE.
+- nvidia,io-hv: Integer. Select high-voltage receivers.
+    normal: TEGRA_PIN_DISABLE
+    high: TEGRA_PIN_ENABLE
+- nvidia,schmitt: Integer. Enables Schmitt Trigger on the input.
+    normal: TEGRA_PIN_DISABLE
+    high: TEGRA_PIN_ENABLE
+- nvidia,drive-type: Integer. Valid range 0...3.
+- nvidia,pull-down-strength: Integer. Controls drive strength. 0 is weakest.
+    The range of valid values depends on the pingroup. See "CAL_DRVDN" in the
+    Tegra TRM.
+- nvidia,pull-up-strength: Integer. Controls drive strength. 0 is weakest.
+    The range of valid values depends on the pingroup. See "CAL_DRVUP" in the
+    Tegra TRM.
+
+Valid values for pin and group names (nvidia,pin) are:
+
+    These correspond to Tegra PADCTL_* (pinmux) registers.
+
+  Mux groups:
+
+    These correspond to Tegra PADCTL_* (pinmux) registers. Any property
+    that exists in those registers may be set for the following pin names.
+
+    pex_l5_clkreq_n_pgg0, pex_l5_rst_n_pgg1
+
+  Drive groups:
+
+    These registers controls a single pin for which a mux group exists.
+    See the list above for the pin name to use when configuring the pinmux.
+
+    pex_l5_clkreq_n_pgg0, pex_l5_rst_n_pgg1
+
+Valid values for nvidia,functions are:
+
+    pe5
+
+Power Domain:
+    pex_l5_clkreq_n_pgg0 and pex_l5_rst_n_pgg1 are part of PCIE C5 power
+    partition. Client devices must enable this partition before accessing
+    these pins here.
+
+
+Example:
+
+                tegra_pinctrl: pinmux: pinmux@2430000 {
+                        compatible = "nvidia,tegra194-pinmux";
+                        reg = <0x2430000 0x17000
+                               0xc300000 0x4000>;
+
+                        pinctrl-names = "pex_rst";
+                        pinctrl-0 = <&pex_rst_c5_out_state>;
+
+                        pex_rst_c5_out_state: pex_rst_c5_out {
+                                pex_rst {
+                                        nvidia,pins = "pex_l5_rst_n_pgg1";
+                                        nvidia,schmitt = <TEGRA_PIN_DISABLE>;
+                                        nvidia,lpdr = <TEGRA_PIN_ENABLE>;
+                                        nvidia,enable-input = <TEGRA_PIN_DISABLE>;
+                                        nvidia,io-high-voltage = <TEGRA_PIN_ENABLE>;
+                                        nvidia,tristate = <TEGRA_PIN_DISABLE>;
+                                        nvidia,pull = <TEGRA_PIN_PULL_NONE>;
+                                };
+                        };
+                };
diff --git a/Documentation/devicetree/bindings/pinctrl/pinctrl-aspeed.txt b/Documentation/devicetree/bindings/pinctrl/pinctrl-aspeed.txt
deleted file mode 100644
index 3b7266c7c438..000000000000
--- a/Documentation/devicetree/bindings/pinctrl/pinctrl-aspeed.txt
+++ /dev/null
@@ -1,172 +0,0 @@
-======================
-Aspeed Pin Controllers
-======================
-
-The Aspeed SoCs vary in functionality inside a generation but have a common mux
-device register layout.
-
-Required properties for g4:
-- compatible :                  Should be one of the following:
-                                "aspeed,ast2400-pinctrl"
-                                "aspeed,g4-pinctrl"
-
-Required properties for g5:
-- compatible :                  Should be one of the following:
-                                "aspeed,ast2500-pinctrl"
-                                "aspeed,g5-pinctrl"
-
-- aspeed,external-nodes:        A cell of phandles to external controller nodes:
-                                0: compatible with "aspeed,ast2500-gfx", "syscon"
-                                1: compatible with "aspeed,ast2500-lhc", "syscon"
-
-The pin controller node should be the child of a syscon node with the required
-property:
-
-- compatible :          Should be one of the following:
-                        "aspeed,ast2400-scu", "syscon", "simple-mfd"
-                        "aspeed,g4-scu", "syscon", "simple-mfd"
-                        "aspeed,ast2500-scu", "syscon", "simple-mfd"
-                        "aspeed,g5-scu", "syscon", "simple-mfd"
-
-Refer to the the bindings described in
-Documentation/devicetree/bindings/mfd/syscon.txt
-
-Subnode Format
-==============
-
-The required properties of pinmux child nodes are:
-- function: the mux function to select
-- groups  : the list of groups to select with this function
-
-Required properties of pinconf child nodes are:
-- groups: A list of groups to select (either this or "pins" must be
-          specified)
-- pins  : A list of ball names as strings, eg "D14" (either this or "groups"
-          must be specified)
-
-Optional properties of pinconf child nodes are:
-- bias-disable  : disable any pin bias
-- bias-pull-down: pull down the pin
-- drive-strength: sink or source at most X mA
-
-Definitions are as specified in
-Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt, with any
-further limitations as described above.
-
-For pinmux, each mux function has only one associated pin group. Each group is
-named by its function. The following values for the function and groups
-properties are supported:
-
-aspeed,ast2400-pinctrl, aspeed,g4-pinctrl:
-
-ACPI ADC0 ADC1 ADC10 ADC11 ADC12 ADC13 ADC14 ADC15 ADC2 ADC3 ADC4 ADC5 ADC6
-ADC7 ADC8 ADC9 BMCINT DDCCLK DDCDAT EXTRST FLACK FLBUSY FLWP GPID GPID0 GPID2
-GPID4 GPID6 GPIE0 GPIE2 GPIE4 GPIE6 I2C10 I2C11 I2C12 I2C13 I2C14 I2C3 I2C4
-I2C5 I2C6 I2C7 I2C8 I2C9 LPCPD LPCPME LPCRST LPCSMI MAC1LINK MAC2LINK MDIO1
-MDIO2 NCTS1 NCTS2 NCTS3 NCTS4 NDCD1 NDCD2 NDCD3 NDCD4 NDSR1 NDSR2 NDSR3 NDSR4
-NDTR1 NDTR2 NDTR3 NDTR4 NDTS4 NRI1 NRI2 NRI3 NRI4 NRTS1 NRTS2 NRTS3 OSCCLK PWM0
-PWM1 PWM2 PWM3 PWM4 PWM5 PWM6 PWM7 RGMII1 RGMII2 RMII1 RMII2 ROM16 ROM8 ROMCS1
-ROMCS2 ROMCS3 ROMCS4 RXD1 RXD2 RXD3 RXD4 SALT1 SALT2 SALT3 SALT4 SD1 SD2 SGPMCK
-SGPMI SGPMLD SGPMO SGPSCK SGPSI0 SGPSI1 SGPSLD SIOONCTRL SIOPBI SIOPBO SIOPWREQ
-SIOPWRGD SIOS3 SIOS5 SIOSCI SPI1 SPI1DEBUG SPI1PASSTHRU SPICS1 TIMER3 TIMER4
-TIMER5 TIMER6 TIMER7 TIMER8 TXD1 TXD2 TXD3 TXD4 UART6 USB11D1 USB11H2 USB2D1
-USB2H1 USBCKI VGABIOS_ROM VGAHS VGAVS VPI18 VPI24 VPI30 VPO12 VPO24 WDTRST1
-WDTRST2
-
-aspeed,ast2500-pinctrl, aspeed,g5-pinctrl:
-
-ACPI ADC0 ADC1 ADC10 ADC11 ADC12 ADC13 ADC14 ADC15 ADC2 ADC3 ADC4 ADC5 ADC6
-ADC7 ADC8 ADC9 BMCINT DDCCLK DDCDAT ESPI FWSPICS1 FWSPICS2 GPID0 GPID2 GPID4
-GPID6 GPIE0 GPIE2 GPIE4 GPIE6 I2C10 I2C11 I2C12 I2C13 I2C14 I2C3 I2C4 I2C5 I2C6
-I2C7 I2C8 I2C9 LAD0 LAD1 LAD2 LAD3 LCLK LFRAME LPCHC LPCPD LPCPLUS LPCPME
-LPCRST LPCSMI LSIRQ MAC1LINK MAC2LINK MDIO1 MDIO2 NCTS1 NCTS2 NCTS3 NCTS4 NDCD1
-NDCD2 NDCD3 NDCD4 NDSR1 NDSR2 NDSR3 NDSR4 NDTR1 NDTR2 NDTR3 NDTR4 NRI1 NRI2
-NRI3 NRI4 NRTS1 NRTS2 NRTS3 NRTS4 OSCCLK PEWAKE PNOR PWM0 PWM1 PWM2 PWM3 PWM4
-PWM5 PWM6 PWM7 RGMII1 RGMII2 RMII1 RMII2 RXD1 RXD2 RXD3 RXD4 SALT1 SALT10
-SALT11 SALT12 SALT13 SALT14 SALT2 SALT3 SALT4 SALT5 SALT6 SALT7 SALT8 SALT9
-SCL1 SCL2 SD1 SD2 SDA1 SDA2 SGPS1 SGPS2 SIOONCTRL SIOPBI SIOPBO SIOPWREQ
-SIOPWRGD SIOS3 SIOS5 SIOSCI SPI1 SPI1CS1 SPI1DEBUG SPI1PASSTHRU SPI2CK SPI2CS0
-SPI2CS1 SPI2MISO SPI2MOSI TIMER3 TIMER4 TIMER5 TIMER6 TIMER7 TIMER8 TXD1 TXD2
-TXD3 TXD4 UART6 USB11BHID USB2AD USB2AH USB2BD USB2BH USBCKI VGABIOSROM VGAHS
-VGAVS VPI24 VPO WDTRST1 WDTRST2
-
-Examples
-========
-
-g4 Example
-----------
-
-syscon: scu@1e6e2000 {
-        compatible = "aspeed,ast2400-scu", "syscon", "simple-mfd";
-        reg = <0x1e6e2000 0x1a8>;
-
-        pinctrl: pinctrl {
-                compatible = "aspeed,g4-pinctrl";
-
-                pinctrl_i2c3_default: i2c3_default {
-                        function = "I2C3";
-                        groups = "I2C3";
-                };
-
-                pinctrl_gpioh0_unbiased_default: gpioh0 {
-                        pins = "A8";
-                        bias-disable;
-                };
-        };
-};
-
-g5 Example
-----------
-
-ahb {
-        apb {
-                syscon: scu@1e6e2000 {
-                        compatible = "aspeed,ast2500-scu", "syscon", "simple-mfd";
-                        reg = <0x1e6e2000 0x1a8>;
-
-                        pinctrl: pinctrl {
-                                compatible = "aspeed,g5-pinctrl";
-                                aspeed,external-nodes = <&gfx &lhc>;
-
-                                pinctrl_i2c3_default: i2c3_default {
-                                        function = "I2C3";
-                                        groups = "I2C3";
-                                };
-
-                                pinctrl_gpioh0_unbiased_default: gpioh0 {
-                                        pins = "A18";
-                                        bias-disable;
-                                };
-                        };
-                };
-
-                gfx: display@1e6e6000 {
-                        compatible = "aspeed,ast2500-gfx", "syscon";
-                        reg = <0x1e6e6000 0x1000>;
-                };
-        };
-
-        lpc: lpc@1e789000 {
-                compatible = "aspeed,ast2500-lpc", "simple-mfd";
-                reg = <0x1e789000 0x1000>;
-
-                #address-cells = <1>;
-                #size-cells = <1>;
-                ranges = <0x0 0x1e789000 0x1000>;
-
-                lpc_host: lpc-host@80 {
-                        compatible = "aspeed,ast2500-lpc-host", "simple-mfd", "syscon";
-                        reg = <0x80 0x1e0>;
-                        reg-io-width = <4>;
-
-                        #address-cells = <1>;
-                        #size-cells = <1>;
-                        ranges = <0x0 0x80 0x1e0>;
-
-                        lhc: lhc@20 {
-                               compatible = "aspeed,ast2500-lhc";
-                               reg = <0x20 0x24 0x48 0x8>;
-                        };
-                };
-        };
-};
diff --git a/Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt b/Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
index cef2b5855d60..fcd37e93ed4d 100644
--- a/Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
+++ b/Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
@@ -258,6 +258,7 @@ drive-push-pull		- drive actively high and low
 drive-open-drain        - drive with open drain
 drive-open-source       - drive with open source
 drive-strength          - sink or source at most X mA
+drive-strength-microamp - sink or source at most X uA
 input-enable            - enable input on pin (no effect on output, such as
                           enabling an input buffer)
 input-disable           - disable input on pin (no effect on output, such as
@@ -326,6 +327,8 @@ arguments are described below.
 
 - drive-strength takes as argument the target strength in mA.
 
+- drive-strength-microamp takes as argument the target strength in uA.
+
 - input-debounce takes the debounce time in usec as argument
   or 0 to disable debouncing
 
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,apq8084-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,apq8084-pinctrl.txt
index 68e93d5b7ede..c9782397ff14 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,apq8084-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,apq8084-pinctrl.txt
@@ -122,17 +122,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,ipq8074-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,ipq8074-pinctrl.txt
index 6dd72f8599e9..7b151894f5a0 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,ipq8074-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,ipq8074-pinctrl.txt
@@ -118,17 +118,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,mdm9615-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,mdm9615-pinctrl.txt
index 86ecdcfc4fb8..d46973968873 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,mdm9615-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,mdm9615-pinctrl.txt
@@ -97,17 +97,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,msm8916-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,msm8916-pinctrl.txt
index 195a7a0ef0cc..3354a63296d9 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,msm8916-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,msm8916-pinctrl.txt
@@ -130,17 +130,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,msm8960-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,msm8960-pinctrl.txt
index 5034eb6653c7..a7dd213c77c6 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,msm8960-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,msm8960-pinctrl.txt
@@ -124,17 +124,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,msm8994-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,msm8994-pinctrl.txt
index f15443f6e78e..da52df6273bc 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,msm8994-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,msm8994-pinctrl.txt
@@ -128,17 +128,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,msm8996-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,msm8996-pinctrl.txt
index fa97f609fe45..a56cb882830c 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,msm8996-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,msm8996-pinctrl.txt
@@ -149,17 +149,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,msm8998-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,msm8998-pinctrl.txt
index e70c79bbbc5b..cdec1eeb2799 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,msm8998-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,msm8998-pinctrl.txt
@@ -40,6 +40,14 @@ MSM8998 platform.
         Definition: must be 2. Specifying the pin number and flags, as defined
                     in <dt-bindings/gpio/gpio.h>
 
+- gpio-ranges:
+        Usage: required
+        Definition:  see ../gpio/gpio.txt
+
+- gpio-reserved-ranges:
+        Usage: optional
+        Definition: see ../gpio/gpio.txt
+
 Please refer to ../gpio/gpio.txt and ../interrupt-controller/interrupts.txt for
 a general description of GPIO and interrupt bindings.
 
@@ -135,17 +143,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
@@ -175,6 +183,8 @@ Example:
                 interrupts = <0 208 0>;
                 gpio-controller;
                 #gpio-cells = <2>;
+                gpio-ranges = <&tlmm 0 0 175>;
+                gpio-reserved-ranges = <0 4>, <81 4>;
                 interrupt-controller;
                 #interrupt-cells = <2>;
 
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,qcs404-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,qcs404-pinctrl.txt
index 2b8f77762edc..a50e74684195 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,qcs404-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,qcs404-pinctrl.txt
@@ -150,17 +150,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,sdm660-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,sdm660-pinctrl.txt
index 769ca83bb40d..be034d329e10 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,sdm660-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,sdm660-pinctrl.txt
@@ -142,17 +142,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,sdm845-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,sdm845-pinctrl.txt
index 665aadb5ea28..7462e3743c68 100644
--- a/Documentation/devicetree/bindings/pinctrl/qcom,sdm845-pinctrl.txt
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,sdm845-pinctrl.txt
@@ -79,7 +79,7 @@ to specify in a pin configuration subnode:
                       gpio0-gpio149
                         Supports mux, bias and drive-strength
 
-                      sdc2_clk, sdc2_cmd, sdc2_data
+                      sdc2_clk, sdc2_cmd, sdc2_data, ufs_reset
                         Supports bias and drive-strength
 
 - function:
@@ -118,17 +118,17 @@ to specify in a pin configuration subnode:
 - bias-disable:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as no pull.
+        Definition: The specified pins should be configured as no pull.
 
 - bias-pull-down:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull down.
+        Definition: The specified pins should be configured as pull down.
 
 - bias-pull-up:
         Usage: optional
         Value type: <none>
-        Definition: The specified pins should be configued as pull up.
+        Definition: The specified pins should be configured as pull up.
 
 - output-high:
         Usage: optional
diff --git a/Documentation/devicetree/bindings/pinctrl/qcom,sm8150-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/qcom,sm8150-pinctrl.txt
new file mode 100644
index 000000000000..fa37733e5102
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/qcom,sm8150-pinctrl.txt
@@ -0,0 +1,190 @@
+Qualcomm SM8150 TLMM block
+
+This binding describes the Top Level Mode Multiplexer block found in the
+QCS404 platform.
+
+- compatible:
+        Usage: required
+        Value type: <string>
+        Definition: must be "qcom,sm8150-pinctrl"
+
+- reg:
+        Usage: required
+        Value type: <prop-encoded-array>
+        Definition: the base address and size of the north, south, west
+                    and east TLMM tiles.
+
+- reg-names:
+        Usage: required
+        Value type: <prop-encoded-array>
+        Defintiion: names for the cells of reg, must contain "north", "south"
+                    "west" and "east".
+
+- interrupts:
+        Usage: required
+        Value type: <prop-encoded-array>
+        Definition: should specify the TLMM summary IRQ.
+
+- interrupt-controller:
+        Usage: required
+        Value type: <none>
+        Definition: identifies this node as an interrupt controller
+
+- #interrupt-cells:
+        Usage: required
+        Value type: <u32>
+        Definition: must be 2. Specifying the pin number and flags, as defined
+                    in <dt-bindings/interrupt-controller/irq.h>
+
+- gpio-controller:
+        Usage: required
+        Value type: <none>
+        Definition: identifies this node as a gpio controller
+
+- #gpio-cells:
+        Usage: required
+        Value type: <u32>
+        Definition: must be 2. Specifying the pin number and flags, as defined
+                    in <dt-bindings/gpio/gpio.h>
+
+- gpio-ranges:
+        Usage: required
+        Value type: <prop-encoded-array>
+        Definition:  see ../gpio/gpio.txt
+
+- gpio-reserved-ranges:
+        Usage: optional
+        Value type: <prop-encoded-array>
+        Definition: see ../gpio/gpio.txt
+
+Please refer to ../gpio/gpio.txt and ../interrupt-controller/interrupts.txt for
+a general description of GPIO and interrupt bindings.
+
+Please refer to pinctrl-bindings.txt in this directory for details of the
+common pinctrl bindings used by client devices, including the meaning of the
+phrase "pin configuration node".
+
+The pin configuration nodes act as a container for an arbitrary number of
+subnodes. Each of these subnodes represents some desired configuration for a
+pin, a group, or a list of pins or groups. This configuration can include the
+mux function to select on those pin(s)/group(s), and various pin configuration
+parameters, such as pull-up, drive strength, etc.
+
+
+PIN CONFIGURATION NODES:
+
+The name of each subnode is not important; all subnodes should be enumerated
+and processed purely based on their content.
+
+Each subnode only affects those parameters that are explicitly listed. In
+other words, a subnode that lists a mux function but no pin configuration
+parameters implies no information about any pin configuration parameters.
+Similarly, a pin subnode that describes a pullup parameter implies no
+information about e.g. the mux function.
+
+
+The following generic properties as defined in pinctrl-bindings.txt are valid
+to specify in a pin configuration subnode:
+
+- pins:
+        Usage: required
+        Value type: <string-array>
+        Definition: List of gpio pins affected by the properties specified in
+                    this subnode.
+
+                    Valid pins are:
+                      gpio0-gpio149
+                        Supports mux, bias and drive-strength
+
+                      sdc1_clk, sdc1_cmd, sdc1_data sdc2_clk, sdc2_cmd,
+                      sdc2_data sdc1_rclk
+                        Supports bias and drive-strength
+
+                      ufs_reset
+                        Supports bias and drive-strength
+
+- function:
+        Usage: required
+        Value type: <string>
+        Definition: Specify the alternative function to be configured for the
+                    specified pins. Functions are only valid for gpio pins.
+                    Valid values are:
+
+                    adsp_ext, agera_pll, aoss_cti, ddr_pxi2, atest_char,
+                    atest_char0, atest_char1, atest_char2, atest_char3,
+                    audio_ref, atest_usb1, atest_usb2, atest_usb10,
+                    atest_usb11, atest_usb12, atest_usb13, atest_usb20,
+                    atest_usb21, atest_usb22, atest_usb2, atest_usb23,
+                    btfm_slimbus, cam_mclk, cci_async, cci_i2c, cci_timer0,
+                    cci_timer1, cci_timer2, cci_timer3, cci_timer4,
+                    cri_trng, cri_trng0, cri_trng1, dbg_out, ddr_bist,
+                    ddr_pxi0, ddr_pxi1, ddr_pxi3, edp_hot, edp_lcd,
+                    emac_phy, emac_pps, gcc_gp1, gcc_gp2, gcc_gp3, gpio,
+                    hs1_mi2s, hs2_mi2s, hs3_mi2s, jitter_bist,
+                    lpass_slimbus, mdp_vsync, mdp_vsync0, mdp_vsync1,
+                    mdp_vsync2, mdp_vsync3, mss_lte, m_voc, nav_pps,
+                    pa_indicator, pci_e0, phase_flag, pll_bypassnl,
+                    pll_bist, pci_e1, pll_reset, pri_mi2s, pri_mi2s_ws,
+                    prng_rosc, qdss, qdss_cti, qlink_request, qlink_enable,
+                    qspi0, qspi1, qspi2, qspi3, qspi_clk, qspi_cs, qua_mi2s,
+                    qup0, qup1, qup2, qup3, qup4, qup5, qup6, qup7, qup8,
+                    qup9, qup10, qup11, qup12, qup13, qup14, qup15, qup16,
+                    qup17, qup18, qup19, qup_l4, qup_l5, qup_l6, rgmii,
+                    sdc4, sd_write, sec_mi2s, spkr_i2s, sp_cmu, ter_mi2s,
+                    tgu_ch0, tgu_ch1, tgu_ch2, tgu_ch3, tsense_pwm1,
+                    tsense_pwm2, tsif1, tsif2, uim1, uim2, uim_batt,
+                    usb2phy_ac, usb_phy, vfr_1, vsense_trigger, wlan1_adc0,
+                    wlan1_adc1, wlan2_adc0, wlan2_adc1, wmss_reset
+
+- bias-disable:
+        Usage: optional
+        Value type: <none>
+        Definition: The specified pins should be configued as no pull.
+
+- bias-pull-down:
+        Usage: optional
+        Value type: <none>
+        Definition: The specified pins should be configued as pull down.
+
+- bias-pull-up:
+        Usage: optional
+        Value type: <none>
+        Definition: The specified pins should be configued as pull up.
+
+- output-high:
+        Usage: optional
+        Value type: <none>
+        Definition: The specified pins are configured in output mode, driven
+                    high.
+                    Not valid for sdc pins.
+
+- output-low:
+        Usage: optional
+        Value type: <none>
+        Definition: The specified pins are configured in output mode, driven
+                    low.
+                    Not valid for sdc pins.
+
+- drive-strength:
+        Usage: optional
+        Value type: <u32>
+        Definition: Selects the drive strength for the specified pins, in mA.
+                    Valid values are: 2, 4, 6, 8, 10, 12, 14 and 16
+
+Example:
+
+        tlmm: pinctrl@3000000 {
+                compatible = "qcom,sm8150-pinctrl";
+                reg = <0x03100000 0x300000>,
+                      <0x03500000 0x300000>,
+                      <0x03900000 0x300000>,
+                      <0x03D00000 0x300000>;
+                reg-names = "west", "east", "north", "south";
+                interrupts = <GIC_SPI 208 IRQ_TYPE_LEVEL_HIGH>;
+                gpio-controller;
+                #gpio-cells = <2>;
+                gpio-ranges = <&tlmm 0 0 175>;
+                gpio-reserved-ranges = <0 4>, <126 4>;
+                interrupt-controller;
+                #interrupt-cells = <2>;
+        };
diff --git a/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.txt
deleted file mode 100644
index 00169255e48c..000000000000
--- a/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.txt
+++ /dev/null
@@ -1,208 +0,0 @@
-* STM32 GPIO and Pin Mux/Config controller
-
-STMicroelectronics's STM32 MCUs intregrate a GPIO and Pin mux/config hardware
-controller. It controls the input/output settings on the available pins and
-also provides ability to multiplex and configure the output of various on-chip
-controllers onto these pads.
-
-Pin controller node:
-Required properies:
- - compatible: value should be one of the following:
-   "st,stm32f429-pinctrl"
-   "st,stm32f469-pinctrl"
-   "st,stm32f746-pinctrl"
-   "st,stm32f769-pinctrl"
-   "st,stm32h743-pinctrl"
-   "st,stm32mp157-pinctrl"
-   "st,stm32mp157-z-pinctrl"
- - #address-cells: The value of this property must be 1
- - #size-cells  : The value of this property must be 1
- - ranges       : defines mapping between pin controller node (parent) to
-   gpio-bank node (children).
- - pins-are-numbered: Specify the subnodes are using numbered pinmux to
-   specify pins.
-
-GPIO controller/bank node:
-Required properties:
- - gpio-controller : Indicates this device is a GPIO controller
- - #gpio-cells    : Should be two.
-                        The first cell is the pin number
-                        The second one is the polarity:
-                                - 0 for active high
-                                - 1 for active low
- - reg            : The gpio address range, relative to the pinctrl range
- - clocks         : clock that drives this bank
- - st,bank-name   : Should be a name string for this bank as specified in
-   the datasheet
-
-Optional properties:
- - reset:         : Reference to the reset controller
- - st,syscfg: Should be phandle/offset/mask.
-        -The phandle to the syscon node which includes IRQ mux selection register.
-        -The offset of the IRQ mux selection register
-        -The field mask of IRQ mux, needed if different of 0xf.
- - gpio-ranges: Define a dedicated mapping between a pin-controller and
-   a gpio controller. Format is <&phandle a b c> with:
-        -(phandle): phandle of pin-controller.
-        -(a): gpio base offset in range.
-        -(b): pin base offset in range.
-        -(c): gpio count in range
-   This entry has to be used either if there are holes inside a bank:
-        GPIOB0/B1/B2/B14/B15 (see example 2)
-   or if banks are not contiguous:
-        GPIOA/B/C/E...
-   NOTE: If "gpio-ranges" is used for a gpio controller, all gpio-controller
-   have to use a "gpio-ranges" entry.
-   More details in Documentation/devicetree/bindings/gpio/gpio.txt.
- - st,bank-ioport: should correspond to the EXTI IOport selection (EXTI line
-   used to select GPIOs as interrupts).
- - hwlocks: reference to a phandle of a hardware spinlock provider node.
- - st,package: Indicates the SOC package used.
-   More details in include/dt-bindings/pinctrl/stm32-pinfunc.h
-
-Example 1:
-#include <dt-bindings/pinctrl/stm32f429-pinfunc.h>
-...
-
-        pin-controller {
-                #address-cells = <1>;
-                #size-cells = <1>;
-                compatible = "st,stm32f429-pinctrl";
-                ranges = <0 0x40020000 0x3000>;
-                pins-are-numbered;
-
-                gpioa: gpio@40020000 {
-                        gpio-controller;
-                        #gpio-cells = <2>;
-                        reg = <0x0 0x400>;
-                        resets = <&reset_ahb1 0>;
-                        st,bank-name = "GPIOA";
-                };
-                ...
-                pin-functions nodes follow...
-        };
-
-Example 2:
-#include <dt-bindings/pinctrl/stm32f429-pinfunc.h>
-...
-
-        pinctrl: pin-controller {
-                #address-cells = <1>;
-                #size-cells = <1>;
-                compatible = "st,stm32f429-pinctrl";
-                ranges = <0 0x40020000 0x3000>;
-                pins-are-numbered;
-
-                gpioa: gpio@40020000 {
-                        gpio-controller;
-                        #gpio-cells = <2>;
-                        reg = <0x0 0x400>;
-                        resets = <&reset_ahb1 0>;
-                        st,bank-name = "GPIOA";
-                        gpio-ranges = <&pinctrl 0 0 16>;
-                };
-
-                gpiob: gpio@40020400 {
-                        gpio-controller;
-                        #gpio-cells = <2>;
-                        reg = <0x0 0x400>;
-                        resets = <&reset_ahb1 0>;
-                        st,bank-name = "GPIOB";
-                        ngpios = 4;
-                        gpio-ranges = <&pinctrl 0 16 3>,
-                                      <&pinctrl 14 30 2>;
-                };
-
-
-                ...
-                pin-functions nodes follow...
-        };
-
-
-Contents of function subnode node:
-----------------------------------
-Subnode format
-A pinctrl node should contain at least one subnode representing the
-pinctrl group available on the machine. Each subnode will list the
-pins it needs, and how they should be configured, with regard to muxer
-configuration, pullups, drive, output high/low and output speed.
-
-    node {
-        pinmux = <PIN_NUMBER_PINMUX>;
-        GENERIC_PINCONFIG;
-    };
-
-Required properties:
-- pinmux: integer array, represents gpio pin number and mux setting.
-  Supported pin number and mux varies for different SoCs, and are defined in
-  dt-bindings/pinctrl/<soc>-pinfunc.h directly.
-  These defines are calculated as:
-    ((port * 16 + line) << 8) | function
-  With:
-    - port: The gpio port index (PA = 0, PB = 1, ..., PK = 11)
-    - line: The line offset within the port (PA0 = 0, PA1 = 1, ..., PA15 = 15)
-    - function: The function number, can be:
-      * 0 : GPIO
-      * 1 : Alternate Function 0
-      * 2 : Alternate Function 1
-      * 3 : Alternate Function 2
-      * ...
-      * 16 : Alternate Function 15
-      * 17 : Analog
-
-  To simplify the usage, macro is available to generate "pinmux" field.
-  This macro is available here:
-    - include/dt-bindings/pinctrl/stm32-pinfunc.h
-
-  Some examples of using macro:
-    /* GPIO A9 set as alernate function 2 */
-    ... {
-                pinmux = <STM32_PINMUX('A', 9, AF2)>;
-    };
-    /* GPIO A9 set as GPIO  */
-    ... {
-                pinmux = <STM32_PINMUX('A', 9, GPIO)>;
-    };
-    /* GPIO A9 set as analog */
-    ... {
-                pinmux = <STM32_PINMUX('A', 9, ANALOG)>;
-    };
-
-Optional properties:
-- GENERIC_PINCONFIG: is the generic pinconfig options to use.
-  Available options are:
-   - bias-disable,
-   - bias-pull-down,
-   - bias-pull-up,
-   - drive-push-pull,
-   - drive-open-drain,
-   - output-low
-   - output-high
-   - slew-rate = <x>, with x being:
-       < 0 > : Low speed
-       < 1 > : Medium speed
-       < 2 > : Fast speed
-       < 3 > : High speed
-
-Example:
-
-pin-controller {
-...
-        usart1_pins_a: usart1@0 {
-                pins1 {
-                        pinmux = <STM32_PINMUX('A', 9, AF7)>;
-                        bias-disable;
-                        drive-push-pull;
-                        slew-rate = <0>;
-                };
-                pins2 {
-                        pinmux = <STM32_PINMUX('A', 10, AF7)>;
-                        bias-disable;
-                };
-        };
-};
-
-&usart1 {
-        pinctrl-0 = <&usart1_pins_a>;
-        pinctrl-names = "default";
-};
diff --git a/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.yaml b/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.yaml
new file mode 100644
index 000000000000..06c4b66c3ee6
--- /dev/null
+++ b/Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.yaml
@@ -0,0 +1,264 @@
+# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
+# Copyright (C) STMicroelectronics 2019.
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/pinctrl/st,stm32-pinctrl.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: STM32 GPIO and Pin Mux/Config controller
+
+maintainers:
+  - Alexandre TORGUE <alexandre.torgue@st.com>
+
+description: |
+  STMicroelectronics's STM32 MCUs intregrate a GPIO and Pin mux/config hardware
+  controller. It controls the input/output settings on the available pins and
+  also provides ability to multiplex and configure the output of various
+  on-chip controllers onto these pads.
+
+properties:
+  compatible:
+    enum:
+      - st,stm32f429-pinctrl
+      - st,stm32f469-pinctrl
+      - st,stm32f746-pinctrl
+      - st,stm32f769-pinctrl
+      - st,stm32h743-pinctrl
+      - st,stm32mp157-pinctrl
+      - st,stm32mp157-z-pinctrl
+
+  '#address-cells':
+    const: 1
+  '#size-cells':
+    const: 1
+
+  ranges: true
+  pins-are-numbered: true
+  hwlocks: true
+
+  st,syscfg:
+    $ref: "/schemas/types.yaml#/definitions/phandle-array"
+    description: Should be phandle/offset/mask
+    items:
+      - description: Phandle to the syscon node which includes IRQ mux selection.
+      - description: The offset of the IRQ mux selection register.
+      - description: The field mask of IRQ mux, needed if different of 0xf.
+
+  st,package:
+    allOf:
+      - $ref: /schemas/types.yaml#/definitions/uint32
+      - enum: [1, 2, 4, 8]
+    description:
+     Indicates the SOC package used.
+     More details in include/dt-bindings/pinctrl/stm32-pinfunc.h
+
+
+patternProperties:
+  '^gpio@[0-9a-f]*$':
+    properties:
+      gpio-controller: true
+      '#gpio-cells':
+        const: 2
+
+      reg:
+        maxItems: 1
+      clocks:
+        maxItems: 1
+      reset:
+        minItems: 1
+        maxItems: 1
+      gpio-ranges:
+        minItems: 1
+        maxItems: 16
+      ngpios:
+        description:
+          Number of available gpios in a bank.
+        minimum: 1
+        maximum: 16
+
+      st,bank-name:
+        allOf:
+          - $ref: "/schemas/types.yaml#/definitions/string"
+          - enum:
+            - GPIOA
+            - GPIOB
+            - GPIOC
+            - GPIOD
+            - GPIOE
+            - GPIOF
+            - GPIOG
+            - GPIOH
+            - GPIOI
+            - GPIOJ
+            - GPIOK
+            - GPIOZ
+        description:
+          Should be a name string for this bank as specified in the datasheet.
+
+      st,bank-ioport:
+        allOf:
+          - $ref: "/schemas/types.yaml#/definitions/uint32"
+          - minimum: 0
+          - maximum: 11
+
+        description:
+          Should correspond to the EXTI IOport selection (EXTI line used
+          to select GPIOs as interrupts).
+
+    required:
+      - gpio-controller
+      - '#gpio-cells'
+      - reg
+      - clocks
+      - st,bank-name
+
+  '-[0-9]*$':
+    patternProperties:
+      '^pins':
+        description: |
+          A pinctrl node should contain at least one subnode representing the
+          pinctrl group available on the machine. Each subnode will list the
+          pins it needs, and how they should be configured, with regard to muxer
+          configuration, pullups, drive, output high/low and output speed.
+        properties:
+          pinmux:
+            allOf:
+              - $ref: "/schemas/types.yaml#/definitions/uint32-array"
+            description: |
+              Integer array, represents gpio pin number and mux setting.
+              Supported pin number and mux varies for different SoCs, and are
+              defined in dt-bindings/pinctrl/<soc>-pinfunc.h directly.
+              These defines are calculated as: ((port * 16 + line) << 8) | function
+              With:
+              - port: The gpio port index (PA = 0, PB = 1, ..., PK = 11)
+              - line: The line offset within the port (PA0 = 0, PA1 = 1, ..., PA15 = 15)
+              - function: The function number, can be:
+              * 0 : GPIO
+              * 1 : Alternate Function 0
+              * 2 : Alternate Function 1
+              * 3 : Alternate Function 2
+              * ...
+              * 16 : Alternate Function 15
+              * 17 : Analog
+              To simplify the usage, macro is available to generate "pinmux" field.
+              This macro is available here:
+                - include/dt-bindings/pinctrl/stm32-pinfunc.h
+              Some examples of using macro:
+               /* GPIO A9 set as alernate function 2 */
+               ... {
+                          pinmux = <STM32_PINMUX('A', 9, AF2)>;
+               };
+               /* GPIO A9 set as GPIO  */
+               ... {
+                          pinmux = <STM32_PINMUX('A', 9, GPIO)>;
+               };
+               /* GPIO A9 set as analog */
+               ... {
+                          pinmux = <STM32_PINMUX('A', 9, ANALOG)>;
+               };
+
+          bias-disable:
+            type: boolean
+          bias-pull-down:
+            type: boolean
+          bias-pull-up:
+            type: boolean
+          drive-push-pull:
+            type: boolean
+          drive-open-drain:
+            type: boolean
+          output-low:
+            type: boolean
+          output-high:
+            type: boolean
+          slew-rate:
+            description: |
+              0: Low speed
+              1: Medium speed
+              2: Fast speed
+              3: High speed
+            allOf:
+              - $ref: /schemas/types.yaml#/definitions/uint32
+              - enum: [0, 1, 2, 3]
+
+        required:
+          - pinmux
+
+required:
+  - compatible
+  - '#address-cells'
+  - '#size-cells'
+  - ranges
+  - pins-are-numbered
+
+examples:
+  - |
+    #include <dt-bindings/pinctrl/stm32-pinfunc.h>
+    //Example 1
+      pinctrl@40020000 {
+              #address-cells = <1>;
+              #size-cells = <1>;
+              compatible = "st,stm32f429-pinctrl";
+              ranges = <0 0x40020000 0x3000>;
+              pins-are-numbered;
+
+              gpioa: gpio@0 {
+                      gpio-controller;
+                      #gpio-cells = <2>;
+                      reg = <0x0 0x400>;
+                      resets = <&reset_ahb1 0>;
+                      st,bank-name = "GPIOA";
+              };
+       };
+
+    //Example 2 (using gpio-ranges)
+      pinctrl@50020000 {
+              #address-cells = <1>;
+              #size-cells = <1>;
+              compatible = "st,stm32f429-pinctrl";
+              ranges = <0 0x50020000 0x3000>;
+              pins-are-numbered;
+
+              gpiob: gpio@1000 {
+                      gpio-controller;
+                      #gpio-cells = <2>;
+                      reg = <0x1000 0x400>;
+                      resets = <&reset_ahb1 0>;
+                      st,bank-name = "GPIOB";
+                      gpio-ranges = <&pinctrl 0 0 16>;
+              };
+
+              gpioc: gpio@2000 {
+                      gpio-controller;
+                      #gpio-cells = <2>;
+                      reg = <0x2000 0x400>;
+                      resets = <&reset_ahb1 0>;
+                      st,bank-name = "GPIOC";
+                      ngpios = <5>;
+                      gpio-ranges = <&pinctrl 0 16 3>,
+                                    <&pinctrl 14 30 2>;
+              };
+      };
+
+    //Example 3 pin groups
+      pinctrl@60020000 {
+        usart1_pins_a: usart1-0 {
+                pins1 {
+                        pinmux = <STM32_PINMUX('A', 9, AF7)>;
+                        bias-disable;
+                        drive-push-pull;
+                        slew-rate = <0>;
+                };
+                pins2 {
+                        pinmux = <STM32_PINMUX('A', 10, AF7)>;
+                        bias-disable;
+                };
+        };
+    };
+
+    usart1 {
+                pinctrl-0 = <&usart1_pins_a>;
+                pinctrl-names = "default";
+    };
+
+...
diff --git a/MAINTAINERS b/MAINTAINERS
index 1be025959be9..32bb6280c219 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2625,6 +2625,15 @@ S:	Maintained
 F:      Documentation/hwmon/asc7621.rst
 F:      drivers/hwmon/asc7621.c
 
+ASPEED PINCTRL DRIVERS
+M:      Andrew Jeffery <andrew@aj.id.au>
+L:      linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
+L:      openbmc@lists.ozlabs.org (moderated for non-subscribers)
+L:      linux-gpio@vger.kernel.org
+S:      Maintained
+F:      drivers/pinctrl/aspeed/
+F:      Documentation/devicetree/bindings/pinctrl/aspeed,*
+
 ASPEED VIDEO ENGINE DRIVER
 M:      Eddie James <eajames@linux.ibm.com>
 L:      linux-media@vger.kernel.org
diff --git a/arch/arm64/boot/dts/freescale/imx8mn-pinfunc.h b/arch/arm64/boot/dts/freescale/imx8mn-pinfunc.h
new file mode 100644
index 000000000000..faf1e69e742b
--- /dev/null
+++ b/arch/arm64/boot/dts/freescale/imx8mn-pinfunc.h
@@ -0,0 +1,646 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright 2018-2019 NXP
+ */
+
+#ifndef __DTS_IMX8MN_PINFUNC_H
+#define __DTS_IMX8MN_PINFUNC_H
+
+/*
+ * The pin function ID is a tuple of
+ * <mux_reg conf_reg input_reg mux_mode input_val>
+ */
+
+#define MX8MN_IOMUXC_BOOT_MODE2_CCMSRCGPCMIX_BOOT_MODE2                        0x020 0x25C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_BOOT_MODE2_I2C1_SCL                                       0x020 0x25C 0x55C 0x1 0x3
+#define MX8MN_IOMUXC_BOOT_MODE3_CCMSRCGPCMIX_BOOT_MODE3                        0x024 0x260 0x000 0x0 0x0
+#define MX8MN_IOMUXC_BOOT_MODE3_I2C1_SDA                                       0x024 0x260 0x56C 0x1 0x3
+#define MX8MN_IOMUXC_GPIO1_IO00_GPIO1_IO0                                      0x028 0x290 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO00_CCMSRCGPCMIX_ENET_PHY_REF_CLK_ROOT             0x028 0x290 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO00_ANAMIX_REF_CLK_32K                             0x028 0x290 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO00_CCMSRCGPCMIX_EXT_CLK1                          0x028 0x290 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO01_GPIO1_IO1                                      0x02C 0x294 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO01_PWM1_OUT                                       0x02C 0x294 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO01_ANAMIX_REF_CLK_24M                             0x02C 0x294 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO01_CCMSRCGPCMIX_EXT_CLK2                          0x02C 0x294 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO02_GPIO1_IO2                                      0x030 0x298 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO02_WDOG1_WDOG_B                                   0x030 0x298 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO02_WDOG1_WDOG_ANY                                 0x030 0x298 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO03_GPIO1_IO3                                      0x034 0x29C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO03_USDHC1_VSELECT                                 0x034 0x29C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO03_SDMA1_EXT_EVENT0                               0x034 0x29C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO03_ANAMIX_XTAL_OK                                 0x034 0x29C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO04_GPIO1_IO4                                      0x038 0x2A0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO04_USDHC2_VSELECT                                 0x038 0x2A0 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO04_SDMA1_EXT_EVENT1                               0x038 0x2A0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO04_ANAMIX_XTAL_OK_LV                              0x038 0x2A0 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO05_GPIO1_IO5                                      0x03C 0x2A4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO05_M4_NMI                                         0x03C 0x2A4 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO05_CCMSRCGPCMIX_PMIC_READY                        0x03C 0x2A4 0x4BC 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO05_CCMSRCGPCMIX_INT_BOOT                          0x03C 0x2A4 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO06_GPIO1_IO6                                      0x040 0x2A8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO06_ENET1_MDC                                      0x040 0x2A8 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO06_USDHC1_CD_B                                    0x040 0x2A8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO06_CCMSRCGPCMIX_EXT_CLK3                          0x040 0x2A8 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO07_GPIO1_IO7                                      0x044 0x2AC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO07_ENET1_MDIO                                     0x044 0x2AC 0x4C0 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO07_USDHC1_WP                                      0x044 0x2AC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO07_CCMSRCGPCMIX_EXT_CLK4                          0x044 0x2AC 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO08_GPIO1_IO8                                      0x048 0x2B0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO08_ENET1_1588_EVENT0_IN                           0x048 0x2B0 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO08_PWM1_OUT                                       0x048 0x2B0 0x000 0x2 0x0
+#define MX8MN_IOMUXC_GPIO1_IO08_USDHC2_RESET_B                                 0x048 0x2B0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO08_CCMSRCGPCMIX_WAIT                              0x048 0x2B0 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_GPIO1_IO9                                      0x04C 0x2B4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_ENET1_1588_EVENT0_OUT                          0x04C 0x2B4 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_PWM2_OUT                                       0x04C 0x2B4 0x000 0x2 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_USDHC3_RESET_B                                 0x04C 0x2B4 0x000 0x4 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_SDMA2_EXT_EVENT0                               0x04C 0x2B4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO09_CCMSRCGPCMIX_STOP                              0x04C 0x2B4 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO10_GPIO1_IO10                                     0x050 0x2B8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO10_USB1_OTG_ID                                    0x050 0x2B8 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO10_PWM3_OUT                                       0x050 0x2B8 0x000 0x2 0x0
+#define MX8MN_IOMUXC_GPIO1_IO11_GPIO1_IO11                                     0x054 0x2BC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO11_PWM2_OUT                                       0x054 0x2BC 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO11_USDHC3_VSELECT                                 0x054 0x2BC 0x000 0x4 0x0
+#define MX8MN_IOMUXC_GPIO1_IO11_CCMSRCGPCMIX_PMIC_READY                        0x054 0x2BC 0x4BC 0x5 0x1
+#define MX8MN_IOMUXC_GPIO1_IO11_CCMSRCGPCMIX_OUT0                              0x054 0x2BC 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO12_GPIO1_IO12                                     0x058 0x2C0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO12_USB1_OTG_PWR                                   0x058 0x2C0 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO12_SDMA2_EXT_EVENT1                               0x058 0x2C0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO12_CCMSRCGPCMIX_OUT1                              0x058 0x2C0 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO13_GPIO1_IO13                                     0x05C 0x2C4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO13_USB1_OTG_OC                                    0x05C 0x2C4 0x000 0x1 0x0
+#define MX8MN_IOMUXC_GPIO1_IO13_PWM2_OUT                                       0x05C 0x2C4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO13_CCMSRCGPCMIX_OUT2                              0x05C 0x2C4 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO14_GPIO1_IO14                                     0x060 0x2C8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO14_USDHC3_CD_B                                    0x060 0x2C8 0x598 0x4 0x2
+#define MX8MN_IOMUXC_GPIO1_IO14_PWM3_OUT                                       0x060 0x2C8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO14_CCMSRCGPCMIX_CLKO1                             0x060 0x2C8 0x000 0x6 0x0
+#define MX8MN_IOMUXC_GPIO1_IO15_GPIO1_IO15                                     0x064 0x2CC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_GPIO1_IO15_USDHC3_WP                                      0x064 0x2CC 0x5B8 0x4 0x2
+#define MX8MN_IOMUXC_GPIO1_IO15_PWM4_OUT                                       0x064 0x2CC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_GPIO1_IO15_CCMSRCGPCMIX_CLKO2                             0x064 0x2CC 0x000 0x6 0x0
+#define MX8MN_IOMUXC_ENET_MDC_ENET1_MDC                                        0x068 0x2D0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_MDC_SAI6_TX_DATA0                                    0x068 0x2D0 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_MDC_PDM_BIT_STREAM3                                  0x068 0x2D0 0x540 0x3 0x1
+#define MX8MN_IOMUXC_ENET_MDC_SPDIF1_OUT                                       0x068 0x2D0 0x000 0x4 0x0
+#define MX8MN_IOMUXC_ENET_MDC_GPIO1_IO16                                       0x068 0x2D0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_MDC_USDHC3_STROBE                                    0x068 0x2D0 0x59C 0x6 0x1
+#define MX8MN_IOMUXC_ENET_MDIO_ENET1_MDIO                                      0x06C 0x2D4 0x4C0 0x0 0x1
+#define MX8MN_IOMUXC_ENET_MDIO_SAI6_TX_SYNC                                    0x06C 0x2D4 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_MDIO_PDM_BIT_STREAM2                                 0x06C 0x2D4 0x53C 0x3 0x1
+#define MX8MN_IOMUXC_ENET_MDIO_SPDIF1_IN                                       0x06C 0x2D4 0x5CC 0x4 0x1
+#define MX8MN_IOMUXC_ENET_MDIO_GPIO1_IO17                                      0x06C 0x2D4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_MDIO_USDHC3_DATA5                                    0x06C 0x2D4 0x550 0x6 0x1
+#define MX8MN_IOMUXC_ENET_TD3_ENET1_RGMII_TD3                                  0x070 0x2D8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TD3_SAI6_TX_BCLK                                     0x070 0x2D8 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TD3_PDM_BIT_STREAM1                                  0x070 0x2D8 0x538 0x3 0x1
+#define MX8MN_IOMUXC_ENET_TD3_SPDIF1_EXT_CLK                                   0x070 0x2D8 0x568 0x4 0x1
+#define MX8MN_IOMUXC_ENET_TD3_GPIO1_IO18                                       0x070 0x2D8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TD3_USDHC3_DATA6                                     0x070 0x2D8 0x584 0x6 0x1
+#define MX8MN_IOMUXC_ENET_TD2_ENET1_RGMII_TD2                                  0x074 0x2DC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TD2_ENET1_TX_CLK                                     0x074 0x2DC 0x5A4 0x1 0x0
+#define MX8MN_IOMUXC_ENET_TD2_CCMSRCGPCMIX_ENET_REF_CLK_ROOT                   0x074 0x2DC 0x5A4 0x1 0x0
+#define MX8MN_IOMUXC_ENET_TD2_SAI6_RX_DATA0                                    0x074 0x2DC 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TD2_PDM_BIT_STREAM3                                  0x074 0x2DC 0x540 0x3 0x2
+#define MX8MN_IOMUXC_ENET_TD2_GPIO1_IO19                                       0x074 0x2DC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TD2_USDHC3_DATA7                                     0x074 0x2DC 0x54C 0x6 0x1
+#define MX8MN_IOMUXC_ENET_TD1_ENET1_RGMII_TD1                                  0x078 0x2E0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TD1_SAI6_RX_SYNC                                     0x078 0x2E0 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TD1_PDM_BIT_STREAM2                                  0x078 0x2E0 0x53C 0x3 0x2
+#define MX8MN_IOMUXC_ENET_TD1_GPIO1_IO20                                       0x078 0x2E0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TD1_USDHC3_CD_B                                      0x078 0x2E0 0x598 0x6 0x3
+#define MX8MN_IOMUXC_ENET_TD0_ENET1_RGMII_TD0                                  0x07C 0x2E4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TD0_SAI6_RX_BCLK                                     0x07C 0x2E4 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TD0_PDM_BIT_STREAM1                                  0x07C 0x2E4 0x538 0x3 0x2
+#define MX8MN_IOMUXC_ENET_TD0_GPIO1_IO21                                       0x07C 0x2E4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TD0_USDHC3_WP                                        0x07C 0x2E4 0x5B8 0x6 0x3
+#define MX8MN_IOMUXC_ENET_TX_CTL_ENET1_RGMII_TX_CTL                            0x080 0x2E8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TX_CTL_SAI6_MCLK                                     0x080 0x2E8 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TX_CTL_GPIO1_IO22                                    0x080 0x2E8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TX_CTL_USDHC3_DATA0                                  0x080 0x2E8 0x5B4 0x6 0x1
+#define MX8MN_IOMUXC_ENET_TXC_ENET1_RGMII_TXC                                  0x084 0x2EC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_TXC_ENET1_TX_ER                                      0x084 0x2EC 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ENET_TXC_SAI7_TX_DATA0                                    0x084 0x2EC 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_TXC_GPIO1_IO23                                       0x084 0x2EC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_TXC_USDHC3_DATA1                                     0x084 0x2EC 0x5B0 0x6 0x1
+#define MX8MN_IOMUXC_ENET_RX_CTL_ENET1_RGMII_RX_CTL                            0x088 0x2F0 0x574 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RX_CTL_SAI7_TX_SYNC                                  0x088 0x2F0 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RX_CTL_PDM_BIT_STREAM3                               0x088 0x2F0 0x540 0x3 0x3
+#define MX8MN_IOMUXC_ENET_RX_CTL_GPIO1_IO24                                    0x088 0x2F0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RX_CTL_USDHC3_DATA2                                  0x088 0x2F0 0x5E4 0x6 0x1
+#define MX8MN_IOMUXC_ENET_RXC_ENET1_RGMII_RXC                                  0x08C 0x2F4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RXC_ENET1_RX_ER                                      0x08C 0x2F4 0x5C8 0x1 0x0
+#define MX8MN_IOMUXC_ENET_RXC_SAI7_TX_BCLK                                     0x08C 0x2F4 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RXC_PDM_BIT_STREAM2                                  0x08C 0x2F4 0x53C 0x3 0x3
+#define MX8MN_IOMUXC_ENET_RXC_GPIO1_IO25                                       0x08C 0x2F4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RXC_USDHC3_DATA3                                     0x08C 0x2F4 0x5E0 0x6 0x1
+#define MX8MN_IOMUXC_ENET_RD0_ENET1_RGMII_RD0                                  0x090 0x2F8 0x57C 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RD0_SAI7_RX_DATA0                                    0x090 0x2F8 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RD0_PDM_BIT_STREAM1                                  0x090 0x2F8 0x538 0x3 0x3
+#define MX8MN_IOMUXC_ENET_RD0_GPIO1_IO26                                       0x090 0x2F8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RD0_USDHC3_DATA4                                     0x090 0x2F8 0x558 0x6 0x1
+#define MX8MN_IOMUXC_ENET_RD1_ENET1_RGMII_RD1                                  0x094 0x2FC 0x554 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RD1_SAI7_RX_SYNC                                     0x094 0x2FC 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RD1_PDM_BIT_STREAM0                                  0x094 0x2FC 0x534 0x3 0x1
+#define MX8MN_IOMUXC_ENET_RD1_GPIO1_IO27                                       0x094 0x2FC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RD1_USDHC3_RESET_B                                   0x094 0x2FC 0x000 0x6 0x0
+#define MX8MN_IOMUXC_ENET_RD2_ENET1_RGMII_RD2                                  0x098 0x300 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RD2_SAI7_RX_BCLK                                     0x098 0x300 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RD2_PDM_CLK                                          0x098 0x300 0x000 0x3 0x0
+#define MX8MN_IOMUXC_ENET_RD2_GPIO1_IO28                                       0x098 0x300 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RD2_USDHC3_CLK                                       0x098 0x300 0x5A0 0x6 0x1
+#define MX8MN_IOMUXC_ENET_RD3_ENET1_RGMII_RD3                                  0x09C 0x304 0x000 0x0 0x0
+#define MX8MN_IOMUXC_ENET_RD3_SAI7_MCLK                                        0x09C 0x304 0x000 0x2 0x0
+#define MX8MN_IOMUXC_ENET_RD3_SPDIF1_IN                                        0x09C 0x304 0x5CC 0x3 0x5
+#define MX8MN_IOMUXC_ENET_RD3_GPIO1_IO29                                       0x09C 0x304 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ENET_RD3_USDHC3_CMD                                       0x09C 0x304 0x5DC 0x6 0x1
+#define MX8MN_IOMUXC_SD1_CLK_USDHC1_CLK                                        0x0A0 0x308 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_CLK_ENET1_MDC                                         0x0A0 0x308 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD1_CLK_UART1_DCE_TX                                      0x0A0 0x308 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_CLK_UART1_DTE_RX                                      0x0A0 0x308 0x4F4 0x4 0x4
+#define MX8MN_IOMUXC_SD1_CLK_GPIO2_IO0                                         0x0A0 0x308 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_CMD_USDHC1_CMD                                        0x0A4 0x30C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_CMD_ENET1_MDIO                                        0x0A4 0x30C 0x4C0 0x1 0x3
+#define MX8MN_IOMUXC_SD1_CMD_UART1_DCE_RX                                      0x0A4 0x30C 0x4F4 0x4 0x5
+#define MX8MN_IOMUXC_SD1_CMD_UART1_DTE_TX                                      0x0A4 0x30C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_CMD_GPIO2_IO1                                         0x0A4 0x30C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA0_USDHC1_DATA0                                    0x0A8 0x310 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA0_ENET1_RGMII_TD1                                 0x0A8 0x310 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD1_DATA0_UART1_DCE_RTS_B                                 0x0A8 0x310 0x4F0 0x4 0x4
+#define MX8MN_IOMUXC_SD1_DATA0_UART1_DTE_CTS_B                                 0x0A8 0x310 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA0_GPIO2_IO2                                       0x0A8 0x310 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA1_USDHC1_DATA1                                    0x0AC 0x314 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA1_ENET1_RGMII_TD0                                 0x0AC 0x314 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD1_DATA1_UART1_DCE_CTS_B                                 0x0AC 0x314 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA1_UART1_DTE_RTS_B                                 0x0AC 0x314 0x4F0 0x4 0x5
+#define MX8MN_IOMUXC_SD1_DATA1_GPIO2_IO3                                       0x0AC 0x314 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA2_USDHC1_DATA2                                    0x0B0 0x318 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA2_ENET1_RGMII_RD0                                 0x0B0 0x318 0x57C 0x1 0x1
+#define MX8MN_IOMUXC_SD1_DATA2_UART2_DCE_TX                                    0x0B0 0x318 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA2_UART2_DTE_RX                                    0x0B0 0x318 0x4FC 0x4 0x4
+#define MX8MN_IOMUXC_SD1_DATA2_GPIO2_IO4                                       0x0B0 0x318 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA3_USDHC1_DATA3                                    0x0B4 0x31C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA3_ENET1_RGMII_RD1                                 0x0B4 0x31C 0x554 0x1 0x1
+#define MX8MN_IOMUXC_SD1_DATA3_UART2_DCE_RX                                    0x0B4 0x31C 0x4FC 0x4 0x5
+#define MX8MN_IOMUXC_SD1_DATA3_UART2_DTE_TX                                    0x0B4 0x31C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA3_GPIO2_IO5                                       0x0B4 0x31C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA4_USDHC1_DATA4                                    0x0B8 0x320 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA4_ENET1_RGMII_TX_CTL                              0x0B8 0x320 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD1_DATA4_I2C1_SCL                                        0x0B8 0x320 0x55C 0x3 0x1
+#define MX8MN_IOMUXC_SD1_DATA4_UART2_DCE_RTS_B                                 0x0B8 0x320 0x4F8 0x4 0x4
+#define MX8MN_IOMUXC_SD1_DATA4_UART2_DTE_CTS_B                                 0x0B8 0x320 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA4_GPIO2_IO6                                       0x0B8 0x320 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA5_USDHC1_DATA5                                    0x0BC 0x324 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA5_ENET1_TX_ER                                     0x0BC 0x324 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD1_DATA5_I2C1_SDA                                        0x0BC 0x324 0x56C 0x3 0x1
+#define MX8MN_IOMUXC_SD1_DATA5_UART2_DCE_CTS_B                                 0x0BC 0x324 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA5_UART2_DTE_RTS_B                                 0x0BC 0x324 0x4F8 0x4 0x5
+#define MX8MN_IOMUXC_SD1_DATA5_GPIO2_IO7                                       0x0BC 0x324 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA6_USDHC1_DATA6                                    0x0C0 0x328 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA6_ENET1_RGMII_RX_CTL                              0x0C0 0x328 0x574 0x1 0x1
+#define MX8MN_IOMUXC_SD1_DATA6_I2C2_SCL                                        0x0C0 0x328 0x5D0 0x3 0x1
+#define MX8MN_IOMUXC_SD1_DATA6_UART3_DCE_TX                                    0x0C0 0x328 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA6_UART3_DTE_RX                                    0x0C0 0x328 0x504 0x4 0x4
+#define MX8MN_IOMUXC_SD1_DATA6_GPIO2_IO8                                       0x0C0 0x328 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_DATA7_USDHC1_DATA7                                    0x0C4 0x32C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_DATA7_ENET1_RX_ER                                     0x0C4 0x32C 0x5C8 0x1 0x1
+#define MX8MN_IOMUXC_SD1_DATA7_I2C2_SDA                                        0x0C4 0x32C 0x560 0x3 0x1
+#define MX8MN_IOMUXC_SD1_DATA7_UART3_DCE_RX                                    0x0C4 0x32C 0x504 0x4 0x5
+#define MX8MN_IOMUXC_SD1_DATA7_UART3_DTE_TX                                    0x0C4 0x32C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_DATA7_GPIO2_IO9                                       0x0C4 0x32C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_RESET_B_USDHC1_RESET_B                                0x0C8 0x330 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_RESET_B_ENET1_TX_CLK                                  0x0C8 0x330 0x5A4 0x1 0x1
+#define MX8MN_IOMUXC_SD1_RESET_B_CCMSRCGPCMIX_ENET_REF_CLK_ROOT                0x0C8 0x330 0x5A4 0x1 0x0
+#define MX8MN_IOMUXC_SD1_RESET_B_I2C3_SCL                                      0x0C8 0x330 0x588 0x3 0x1
+#define MX8MN_IOMUXC_SD1_RESET_B_UART3_DCE_RTS_B                               0x0C8 0x330 0x500 0x4 0x2
+#define MX8MN_IOMUXC_SD1_RESET_B_UART3_DTE_CTS_B                               0x0C8 0x330 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_RESET_B_GPIO2_IO10                                    0x0C8 0x330 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD1_STROBE_USDHC1_STROBE                                  0x0CC 0x334 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD1_STROBE_I2C3_SDA                                       0x0CC 0x334 0x5BC 0x3 0x1
+#define MX8MN_IOMUXC_SD1_STROBE_UART3_DCE_CTS_B                                0x0CC 0x334 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD1_STROBE_UART3_DTE_RTS_B                                0x0CC 0x334 0x500 0x4 0x3
+#define MX8MN_IOMUXC_SD1_STROBE_GPIO2_IO11                                     0x0CC 0x334 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_CD_B_USDHC2_CD_B                                      0x0D0 0x338 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_CD_B_GPIO2_IO12                                       0x0D0 0x338 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_CD_B_CCMSRCGPCMIX_TESTER_ACK                          0x0D0 0x338 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_CLK_USDHC2_CLK                                        0x0D4 0x33C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_CLK_SAI5_RX_SYNC                                      0x0D4 0x33C 0x4E4 0x1 0x1
+#define MX8MN_IOMUXC_SD2_CLK_ECSPI2_SCLK                                       0x0D4 0x33C 0x580 0x2 0x1
+#define MX8MN_IOMUXC_SD2_CLK_UART4_DCE_RX                                      0x0D4 0x33C 0x50C 0x3 0x4
+#define MX8MN_IOMUXC_SD2_CLK_UART4_DTE_TX                                      0x0D4 0x33C 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SD2_CLK_SAI5_MCLK                                         0x0D4 0x33C 0x594 0x4 0x1
+#define MX8MN_IOMUXC_SD2_CLK_GPIO2_IO13                                        0x0D4 0x33C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_CLK_CCMSRCGPCMIX_OBSERVE0                             0x0D4 0x33C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_CMD_USDHC2_CMD                                        0x0D8 0x340 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_CMD_SAI5_RX_BCLK                                      0x0D8 0x340 0x4D0 0x1 0x1
+#define MX8MN_IOMUXC_SD2_CMD_ECSPI2_MOSI                                       0x0D8 0x340 0x590 0x2 0x1
+#define MX8MN_IOMUXC_SD2_CMD_UART4_DCE_TX                                      0x0D8 0x340 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SD2_CMD_UART4_DTE_RX                                      0x0D8 0x340 0x50C 0x3 0x5
+#define MX8MN_IOMUXC_SD2_CMD_PDM_CLK                                           0x0D8 0x340 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SD2_CMD_GPIO2_IO14                                        0x0D8 0x340 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_CMD_CCMSRCGPCMIX_OBSERVE1                             0x0D8 0x340 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_DATA0_USDHC2_DATA0                                    0x0DC 0x344 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_DATA0_SAI5_RX_DATA0                                   0x0DC 0x344 0x4D4 0x1 0x1
+#define MX8MN_IOMUXC_SD2_DATA0_I2C4_SDA                                        0x0DC 0x344 0x58C 0x2 0x1
+#define MX8MN_IOMUXC_SD2_DATA0_UART2_DCE_RX                                    0x0DC 0x344 0x4FC 0x3 0x6
+#define MX8MN_IOMUXC_SD2_DATA0_UART2_DTE_TX                                    0x0DC 0x344 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SD2_DATA0_PDM_BIT_STREAM0                                 0x0DC 0x344 0x534 0x4 0x2
+#define MX8MN_IOMUXC_SD2_DATA0_GPIO2_IO15                                      0x0DC 0x344 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_DATA0_CCMSRCGPCMIX_OBSERVE2                           0x0DC 0x344 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_DATA1_USDHC2_DATA1                                    0x0E0 0x348 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_DATA1_SAI5_TX_SYNC                                    0x0E0 0x348 0x4EC 0x1 0x1
+#define MX8MN_IOMUXC_SD2_DATA1_I2C4_SCL                                        0x0E0 0x348 0x5D4 0x2 0x1
+#define MX8MN_IOMUXC_SD2_DATA1_UART2_DCE_TX                                    0x0E0 0x348 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SD2_DATA1_UART2_DTE_RX                                    0x0E0 0x348 0x4FC 0x3 0x7
+#define MX8MN_IOMUXC_SD2_DATA1_PDM_BIT_STREAM1                                 0x0E0 0x348 0x538 0x4 0x4
+#define MX8MN_IOMUXC_SD2_DATA1_GPIO2_IO16                                      0x0E0 0x348 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_DATA1_CCMSRCGPCMIX_WAIT                               0x0E0 0x348 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_DATA2_USDHC2_DATA2                                    0x0E4 0x34C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_DATA2_SAI5_TX_BCLK                                    0x0E4 0x34C 0x4E8 0x1 0x1
+#define MX8MN_IOMUXC_SD2_DATA2_ECSPI2_SS0                                      0x0E4 0x34C 0x570 0x2 0x2
+#define MX8MN_IOMUXC_SD2_DATA2_SPDIF1_OUT                                      0x0E4 0x34C 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SD2_DATA2_PDM_BIT_STREAM2                                 0x0E4 0x34C 0x53C 0x4 0x4
+#define MX8MN_IOMUXC_SD2_DATA2_GPIO2_IO17                                      0x0E4 0x34C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_DATA2_CCMSRCGPCMIX_STOP                               0x0E4 0x34C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_DATA3_USDHC2_DATA3                                    0x0E8 0x350 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_DATA3_SAI5_TX_DATA0                                   0x0E8 0x350 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SD2_DATA3_ECSPI2_MISO                                     0x0E8 0x350 0x578 0x2 0x1
+#define MX8MN_IOMUXC_SD2_DATA3_SPDIF1_IN                                       0x0E8 0x350 0x5CC 0x3 0x2
+#define MX8MN_IOMUXC_SD2_DATA3_PDM_BIT_STREAM3                                 0x0E8 0x350 0x540 0x4 0x4
+#define MX8MN_IOMUXC_SD2_DATA3_GPIO2_IO18                                      0x0E8 0x350 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_DATA3_CCMSRCGPCMIX_EARLY_RESET                        0x0E8 0x350 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_RESET_B_USDHC2_RESET_B                                0x0EC 0x354 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_RESET_B_GPIO2_IO19                                    0x0EC 0x354 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_RESET_B_CCMSRCGPCMIX_SYSTEM_RESET                     0x0EC 0x354 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SD2_WP_USDHC2_WP                                          0x0F0 0x358 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SD2_WP_GPIO2_IO20                                         0x0F0 0x358 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SD2_WP_CORESIGHT_EVENTI                                   0x0F0 0x358 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_ALE_RAWNAND_ALE                                      0x0F4 0x35C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_ALE_QSPI_A_SCLK                                      0x0F4 0x35C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_ALE_PDM_BIT_STREAM0                                  0x0F4 0x35C 0x534 0x3 0x3
+#define MX8MN_IOMUXC_NAND_ALE_UART3_DCE_RX                                     0x0F4 0x35C 0x504 0x4 0x6
+#define MX8MN_IOMUXC_NAND_ALE_UART3_DTE_TX                                     0x0F4 0x35C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_NAND_ALE_GPIO3_IO0                                        0x0F4 0x35C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_ALE_CORESIGHT_TRACE_CLK                              0x0F4 0x35C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_CE0_B_RAWNAND_CE0_B                                  0x0F8 0x360 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_CE0_B_QSPI_A_SS0_B                                   0x0F8 0x360 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_CE0_B_PDM_BIT_STREAM1                                0x0F8 0x360 0x538 0x3 0x5
+#define MX8MN_IOMUXC_NAND_CE0_B_UART3_DCE_TX                                   0x0F8 0x360 0x000 0x4 0x0
+#define MX8MN_IOMUXC_NAND_CE0_B_UART3_DTE_RX                                   0x0F8 0x360 0x504 0x4 0x7
+#define MX8MN_IOMUXC_NAND_CE0_B_GPIO3_IO1                                      0x0F8 0x360 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_CE0_B_CORESIGHT_TRACE_CTL                            0x0F8 0x360 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_CE1_B_RAWNAND_CE1_B                                  0x0FC 0x364 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_CE1_B_QSPI_A_SS1_B                                   0x0FC 0x364 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_CE1_B_USDHC3_STROBE                                  0x0FC 0x364 0x59C 0x2 0x0
+#define MX8MN_IOMUXC_NAND_CE1_B_PDM_BIT_STREAM0                                0x0FC 0x364 0x534 0x3 0x4
+#define MX8MN_IOMUXC_NAND_CE1_B_I2C4_SCL                                       0x0FC 0x364 0x5D4 0x4 0x2
+#define MX8MN_IOMUXC_NAND_CE1_B_GPIO3_IO2                                      0x0FC 0x364 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_CE1_B_CORESIGHT_TRACE0                               0x0FC 0x364 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_CE2_B_RAWNAND_CE2_B                                  0x100 0x368 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_CE2_B_QSPI_B_SS0_B                                   0x100 0x368 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_CE2_B_USDHC3_DATA5                                   0x100 0x368 0x550 0x2 0x0
+#define MX8MN_IOMUXC_NAND_CE2_B_PDM_BIT_STREAM1                                0x100 0x368 0x538 0x3 0x6
+#define MX8MN_IOMUXC_NAND_CE2_B_I2C4_SDA                                       0x100 0x368 0x58C 0x4 0x2
+#define MX8MN_IOMUXC_NAND_CE2_B_GPIO3_IO3                                      0x100 0x368 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_CE2_B_CORESIGHT_TRACE1                               0x100 0x368 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_CE3_B_RAWNAND_CE3_B                                  0x104 0x36C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_CE3_B_QSPI_B_SS1_B                                   0x104 0x36C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_CE3_B_USDHC3_DATA6                                   0x104 0x36C 0x584 0x2 0x0
+#define MX8MN_IOMUXC_NAND_CE3_B_PDM_BIT_STREAM2                                0x104 0x36C 0x53C 0x3 0x5
+#define MX8MN_IOMUXC_NAND_CE3_B_I2C3_SDA                                       0x104 0x36C 0x5BC 0x4 0x2
+#define MX8MN_IOMUXC_NAND_CE3_B_GPIO3_IO4                                      0x104 0x36C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_CE3_B_CORESIGHT_TRACE2                               0x104 0x36C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_CLE_RAWNAND_CLE                                      0x108 0x370 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_CLE_QSPI_B_SCLK                                      0x108 0x370 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_CLE_USDHC3_DATA7                                     0x108 0x370 0x54C 0x2 0x0
+#define MX8MN_IOMUXC_NAND_CLE_GPIO3_IO5                                        0x108 0x370 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_CLE_CORESIGHT_TRACE3                                 0x108 0x370 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA00_RAWNAND_DATA00                                0x10C 0x374 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA00_QSPI_A_DATA0                                  0x10C 0x374 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA00_PDM_BIT_STREAM2                               0x10C 0x374 0x53C 0x3 0x6
+#define MX8MN_IOMUXC_NAND_DATA00_UART4_DCE_RX                                  0x10C 0x374 0x50C 0x4 0x6
+#define MX8MN_IOMUXC_NAND_DATA00_UART4_DTE_TX                                  0x10C 0x374 0x000 0x4 0x0
+#define MX8MN_IOMUXC_NAND_DATA00_GPIO3_IO6                                     0x10C 0x374 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA00_CORESIGHT_TRACE4                              0x10C 0x374 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA01_RAWNAND_DATA01                                0x110 0x378 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA01_QSPI_A_DATA1                                  0x110 0x378 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA01_PDM_BIT_STREAM3                               0x110 0x378 0x540 0x3 0x5
+#define MX8MN_IOMUXC_NAND_DATA01_UART4_DCE_TX                                  0x110 0x378 0x000 0x4 0x0
+#define MX8MN_IOMUXC_NAND_DATA01_UART4_DTE_RX                                  0x110 0x378 0x50C 0x4 0x7
+#define MX8MN_IOMUXC_NAND_DATA01_GPIO3_IO7                                     0x110 0x378 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA01_CORESIGHT_TRACE5                              0x110 0x378 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA02_RAWNAND_DATA02                                0x114 0x37C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA02_QSPI_A_DATA2                                  0x114 0x37C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA02_USDHC3_CD_B                                   0x114 0x37C 0x598 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA02_I2C4_SDA                                      0x114 0x37C 0x58C 0x4 0x3
+#define MX8MN_IOMUXC_NAND_DATA02_GPIO3_IO8                                     0x114 0x37C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA02_CORESIGHT_TRACE6                              0x114 0x37C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA03_RAWNAND_DATA03                                0x118 0x380 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA03_QSPI_A_DATA3                                  0x118 0x380 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA03_USDHC3_WP                                     0x118 0x380 0x5B8 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA03_GPIO3_IO9                                     0x118 0x380 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA03_CORESIGHT_TRACE7                              0x118 0x380 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA04_RAWNAND_DATA04                                0x11C 0x384 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA04_QSPI_B_DATA0                                  0x11C 0x384 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA04_USDHC3_DATA0                                  0x11C 0x384 0x5B4 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA04_GPIO3_IO10                                    0x11C 0x384 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA04_CORESIGHT_TRACE8                              0x11C 0x384 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA05_RAWNAND_DATA05                                0x120 0x388 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA05_QSPI_B_DATA1                                  0x120 0x388 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA05_USDHC3_DATA1                                  0x120 0x388 0x5B0 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA05_GPIO3_IO11                                    0x120 0x388 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA05_CORESIGHT_TRACE9                              0x120 0x388 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA06_RAWNAND_DATA06                                0x124 0x38C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA06_QSPI_B_DATA2                                  0x124 0x38C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA06_USDHC3_DATA2                                  0x124 0x38C 0x5E4 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA06_GPIO3_IO12                                    0x124 0x38C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA06_CORESIGHT_TRACE10                             0x124 0x38C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DATA07_RAWNAND_DATA07                                0x128 0x390 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DATA07_QSPI_B_DATA3                                  0x128 0x390 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DATA07_USDHC3_DATA3                                  0x128 0x390 0x5E0 0x2 0x0
+#define MX8MN_IOMUXC_NAND_DATA07_GPIO3_IO13                                    0x128 0x390 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DATA07_CORESIGHT_TRACE11                             0x128 0x390 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_DQS_RAWNAND_DQS                                      0x12C 0x394 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_DQS_QSPI_A_DQS                                       0x12C 0x394 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_DQS_PDM_CLK                                          0x12C 0x394 0x000 0x3 0x0
+#define MX8MN_IOMUXC_NAND_DQS_I2C3_SCL                                         0x12C 0x394 0x588 0x4 0x2
+#define MX8MN_IOMUXC_NAND_DQS_GPIO3_IO14                                       0x12C 0x394 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_DQS_CORESIGHT_TRACE12                                0x12C 0x394 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_RE_B_RAWNAND_RE_B                                    0x130 0x398 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_RE_B_QSPI_B_DQS                                      0x130 0x398 0x000 0x1 0x0
+#define MX8MN_IOMUXC_NAND_RE_B_USDHC3_DATA4                                    0x130 0x398 0x558 0x2 0x0
+#define MX8MN_IOMUXC_NAND_RE_B_PDM_BIT_STREAM1                                 0x130 0x398 0x538 0x3 0x7
+#define MX8MN_IOMUXC_NAND_RE_B_GPIO3_IO15                                      0x130 0x398 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_RE_B_CORESIGHT_TRACE13                               0x130 0x398 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_READY_B_RAWNAND_READY_B                              0x134 0x39C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_READY_B_USDHC3_RESET_B                               0x134 0x39C 0x000 0x2 0x0
+#define MX8MN_IOMUXC_NAND_READY_B_PDM_BIT_STREAM3                              0x134 0x39C 0x540 0x3 0x6
+#define MX8MN_IOMUXC_NAND_READY_B_I2C3_SCL                                     0x134 0x39C 0x588 0x4 0x3
+#define MX8MN_IOMUXC_NAND_READY_B_GPIO3_IO16                                   0x134 0x39C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_READY_B_CORESIGHT_TRACE14                            0x134 0x39C 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_WE_B_RAWNAND_WE_B                                    0x138 0x3A0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_WE_B_USDHC3_CLK                                      0x138 0x3A0 0x5A0 0x2 0x0
+#define MX8MN_IOMUXC_NAND_WE_B_I2C3_SDA                                        0x138 0x3A0 0x5BC 0x4 0x3
+#define MX8MN_IOMUXC_NAND_WE_B_GPIO3_IO17                                      0x138 0x3A0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_WE_B_CORESIGHT_TRACE15                               0x138 0x3A0 0x000 0x6 0x0
+#define MX8MN_IOMUXC_NAND_WP_B_RAWNAND_WP_B                                    0x13C 0x3A4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_NAND_WP_B_USDHC3_CMD                                      0x13C 0x3A4 0x5DC 0x2 0x0
+#define MX8MN_IOMUXC_NAND_WP_B_I2C4_SDA                                        0x13C 0x3A4 0x58C 0x4 0x4
+#define MX8MN_IOMUXC_NAND_WP_B_GPIO3_IO18                                      0x13C 0x3A4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_NAND_WP_B_CORESIGHT_EVENTO                                0x13C 0x3A4 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SAI5_RXFS_SAI5_RX_SYNC                                    0x140 0x3A8 0x4E4 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXFS_GPIO3_IO19                                      0x140 0x3A8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_RXC_SAI5_RX_BCLK                                     0x144 0x3AC 0x4D0 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXC_PDM_CLK                                          0x144 0x3AC 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI5_RXC_GPIO3_IO20                                       0x144 0x3AC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_RXD0_SAI5_RX_DATA0                                   0x148 0x3B0 0x4D4 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXD0_PDM_BIT_STREAM0                                 0x148 0x3B0 0x534 0x4 0x0
+#define MX8MN_IOMUXC_SAI5_RXD0_GPIO3_IO21                                      0x148 0x3B0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_RXD1_SAI5_RX_DATA1                                   0x14C 0x3B4 0x4D8 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXD1_SAI5_TX_SYNC                                    0x14C 0x3B4 0x4EC 0x3 0x0
+#define MX8MN_IOMUXC_SAI5_RXD1_PDM_BIT_STREAM1                                 0x14C 0x3B4 0x538 0x4 0x0
+#define MX8MN_IOMUXC_SAI5_RXD1_GPIO3_IO22                                      0x14C 0x3B4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_RXD2_SAI5_RX_DATA2                                   0x150 0x3B8 0x4DC 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXD2_SAI5_TX_BCLK                                    0x150 0x3B8 0x4E8 0x3 0x0
+#define MX8MN_IOMUXC_SAI5_RXD2_PDM_BIT_STREAM2                                 0x150 0x3B8 0x53C 0x4 0x0
+#define MX8MN_IOMUXC_SAI5_RXD2_GPIO3_IO23                                      0x150 0x3B8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_RXD3_SAI5_RX_DATA3                                   0x154 0x3BC 0x4E0 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_RXD3_SAI5_TX_DATA0                                   0x154 0x3BC 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI5_RXD3_PDM_BIT_STREAM3                                 0x154 0x3BC 0x540 0x4 0x0
+#define MX8MN_IOMUXC_SAI5_RXD3_GPIO3_IO24                                      0x154 0x3BC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI5_MCLK_SAI5_MCLK                                       0x158 0x3C0 0x594 0x0 0x0
+#define MX8MN_IOMUXC_SAI5_MCLK_GPIO3_IO25                                      0x158 0x3C0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_SAI2_RX_SYNC                                    0x1B0 0x418 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_SAI5_TX_SYNC                                    0x1B0 0x418 0x4EC 0x1 0x2
+#define MX8MN_IOMUXC_SAI2_RXFS_SAI5_TX_DATA1                                   0x1B0 0x418 0x000 0x2 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_SAI2_RX_DATA1                                   0x1B0 0x418 0x5AC 0x3 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_UART1_DCE_TX                                    0x1B0 0x418 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_UART1_DTE_RX                                    0x1B0 0x418 0x4F4 0x4 0x2
+#define MX8MN_IOMUXC_SAI2_RXFS_GPIO4_IO21                                      0x1B0 0x418 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_RXFS_PDM_BIT_STREAM2                                 0x1B0 0x418 0x53C 0x6 0x7
+#define MX8MN_IOMUXC_SAI2_RXC_SAI2_RX_BCLK                                     0x1B4 0x41C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_RXC_SAI5_TX_BCLK                                     0x1B4 0x41C 0x4E8 0x1 0x2
+#define MX8MN_IOMUXC_SAI2_RXC_UART1_DCE_RX                                     0x1B4 0x41C 0x4F4 0x4 0x3
+#define MX8MN_IOMUXC_SAI2_RXC_UART1_DTE_TX                                     0x1B4 0x41C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI2_RXC_GPIO4_IO22                                       0x1B4 0x41C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_RXC_PDM_BIT_STREAM1                                  0x1B4 0x41C 0x538 0x6 0x8
+#define MX8MN_IOMUXC_SAI2_RXD0_SAI2_RX_DATA0                                   0x1B8 0x420 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_RXD0_SAI5_TX_DATA0                                   0x1B8 0x420 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI2_RXD0_SAI2_TX_DATA1                                   0x1B8 0x420 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI2_RXD0_UART1_DCE_RTS_B                                 0x1B8 0x420 0x4F0 0x4 0x2
+#define MX8MN_IOMUXC_SAI2_RXD0_UART1_DTE_CTS_B                                 0x1B8 0x420 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI2_RXD0_GPIO4_IO23                                      0x1B8 0x420 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_RXD0_PDM_BIT_STREAM3                                 0x1B8 0x420 0x540 0x6 0x7
+#define MX8MN_IOMUXC_SAI2_TXFS_SAI2_TX_SYNC                                    0x1BC 0x424 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_TXFS_SAI5_TX_DATA1                                   0x1BC 0x424 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI2_TXFS_SAI2_TX_DATA1                                   0x1BC 0x424 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI2_TXFS_UART1_DCE_CTS_B                                 0x1BC 0x424 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI2_TXFS_UART1_DTE_RTS_B                                 0x1BC 0x424 0x4F0 0x4 0x3
+#define MX8MN_IOMUXC_SAI2_TXFS_GPIO4_IO24                                      0x1BC 0x424 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_TXFS_PDM_BIT_STREAM2                                 0x1BC 0x424 0x53C 0x6 0x8
+#define MX8MN_IOMUXC_SAI2_TXC_SAI2_TX_BCLK                                     0x1C0 0x428 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_TXC_SAI5_TX_DATA2                                    0x1C0 0x428 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI2_TXC_GPIO4_IO25                                       0x1C0 0x428 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_TXC_PDM_BIT_STREAM1                                  0x1C0 0x428 0x538 0x6 0x9
+#define MX8MN_IOMUXC_SAI2_TXD0_SAI2_TX_DATA0                                   0x1C4 0x42C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_TXD0_SAI5_TX_DATA3                                   0x1C4 0x42C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI2_TXD0_GPIO4_IO26                                      0x1C4 0x42C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_TXD0_CCMSRCGPCMIX_BOOT_MODE4                         0x1C4 0x42C 0x540 0x6 0x8
+#define MX8MN_IOMUXC_SAI2_MCLK_SAI2_MCLK                                       0x1C8 0x430 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI2_MCLK_SAI5_MCLK                                       0x1C8 0x430 0x594 0x1 0x2
+#define MX8MN_IOMUXC_SAI2_MCLK_GPIO4_IO27                                      0x1C8 0x430 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI2_MCLK_SAI3_MCLK                                       0x1C8 0x430 0x5C0 0x6 0x1
+#define MX8MN_IOMUXC_SAI3_RXFS_SAI3_RX_SYNC                                    0x1CC 0x434 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_RXFS_GPT1_CAPTURE1                                   0x1CC 0x434 0x5F0 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_RXFS_SAI5_RX_SYNC                                    0x1CC 0x434 0x4E4 0x2 0x2
+#define MX8MN_IOMUXC_SAI3_RXFS_SAI3_RX_DATA1                                   0x1CC 0x434 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI3_RXFS_SPDIF1_IN                                       0x1CC 0x434 0x5CC 0x4 0x3
+#define MX8MN_IOMUXC_SAI3_RXFS_GPIO4_IO28                                      0x1CC 0x434 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_RXFS_PDM_BIT_STREAM0                                 0x1CC 0x434 0x534 0x6 0x5
+#define MX8MN_IOMUXC_SAI3_RXC_SAI3_RX_BCLK                                     0x1D0 0x438 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_RXC_GPT1_CLK                                         0x1D0 0x438 0x5E8 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_RXC_SAI5_RX_BCLK                                     0x1D0 0x438 0x4D0 0x2 0x2
+#define MX8MN_IOMUXC_SAI3_RXC_SAI2_RX_DATA1                                    0x1D0 0x438 0x5AC 0x3 0x2
+#define MX8MN_IOMUXC_SAI3_RXC_UART2_DCE_CTS_B                                  0x1D0 0x438 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI3_RXC_UART2_DTE_RTS_B                                  0x1D0 0x438 0x4F8 0x4 0x2
+#define MX8MN_IOMUXC_SAI3_RXC_GPIO4_IO29                                       0x1D0 0x438 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_RXC_PDM_CLK                                          0x1D0 0x438 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_SAI3_RX_DATA0                                    0x1D4 0x43C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_GPT1_COMPARE1                                    0x1D4 0x43C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_SAI5_RX_DATA0                                    0x1D4 0x43C 0x4D4 0x2 0x2
+#define MX8MN_IOMUXC_SAI3_RXD_SAI3_TX_DATA1                                    0x1D4 0x43C 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_UART2_DCE_RTS_B                                  0x1D4 0x43C 0x4F8 0x4 0x3
+#define MX8MN_IOMUXC_SAI3_RXD_UART2_DTE_CTS_B                                  0x1D4 0x43C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_GPIO4_IO30                                       0x1D4 0x43C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_RXD_PDM_BIT_STREAM1                                  0x1D4 0x43C 0x538 0x6 0x10
+#define MX8MN_IOMUXC_SAI3_TXFS_SAI3_TX_SYNC                                    0x1D8 0x440 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_TXFS_GPT1_CAPTURE2                                   0x1D8 0x440 0x5EC 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_TXFS_SAI5_RX_DATA1                                   0x1D8 0x440 0x4D8 0x2 0x1
+#define MX8MN_IOMUXC_SAI3_TXFS_SAI3_TX_DATA1                                   0x1D8 0x440 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI3_TXFS_UART2_DCE_RX                                    0x1D8 0x440 0x4FC 0x4 0x2
+#define MX8MN_IOMUXC_SAI3_TXFS_UART2_DTE_TX                                    0x1D8 0x440 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI3_TXFS_GPIO4_IO31                                      0x1D8 0x440 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_TXFS_PDM_BIT_STREAM3                                 0x1D8 0x440 0x540 0x6 0x9
+#define MX8MN_IOMUXC_SAI3_TXC_SAI3_TX_BCLK                                     0x1DC 0x444 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_TXC_GPT1_COMPARE2                                    0x1DC 0x444 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_TXC_SAI5_RX_DATA2                                    0x1DC 0x444 0x4DC 0x2 0x1
+#define MX8MN_IOMUXC_SAI3_TXC_SAI2_TX_DATA1                                    0x1DC 0x444 0x000 0x3 0x0
+#define MX8MN_IOMUXC_SAI3_TXC_UART2_DCE_TX                                     0x1DC 0x444 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI3_TXC_UART2_DTE_RX                                     0x1DC 0x444 0x4FC 0x4 0x3
+#define MX8MN_IOMUXC_SAI3_TXC_GPIO5_IO0                                        0x1DC 0x444 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_TXC_PDM_BIT_STREAM2                                  0x1DC 0x444 0x53C 0x6 0x9
+#define MX8MN_IOMUXC_SAI3_TXD_SAI3_TX_DATA0                                    0x1E0 0x448 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_TXD_GPT1_COMPARE3                                    0x1E0 0x448 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_TXD_SAI5_RX_DATA3                                    0x1E0 0x448 0x4E0 0x2 0x1
+#define MX8MN_IOMUXC_SAI3_TXD_SPDIF1_EXT_CLK                                   0x1E0 0x448 0x568 0x4 0x2
+#define MX8MN_IOMUXC_SAI3_TXD_GPIO5_IO1                                        0x1E0 0x448 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_TXD_CCMSRCGPCMIX_BOOT_MODE5                          0x1E0 0x448 0x000 0x6 0x0
+#define MX8MN_IOMUXC_SAI3_MCLK_SAI3_MCLK                                       0x1E4 0x44C 0x5C0 0x0 0x0
+#define MX8MN_IOMUXC_SAI3_MCLK_PWM4_OUT                                        0x1E4 0x44C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SAI3_MCLK_SAI5_MCLK                                       0x1E4 0x44C 0x594 0x2 0x3
+#define MX8MN_IOMUXC_SAI3_MCLK_SPDIF1_OUT                                      0x1E4 0x44C 0x000 0x4 0x0
+#define MX8MN_IOMUXC_SAI3_MCLK_GPIO5_IO2                                       0x1E4 0x44C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SAI3_MCLK_SPDIF1_IN                                       0x1E4 0x44C 0x5CC 0x6 0x4
+#define MX8MN_IOMUXC_SPDIF_TX_SPDIF1_OUT                                       0x1E8 0x450 0x000 0x0 0x0
+#define MX8MN_IOMUXC_SPDIF_TX_PWM3_OUT                                         0x1E8 0x450 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SPDIF_TX_GPIO5_IO3                                        0x1E8 0x450 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SPDIF_RX_SPDIF1_IN                                        0x1EC 0x454 0x5CC 0x0 0x0
+#define MX8MN_IOMUXC_SPDIF_RX_PWM2_OUT                                         0x1EC 0x454 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SPDIF_RX_GPIO5_IO4                                        0x1EC 0x454 0x000 0x5 0x0
+#define MX8MN_IOMUXC_SPDIF_EXT_CLK_SPDIF1_EXT_CLK                              0x1F0 0x458 0x568 0x0 0x0
+#define MX8MN_IOMUXC_SPDIF_EXT_CLK_PWM1_OUT                                    0x1F0 0x458 0x000 0x1 0x0
+#define MX8MN_IOMUXC_SPDIF_EXT_CLK_GPIO5_IO5                                   0x1F0 0x458 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI1_SCLK_ECSPI1_SCLK                                   0x1F4 0x45C 0x5D8 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI1_SCLK_UART3_DCE_RX                                  0x1F4 0x45C 0x504 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_SCLK_UART3_DTE_TX                                  0x1F4 0x45C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_SCLK_I2C1_SCL                                      0x1F4 0x45C 0x55C 0x2 0x2
+#define MX8MN_IOMUXC_ECSPI1_SCLK_SAI5_RX_SYNC                                  0x1F4 0x45C 0x4DC 0x3 0x2
+#define MX8MN_IOMUXC_ECSPI1_SCLK_GPIO5_IO6                                     0x1F4 0x45C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI1_MOSI_ECSPI1_MOSI                                   0x1F8 0x460 0x5A8 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI1_MOSI_UART3_DCE_TX                                  0x1F8 0x460 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_MOSI_UART3_DTE_RX                                  0x1F8 0x460 0x504 0x1 0x1
+#define MX8MN_IOMUXC_ECSPI1_MOSI_I2C1_SDA                                      0x1F8 0x460 0x56C 0x2 0x2
+#define MX8MN_IOMUXC_ECSPI1_MOSI_SAI5_RX_BCLK                                  0x1F8 0x460 0x4D0 0x3 0x3
+#define MX8MN_IOMUXC_ECSPI1_MOSI_GPIO5_IO7                                     0x1F8 0x460 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI1_MISO_ECSPI1_MISO                                   0x1FC 0x464 0x5C4 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI1_MISO_UART3_DCE_CTS_B                               0x1FC 0x464 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_MISO_UART3_DTE_RTS_B                               0x1FC 0x464 0x500 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_MISO_I2C2_SCL                                      0x1FC 0x464 0x5D0 0x2 0x2
+#define MX8MN_IOMUXC_ECSPI1_MISO_SAI5_RX_DATA0                                 0x1FC 0x464 0x4D4 0x3 0x3
+#define MX8MN_IOMUXC_ECSPI1_MISO_GPIO5_IO8                                     0x1FC 0x464 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI1_SS0_ECSPI1_SS0                                     0x200 0x468 0x564 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI1_SS0_UART3_DCE_RTS_B                                0x200 0x468 0x500 0x1 0x1
+#define MX8MN_IOMUXC_ECSPI1_SS0_UART3_DTE_CTS_B                                0x200 0x468 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI1_SS0_I2C2_SDA                                       0x200 0x468 0x560 0x2 0x2
+#define MX8MN_IOMUXC_ECSPI1_SS0_SAI5_RX_DATA1                                  0x200 0x468 0x4D8 0x3 0x2
+#define MX8MN_IOMUXC_ECSPI1_SS0_SAI5_TX_SYNC                                   0x200 0x468 0x4EC 0x4 0x3
+#define MX8MN_IOMUXC_ECSPI1_SS0_GPIO5_IO9                                      0x200 0x468 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI2_SCLK_ECSPI2_SCLK                                   0x204 0x46C 0x580 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI2_SCLK_UART4_DCE_RX                                  0x204 0x46C 0x50C 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_SCLK_UART4_DTE_TX                                  0x204 0x46C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_SCLK_I2C3_SCL                                      0x204 0x46C 0x588 0x2 0x4
+#define MX8MN_IOMUXC_ECSPI2_SCLK_SAI5_RX_DATA2                                 0x204 0x46C 0x000 0x3 0x0
+#define MX8MN_IOMUXC_ECSPI2_SCLK_SAI5_TX_BCLK                                  0x204 0x46C 0x4E8 0x4 0x3
+#define MX8MN_IOMUXC_ECSPI2_SCLK_GPIO5_IO10                                    0x204 0x46C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI2_MOSI_ECSPI2_MOSI                                   0x208 0x470 0x590 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI2_MOSI_UART4_DCE_TX                                  0x208 0x470 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_MOSI_UART4_DTE_RX                                  0x208 0x470 0x50C 0x1 0x1
+#define MX8MN_IOMUXC_ECSPI2_MOSI_I2C3_SDA                                      0x208 0x470 0x5BC 0x2 0x4
+#define MX8MN_IOMUXC_ECSPI2_MOSI_SAI5_RX_DATA3                                 0x208 0x470 0x4E0 0x3 0x2
+#define MX8MN_IOMUXC_ECSPI2_MOSI_SAI5_TX_DATA0                                 0x208 0x470 0x000 0x4 0x0
+#define MX8MN_IOMUXC_ECSPI2_MOSI_GPIO5_IO11                                    0x208 0x470 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI2_MISO_ECSPI2_MISO                                   0x20C 0x474 0x578 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI2_MISO_UART4_DCE_CTS_B                               0x20C 0x474 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_MISO_UART4_DTE_RTS_B                               0x20C 0x474 0x508 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_MISO_I2C4_SCL                                      0x20C 0x474 0x5D4 0x2 0x3
+#define MX8MN_IOMUXC_ECSPI2_MISO_SAI5_MCLK                                     0x20C 0x474 0x594 0x3 0x4
+#define MX8MN_IOMUXC_ECSPI2_MISO_GPIO5_IO12                                    0x20C 0x474 0x000 0x5 0x0
+#define MX8MN_IOMUXC_ECSPI2_SS0_ECSPI2_SS0                                     0x210 0x478 0x570 0x0 0x0
+#define MX8MN_IOMUXC_ECSPI2_SS0_UART4_DCE_RTS_B                                0x210 0x478 0x508 0x1 0x1
+#define MX8MN_IOMUXC_ECSPI2_SS0_UART4_DTE_CTS_B                                0x210 0x478 0x000 0x1 0x0
+#define MX8MN_IOMUXC_ECSPI2_SS0_I2C4_SDA                                       0x210 0x478 0x58C 0x2 0x5
+#define MX8MN_IOMUXC_ECSPI2_SS0_GPIO5_IO13                                     0x210 0x478 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C1_SCL_I2C1_SCL                                         0x214 0x47C 0x55C 0x0 0x0
+#define MX8MN_IOMUXC_I2C1_SCL_ENET1_MDC                                        0x214 0x47C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C1_SCL_ECSPI1_SCLK                                      0x214 0x47C 0x5D8 0x3 0x1
+#define MX8MN_IOMUXC_I2C1_SCL_GPIO5_IO14                                       0x214 0x47C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C1_SDA_I2C1_SDA                                         0x218 0x480 0x56C 0x0 0x0
+#define MX8MN_IOMUXC_I2C1_SDA_ENET1_MDIO                                       0x218 0x480 0x4C0 0x1 0x2
+#define MX8MN_IOMUXC_I2C1_SDA_ECSPI1_MOSI                                      0x218 0x480 0x5A8 0x3 0x1
+#define MX8MN_IOMUXC_I2C1_SDA_GPIO5_IO15                                       0x218 0x480 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C2_SCL_I2C2_SCL                                         0x21C 0x484 0x5D0 0x0 0x0
+#define MX8MN_IOMUXC_I2C2_SCL_ENET1_1588_EVENT1_IN                             0x21C 0x484 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C2_SCL_USDHC3_CD_B                                      0x21C 0x484 0x598 0x2 0x1
+#define MX8MN_IOMUXC_I2C2_SCL_ECSPI1_MISO                                      0x21C 0x484 0x5C4 0x3 0x1
+#define MX8MN_IOMUXC_I2C2_SCL_GPIO5_IO16                                       0x21C 0x484 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C2_SDA_I2C2_SDA                                         0x220 0x488 0x560 0x0 0x0
+#define MX8MN_IOMUXC_I2C2_SDA_ENET1_1588_EVENT1_OUT                            0x220 0x488 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C2_SDA_USDHC3_WP                                        0x220 0x488 0x5B8 0x2 0x1
+#define MX8MN_IOMUXC_I2C2_SDA_ECSPI1_SS0                                       0x220 0x488 0x564 0x3 0x1
+#define MX8MN_IOMUXC_I2C2_SDA_GPIO5_IO17                                       0x220 0x488 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C3_SCL_I2C3_SCL                                         0x224 0x48C 0x588 0x0 0x0
+#define MX8MN_IOMUXC_I2C3_SCL_PWM4_OUT                                         0x224 0x48C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C3_SCL_GPT2_CLK                                         0x224 0x48C 0x000 0x2 0x0
+#define MX8MN_IOMUXC_I2C3_SCL_ECSPI2_SCLK                                      0x224 0x48C 0x580 0x3 0x2
+#define MX8MN_IOMUXC_I2C3_SCL_GPIO5_IO18                                       0x224 0x48C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C3_SDA_I2C3_SDA                                         0x228 0x490 0x5BC 0x0 0x0
+#define MX8MN_IOMUXC_I2C3_SDA_PWM3_OUT                                         0x228 0x490 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C3_SDA_GPT3_CLK                                         0x228 0x490 0x000 0x2 0x0
+#define MX8MN_IOMUXC_I2C3_SDA_ECSPI2_MOSI                                      0x228 0x490 0x590 0x3 0x2
+#define MX8MN_IOMUXC_I2C3_SDA_GPIO5_IO19                                       0x228 0x490 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C4_SCL_I2C4_SCL                                         0x22C 0x494 0x5D4 0x0 0x0
+#define MX8MN_IOMUXC_I2C4_SCL_PWM2_OUT                                         0x22C 0x494 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C4_SCL_ECSPI2_MISO                                      0x22C 0x494 0x578 0x3 0x2
+#define MX8MN_IOMUXC_I2C4_SCL_GPIO5_IO20                                       0x22C 0x494 0x000 0x5 0x0
+#define MX8MN_IOMUXC_I2C4_SDA_I2C4_SDA                                         0x230 0x498 0x58C 0x0 0x0
+#define MX8MN_IOMUXC_I2C4_SDA_PWM1_OUT                                         0x230 0x498 0x000 0x1 0x0
+#define MX8MN_IOMUXC_I2C4_SDA_ECSPI2_SS0                                       0x230 0x498 0x570 0x3 0x1
+#define MX8MN_IOMUXC_I2C4_SDA_GPIO5_IO21                                       0x230 0x498 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART1_RXD_UART1_DCE_RX                                    0x234 0x49C 0x4F4 0x0 0x0
+#define MX8MN_IOMUXC_UART1_RXD_UART1_DTE_TX                                    0x234 0x49C 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART1_RXD_ECSPI3_SCLK                                     0x234 0x49C 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART1_RXD_GPIO5_IO22                                      0x234 0x49C 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART1_TXD_UART1_DCE_TX                                    0x238 0x4A0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART1_TXD_UART1_DTE_RX                                    0x238 0x4A0 0x4F4 0x0 0x1
+#define MX8MN_IOMUXC_UART1_TXD_ECSPI3_MOSI                                     0x238 0x4A0 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART1_TXD_GPIO5_IO23                                      0x238 0x4A0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART2_RXD_UART2_DCE_RX                                    0x23C 0x4A4 0x4FC 0x0 0x0
+#define MX8MN_IOMUXC_UART2_RXD_UART2_DTE_TX                                    0x23C 0x4A4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART2_RXD_ECSPI3_MISO                                     0x23C 0x4A4 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART2_RXD_GPT1_COMPARE3                                   0x23C 0x4A4 0x000 0x3 0x0
+#define MX8MN_IOMUXC_UART2_RXD_GPIO5_IO24                                      0x23C 0x4A4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART2_TXD_UART2_DCE_TX                                    0x240 0x4A8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART2_TXD_UART2_DTE_RX                                    0x240 0x4A8 0x4FC 0x0 0x1
+#define MX8MN_IOMUXC_UART2_TXD_ECSPI3_SS0                                      0x240 0x4A8 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART2_TXD_GPT1_COMPARE2                                   0x240 0x4A8 0x000 0x3 0x0
+#define MX8MN_IOMUXC_UART2_TXD_GPIO5_IO25                                      0x240 0x4A8 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART3_RXD_UART3_DCE_RX                                    0x244 0x4AC 0x504 0x0 0x2
+#define MX8MN_IOMUXC_UART3_RXD_UART3_DTE_TX                                    0x244 0x4AC 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART3_RXD_UART1_DCE_CTS_B                                 0x244 0x4AC 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART3_RXD_UART1_DTE_RTS_B                                 0x244 0x4AC 0x4F0 0x1 0x0
+#define MX8MN_IOMUXC_UART3_RXD_USDHC3_RESET_B                                  0x244 0x4AC 0x000 0x2 0x0
+#define MX8MN_IOMUXC_UART3_RXD_GPT1_CAPTURE2                                   0x244 0x4AC 0x5EC 0x3 0x1
+#define MX8MN_IOMUXC_UART3_RXD_GPIO5_IO26                                      0x244 0x4AC 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART3_TXD_UART3_DCE_TX                                    0x248 0x4B0 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART3_TXD_UART3_DTE_RX                                    0x248 0x4B0 0x504 0x0 0x3
+#define MX8MN_IOMUXC_UART3_TXD_UART1_DCE_RTS_B                                 0x248 0x4B0 0x4F0 0x1 0x1
+#define MX8MN_IOMUXC_UART3_TXD_UART1_DTE_CTS_B                                 0x248 0x4B0 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART3_TXD_USDHC3_VSELECT                                  0x248 0x4B0 0x000 0x2 0x0
+#define MX8MN_IOMUXC_UART3_TXD_GPT1_CLK                                        0x248 0x4B0 0x5E8 0x3 0x1
+#define MX8MN_IOMUXC_UART3_TXD_GPIO5_IO27                                      0x248 0x4B0 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART4_RXD_UART4_DCE_RX                                    0x24C 0x4B4 0x50C 0x0 0x2
+#define MX8MN_IOMUXC_UART4_RXD_UART4_DTE_TX                                    0x24C 0x4B4 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART4_RXD_UART2_DCE_CTS_B                                 0x24C 0x4B4 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART4_RXD_UART2_DTE_RTS_B                                 0x24C 0x4B4 0x4F8 0x1 0x0
+#define MX8MN_IOMUXC_UART4_RXD_GPT1_COMPARE1                                   0x24C 0x4B4 0x000 0x3 0x0
+#define MX8MN_IOMUXC_UART4_RXD_GPIO5_IO28                                      0x24C 0x4B4 0x000 0x5 0x0
+#define MX8MN_IOMUXC_UART4_TXD_UART4_DCE_TX                                    0x250 0x4B8 0x000 0x0 0x0
+#define MX8MN_IOMUXC_UART4_TXD_UART4_DTE_RX                                    0x250 0x4B8 0x50C 0x0 0x3
+#define MX8MN_IOMUXC_UART4_TXD_UART2_DCE_RTS_B                                 0x250 0x4B8 0x4F8 0x1 0x1
+#define MX8MN_IOMUXC_UART4_TXD_UART2_DTE_CTS_B                                 0x250 0x4B8 0x000 0x1 0x0
+#define MX8MN_IOMUXC_UART4_TXD_GPT1_CAPTURE1                                   0x250 0x4B8 0x5F0 0x3 0x1
+#define MX8MN_IOMUXC_UART4_TXD_GPIO5_IO29                                      0x250 0x4B8 0x000 0x5 0x0
+
+#endif /* __DTS_IMX8MN_PINFUNC_H */
diff --git a/drivers/pinctrl/aspeed/Makefile b/drivers/pinctrl/aspeed/Makefile
index 068729bf4f86..ea8962645e49 100644
--- a/drivers/pinctrl/aspeed/Makefile
+++ b/drivers/pinctrl/aspeed/Makefile
@@ -2,6 +2,6 @@
 # Aspeed pinctrl support
 
 ccflags-y += $(call cc-option,-Woverride-init)
-obj-$(CONFIG_PINCTRL_ASPEED)    += pinctrl-aspeed.o
+obj-$(CONFIG_PINCTRL_ASPEED)    += pinctrl-aspeed.o pinmux-aspeed.o
 obj-$(CONFIG_PINCTRL_ASPEED_G4) += pinctrl-aspeed-g4.o
 obj-$(CONFIG_PINCTRL_ASPEED_G5) += pinctrl-aspeed-g5.o
diff --git a/drivers/pinctrl/aspeed/pinctrl-aspeed-g4.c b/drivers/pinctrl/aspeed/pinctrl-aspeed-g4.c
index 73e2c9c0e549..384396cbb22d 100644
--- a/drivers/pinctrl/aspeed/pinctrl-aspeed-g4.c
+++ b/drivers/pinctrl/aspeed/pinctrl-aspeed-g4.c
@@ -18,9 +18,35 @@
 
 #include "../core.h"
 #include "../pinctrl-utils.h"
+#include "pinmux-aspeed.h"
 #include "pinctrl-aspeed.h"
 
 /*
+ * The "Multi-function Pins Mapping and Control" table in the SoC datasheet
+ * references registers by the device/offset mnemonic. The register macros
+ * below are named the same way to ease transcription and verification (as
+ * opposed to naming them e.g. PINMUX_CTRL_[0-9]). Further, signal expressions
+ * reference registers beyond those dedicated to pinmux, such as the system
+ * reset control and MAC clock configuration registers.
+ */
+#define SCU2C           0x2C /* Misc. Control Register */
+#define SCU3C           0x3C /* System Reset Control/Status Register */
+#define SCU48           0x48 /* MAC Interface Clock Delay Setting */
+#define HW_STRAP1       0x70 /* AST2400 strapping is 33 bits, is split */
+#define HW_REVISION_ID  0x7C /* Silicon revision ID register */
+#define SCU80           0x80 /* Multi-function Pin Control #1 */
+#define SCU84           0x84 /* Multi-function Pin Control #2 */
+#define SCU88           0x88 /* Multi-function Pin Control #3 */
+#define SCU8C           0x8C /* Multi-function Pin Control #4 */
+#define SCU90           0x90 /* Multi-function Pin Control #5 */
+#define SCU94           0x94 /* Multi-function Pin Control #6 */
+#define SCUA0           0xA0 /* Multi-function Pin Control #7 */
+#define SCUA4           0xA4 /* Multi-function Pin Control #8 */
+#define SCUA8           0xA8 /* Multi-function Pin Control #9 */
+#define SCUAC           0xAC /* Multi-function Pin Control #10 */
+#define HW_STRAP2       0xD0 /* Strapping */
+
+/*
  * Uses undefined macros for symbol naming and references, eg GPIOA0, MAC1LINK,
  * TIMER3 etc.
  *
@@ -2386,13 +2412,73 @@ static const struct aspeed_pin_config aspeed_g4_configs[] = {
         { PIN_CONFIG_INPUT_DEBOUNCE, { C14, B14 }, SCUA8, 27 },
 };
 
+static int aspeed_g4_sig_expr_set(const struct aspeed_pinmux_data *ctx,
+                                  const struct aspeed_sig_expr *expr,
+                                  bool enable)
+{
+        int ret;
+        int i;
+
+        for (i = 0; i < expr->ndescs; i++) {
+                const struct aspeed_sig_desc *desc = &expr->descs[i];
+                u32 pattern = enable ? desc->enable : desc->disable;
+                u32 val = (pattern << __ffs(desc->mask));
+
+                if (!ctx->maps[desc->ip])
+                        return -ENODEV;
+
+                /*
+                 * Strap registers are configured in hardware or by early-boot
+                 * firmware. Treat them as read-only despite that we can write
+                 * them. This may mean that certain functions cannot be
+                 * deconfigured and is the reason we re-evaluate after writing
+                 * all descriptor bits.
+                 *
+                 * Port D and port E GPIO loopback modes are the only exception
+                 * as those are commonly used with front-panel buttons to allow
+                 * normal operation of the host when the BMC is powered off or
+                 * fails to boot. Once the BMC has booted, the loopback mode
+                 * must be disabled for the BMC to control host power-on and
+                 * reset.
+                 */
+                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1 &&
+                    !(desc->mask & (BIT(21) | BIT(22))))
+                        continue;
+
+                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP2)
+                        continue;
+
+                ret = regmap_update_bits(ctx->maps[desc->ip], desc->reg,
+                                         desc->mask, val);
+
+                if (ret)
+                        return ret;
+        }
+
+        ret = aspeed_sig_expr_eval(ctx, expr, enable);
+        if (ret < 0)
+                return ret;
+
+        if (!ret)
+                return -EPERM;
+
+        return 0;
+}
+
+static const struct aspeed_pinmux_ops aspeed_g4_ops = {
+        .set = aspeed_g4_sig_expr_set,
+};
+
 static struct aspeed_pinctrl_data aspeed_g4_pinctrl_data = {
         .pins = aspeed_g4_pins,
         .npins = ARRAY_SIZE(aspeed_g4_pins),
-        .groups = aspeed_g4_groups,
-        .ngroups = ARRAY_SIZE(aspeed_g4_groups),
-        .functions = aspeed_g4_functions,
-        .nfunctions = ARRAY_SIZE(aspeed_g4_functions),
+        .pinmux = {
+                .ops = &aspeed_g4_ops,
+                .groups = aspeed_g4_groups,
+                .ngroups = ARRAY_SIZE(aspeed_g4_groups),
+                .functions = aspeed_g4_functions,
+                .nfunctions = ARRAY_SIZE(aspeed_g4_functions),
+        },
         .configs = aspeed_g4_configs,
         .nconfigs = ARRAY_SIZE(aspeed_g4_configs),
 };
diff --git a/drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c b/drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c
index aa7e148b38bb..053101f795a2 100644
--- a/drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c
+++ b/drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c
@@ -21,6 +21,32 @@
 #include "../pinctrl-utils.h"
 #include "pinctrl-aspeed.h"
 
+/*
+ * The "Multi-function Pins Mapping and Control" table in the SoC datasheet
+ * references registers by the device/offset mnemonic. The register macros
+ * below are named the same way to ease transcription and verification (as
+ * opposed to naming them e.g. PINMUX_CTRL_[0-9]). Further, signal expressions
+ * reference registers beyond those dedicated to pinmux, such as the system
+ * reset control and MAC clock configuration registers. The AST2500 goes a step
+ * further and references registers in the graphics IP block.
+ */
+#define SCU2C           0x2C /* Misc. Control Register */
+#define SCU3C           0x3C /* System Reset Control/Status Register */
+#define SCU48           0x48 /* MAC Interface Clock Delay Setting */
+#define HW_STRAP1       0x70 /* AST2400 strapping is 33 bits, is split */
+#define HW_REVISION_ID  0x7C /* Silicon revision ID register */
+#define SCU80           0x80 /* Multi-function Pin Control #1 */
+#define SCU84           0x84 /* Multi-function Pin Control #2 */
+#define SCU88           0x88 /* Multi-function Pin Control #3 */
+#define SCU8C           0x8C /* Multi-function Pin Control #4 */
+#define SCU90           0x90 /* Multi-function Pin Control #5 */
+#define SCU94           0x94 /* Multi-function Pin Control #6 */
+#define SCUA0           0xA0 /* Multi-function Pin Control #7 */
+#define SCUA4           0xA4 /* Multi-function Pin Control #8 */
+#define SCUA8           0xA8 /* Multi-function Pin Control #9 */
+#define SCUAC           0xAC /* Multi-function Pin Control #10 */
+#define HW_STRAP2       0xD0 /* Strapping */
+
 #define ASPEED_G5_NR_PINS 236
 
 #define COND1           { ASPEED_IP_SCU, SCU90, BIT(6), 0, 0 }
@@ -573,6 +599,8 @@ SS_PIN_DECL(N3, GPIOJ2, SGPMO);
 SIG_EXPR_LIST_DECL_SINGLE(SGPMI, SGPM, SIG_DESC_SET(SCU84, 11));
 SS_PIN_DECL(N4, GPIOJ3, SGPMI);
 
+FUNC_GROUP_DECL(SGPM, R2, L2, N3, N4);
+
 #define N5 76
 SIG_EXPR_LIST_DECL_SINGLE(VGAHS, VGAHS, SIG_DESC_SET(SCU84, 12));
 SIG_EXPR_LIST_DECL_SINGLE(DASHN5, DASHN5, SIG_DESC_SET(SCU94, 8));
@@ -2123,6 +2151,7 @@ static const struct aspeed_pin_group aspeed_g5_groups[] = {
         ASPEED_PINCTRL_GROUP(SD2),
         ASPEED_PINCTRL_GROUP(SDA1),
         ASPEED_PINCTRL_GROUP(SDA2),
+        ASPEED_PINCTRL_GROUP(SGPM),
         ASPEED_PINCTRL_GROUP(SGPS1),
         ASPEED_PINCTRL_GROUP(SGPS2),
         ASPEED_PINCTRL_GROUP(SIOONCTRL),
@@ -2292,6 +2321,7 @@ static const struct aspeed_pin_function aspeed_g5_functions[] = {
         ASPEED_PINCTRL_FUNC(SD2),
         ASPEED_PINCTRL_FUNC(SDA1),
         ASPEED_PINCTRL_FUNC(SDA2),
+        ASPEED_PINCTRL_FUNC(SGPM),
         ASPEED_PINCTRL_FUNC(SGPS1),
         ASPEED_PINCTRL_FUNC(SGPS2),
         ASPEED_PINCTRL_FUNC(SIOONCTRL),
@@ -2477,13 +2507,98 @@ static struct aspeed_pin_config aspeed_g5_configs[] = {
         { PIN_CONFIG_INPUT_DEBOUNCE, { A20, B19 }, SCUA8, 27 },
 };
 
+/**
+ * Configure a pin's signal by applying an expression's descriptor state for
+ * all descriptors in the expression.
+ *
+ * @ctx: The pinmux context
+ * @expr: The expression associated with the function whose signal is to be
+ *        configured
+ * @enable: true to enable an function's signal through a pin's signal
+ *          expression, false to disable the function's signal
+ *
+ * Return: 0 if the expression is configured as requested and a negative error
+ * code otherwise
+ */
+static int aspeed_g5_sig_expr_set(const struct aspeed_pinmux_data *ctx,
+                                  const struct aspeed_sig_expr *expr,
+                                  bool enable)
+{
+        int ret;
+        int i;
+
+        for (i = 0; i < expr->ndescs; i++) {
+                const struct aspeed_sig_desc *desc = &expr->descs[i];
+                u32 pattern = enable ? desc->enable : desc->disable;
+                u32 val = (pattern << __ffs(desc->mask));
+
+                if (!ctx->maps[desc->ip])
+                        return -ENODEV;
+
+                /*
+                 * Strap registers are configured in hardware or by early-boot
+                 * firmware. Treat them as read-only despite that we can write
+                 * them. This may mean that certain functions cannot be
+                 * deconfigured and is the reason we re-evaluate after writing
+                 * all descriptor bits.
+                 *
+                 * Port D and port E GPIO loopback modes are the only exception
+                 * as those are commonly used with front-panel buttons to allow
+                 * normal operation of the host when the BMC is powered off or
+                 * fails to boot. Once the BMC has booted, the loopback mode
+                 * must be disabled for the BMC to control host power-on and
+                 * reset.
+                 */
+                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1 &&
+                    !(desc->mask & (BIT(21) | BIT(22))))
+                        continue;
+
+                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP2)
+                        continue;
+
+                /* On AST2500, Set bits in SCU70 are cleared from SCU7C */
+                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1) {
+                        u32 value = ~val & desc->mask;
+
+                        if (value) {
+                                ret = regmap_write(ctx->maps[desc->ip],
+                                                   HW_REVISION_ID, value);
+                                if (ret < 0)
+                                        return ret;
+                        }
+                }
+
+                ret = regmap_update_bits(ctx->maps[desc->ip], desc->reg,
+                                         desc->mask, val);
+
+                if (ret)
+                        return ret;
+        }
+
+        ret = aspeed_sig_expr_eval(ctx, expr, enable);
+        if (ret < 0)
+                return ret;
+
+        if (!ret)
+                return -EPERM;
+
+        return 0;
+}
+
+static const struct aspeed_pinmux_ops aspeed_g5_ops = {
+        .set = aspeed_g5_sig_expr_set,
+};
+
 static struct aspeed_pinctrl_data aspeed_g5_pinctrl_data = {
         .pins = aspeed_g5_pins,
         .npins = ARRAY_SIZE(aspeed_g5_pins),
-        .groups = aspeed_g5_groups,
-        .ngroups = ARRAY_SIZE(aspeed_g5_groups),
-        .functions = aspeed_g5_functions,
-        .nfunctions = ARRAY_SIZE(aspeed_g5_functions),
+        .pinmux = {
+                .ops = &aspeed_g5_ops,
+                .groups = aspeed_g5_groups,
+                .ngroups = ARRAY_SIZE(aspeed_g5_groups),
+                .functions = aspeed_g5_functions,
+                .nfunctions = ARRAY_SIZE(aspeed_g5_functions),
+        },
         .configs = aspeed_g5_configs,
         .nconfigs = ARRAY_SIZE(aspeed_g5_configs),
 };
@@ -2539,7 +2654,7 @@ static int aspeed_g5_pinctrl_probe(struct platform_device *pdev)
                 dev_warn(&pdev->dev, "No GFX phandle found, some mux configurations may fail\n");
                 map = NULL;
         }
-        aspeed_g5_pinctrl_data.maps[ASPEED_IP_GFX] = map;
+        aspeed_g5_pinctrl_data.pinmux.maps[ASPEED_IP_GFX] = map;
 
         node = of_parse_phandle(pdev->dev.of_node, "aspeed,external-nodes", 1);
         if (node) {
@@ -2553,7 +2668,7 @@ static int aspeed_g5_pinctrl_probe(struct platform_device *pdev)
                 map = NULL;
         }
         of_node_put(node);
-        aspeed_g5_pinctrl_data.maps[ASPEED_IP_LPC] = map;
+        aspeed_g5_pinctrl_data.pinmux.maps[ASPEED_IP_LPC] = map;
 
         return aspeed_pinctrl_probe(pdev, &aspeed_g5_pinctrl_desc,
                         &aspeed_g5_pinctrl_data);
diff --git a/drivers/pinctrl/aspeed/pinctrl-aspeed.c b/drivers/pinctrl/aspeed/pinctrl-aspeed.c
index 4c775b8ffdc4..535db3de490b 100644
--- a/drivers/pinctrl/aspeed/pinctrl-aspeed.c
+++ b/drivers/pinctrl/aspeed/pinctrl-aspeed.c
@@ -10,17 +10,11 @@
 #include "../core.h"
 #include "pinctrl-aspeed.h"
 
-static const char *const aspeed_pinmux_ips[] = {
-        [ASPEED_IP_SCU] = "SCU",
-        [ASPEED_IP_GFX] = "GFX",
-        [ASPEED_IP_LPC] = "LPC",
-};
-
 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        return pdata->ngroups;
+        return pdata->pinmux.ngroups;
 }
 
 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
@@ -28,7 +22,7 @@ const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        return pdata->groups[group].name;
+        return pdata->pinmux.groups[group].name;
 }
 
 int aspeed_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
@@ -37,8 +31,8 @@ int aspeed_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        *pins = &pdata->groups[group].pins[0];
-        *npins = pdata->groups[group].npins;
+        *pins = &pdata->pinmux.groups[group].pins[0];
+        *npins = pdata->pinmux.groups[group].npins;
 
         return 0;
 }
@@ -53,7 +47,7 @@ int aspeed_pinmux_get_fn_count(struct pinctrl_dev *pctldev)
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        return pdata->nfunctions;
+        return pdata->pinmux.nfunctions;
 }
 
 const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev *pctldev,
@@ -61,7 +55,7 @@ const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev *pctldev,
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        return pdata->functions[function].name;
+        return pdata->pinmux.functions[function].name;
 }
 
 int aspeed_pinmux_get_fn_groups(struct pinctrl_dev *pctldev,
@@ -71,208 +65,38 @@ int aspeed_pinmux_get_fn_groups(struct pinctrl_dev *pctldev,
 {
         struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 
-        *groups = pdata->functions[function].groups;
-        *num_groups = pdata->functions[function].ngroups;
+        *groups = pdata->pinmux.functions[function].groups;
+        *num_groups = pdata->pinmux.functions[function].ngroups;
 
         return 0;
 }
 
-static inline void aspeed_sig_desc_print_val(
-                const struct aspeed_sig_desc *desc, bool enable, u32 rv)
-{
-        pr_debug("Want %s%X[0x%08X]=0x%X, got 0x%X from 0x%08X\n",
-                        aspeed_pinmux_ips[desc->ip], desc->reg,
-                        desc->mask, enable ? desc->enable : desc->disable,
-                        (rv & desc->mask) >> __ffs(desc->mask), rv);
-}
-
-/**
- * Query the enabled or disabled state of a signal descriptor
- *
- * @desc: The signal descriptor of interest
- * @enabled: True to query the enabled state, false to query disabled state
- * @map: The IP block's regmap instance
- *
- * Return: 1 if the descriptor's bitfield is configured to the state
- * selected by @enabled, 0 if not, and less than zero if an unrecoverable
- * failure occurred
- *
- * Evaluation of descriptor state is non-trivial in that it is not a binary
- * outcome: The bitfields can be greater than one bit in size and thus can take
- * a value that is neither the enabled nor disabled state recorded in the
- * descriptor (typically this means a different function to the one of interest
- * is enabled). Thus we must explicitly test for either condition as required.
- */
-static int aspeed_sig_desc_eval(const struct aspeed_sig_desc *desc,
-                                 bool enabled, struct regmap *map)
+static int aspeed_sig_expr_enable(const struct aspeed_pinmux_data *ctx,
+                                  const struct aspeed_sig_expr *expr)
 {
         int ret;
-        unsigned int raw;
-        u32 want;
 
-        if (!map)
-                return -ENODEV;
-
-        ret = regmap_read(map, desc->reg, &raw);
-        if (ret)
-                return ret;
-
-        aspeed_sig_desc_print_val(desc, enabled, raw);
-        want = enabled ? desc->enable : desc->disable;
-
-        return ((raw & desc->mask) >> __ffs(desc->mask)) == want;
-}
-
-/**
- * Query the enabled or disabled state for a mux function's signal on a pin
- *
- * @expr: An expression controlling the signal for a mux function on a pin
- * @enabled: True to query the enabled state, false to query disabled state
- * @maps: The list of regmap instances
- *
- * Return: 1 if the expression composed by @enabled evaluates true, 0 if not,
- * and less than zero if an unrecoverable failure occurred.
- *
- * A mux function is enabled or disabled if the function's signal expression
- * for each pin in the function's pin group evaluates true for the desired
- * state. An signal expression evaluates true if all of its associated signal
- * descriptors evaluate true for the desired state.
- *
- * If an expression's state is described by more than one bit, either through
- * multi-bit bitfields in a single signal descriptor or through multiple signal
- * descriptors of a single bit then it is possible for the expression to be in
- * neither the enabled nor disabled state. Thus we must explicitly test for
- * either condition as required.
- */
-static int aspeed_sig_expr_eval(const struct aspeed_sig_expr *expr,
-                                 bool enabled, struct regmap * const *maps)
-{
-        int i;
-        int ret;
-
-        for (i = 0; i < expr->ndescs; i++) {
-                const struct aspeed_sig_desc *desc = &expr->descs[i];
-
-                ret = aspeed_sig_desc_eval(desc, enabled, maps[desc->ip]);
-                if (ret <= 0)
-                        return ret;
-        }
-
-        return 1;
-}
-
-/**
- * Configure a pin's signal by applying an expression's descriptor state for
- * all descriptors in the expression.
- *
- * @expr: The expression associated with the function whose signal is to be
- *        configured
- * @enable: true to enable an function's signal through a pin's signal
- *          expression, false to disable the function's signal
- * @maps: The list of regmap instances for pinmux register access.
- *
- * Return: 0 if the expression is configured as requested and a negative error
- * code otherwise
- */
-static int aspeed_sig_expr_set(const struct aspeed_sig_expr *expr,
-                                bool enable, struct regmap * const *maps)
-{
-        int ret;
-        int i;
-
-        for (i = 0; i < expr->ndescs; i++) {
-                const struct aspeed_sig_desc *desc = &expr->descs[i];
-                u32 pattern = enable ? desc->enable : desc->disable;
-                u32 val = (pattern << __ffs(desc->mask));
-
-                if (!maps[desc->ip])
-                        return -ENODEV;
-
-                /*
-                 * Strap registers are configured in hardware or by early-boot
-                 * firmware. Treat them as read-only despite that we can write
-                 * them. This may mean that certain functions cannot be
-                 * deconfigured and is the reason we re-evaluate after writing
-                 * all descriptor bits.
-                 *
-                 * Port D and port E GPIO loopback modes are the only exception
-                 * as those are commonly used with front-panel buttons to allow
-                 * normal operation of the host when the BMC is powered off or
-                 * fails to boot. Once the BMC has booted, the loopback mode
-                 * must be disabled for the BMC to control host power-on and
-                 * reset.
-                 */
-                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1 &&
-                    !(desc->mask & (BIT(21) | BIT(22))))
-                        continue;
-
-                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP2)
-                        continue;
-
-                /* On AST2500, Set bits in SCU7C are cleared from SCU70 */
-                if (desc->ip == ASPEED_IP_SCU && desc->reg == HW_STRAP1) {
-                        unsigned int rev_id;
-
-                        ret = regmap_read(maps[ASPEED_IP_SCU],
-                                HW_REVISION_ID, &rev_id);
-                        if (ret < 0)
-                                return ret;
-
-                        if (0x04 == (rev_id >> 24)) {
-                                u32 value = ~val & desc->mask;
-
-                                if (value) {
-                                        ret = regmap_write(maps[desc->ip],
-                                                HW_REVISION_ID, value);
-                                        if (ret < 0)
-                                                return ret;
-                                }
-                        }
-                }
-
-                ret = regmap_update_bits(maps[desc->ip], desc->reg,
-                                         desc->mask, val);
-
-                if (ret)
-                        return ret;
-        }
-
-        ret = aspeed_sig_expr_eval(expr, enable, maps);
-        if (ret < 0)
-                return ret;
-
-        if (!ret)
-                return -EPERM;
-
-        return 0;
-}
-
-static int aspeed_sig_expr_enable(const struct aspeed_sig_expr *expr,
-                                   struct regmap * const *maps)
-{
-        int ret;
-
-        ret = aspeed_sig_expr_eval(expr, true, maps);
+        ret = aspeed_sig_expr_eval(ctx, expr, true);
         if (ret < 0)
                 return ret;
 
         if (!ret)
-                return aspeed_sig_expr_set(expr, true, maps);
+                return aspeed_sig_expr_set(ctx, expr, true);
 
         return 0;
 }
 
-static int aspeed_sig_expr_disable(const struct aspeed_sig_expr *expr,
-                                    struct regmap * const *maps)
+static int aspeed_sig_expr_disable(const struct aspeed_pinmux_data *ctx,
+                                   const struct aspeed_sig_expr *expr)
 {
         int ret;
 
-        ret = aspeed_sig_expr_eval(expr, true, maps);
+        ret = aspeed_sig_expr_eval(ctx, expr, true);
         if (ret < 0)
                 return ret;
 
         if (ret)
-                return aspeed_sig_expr_set(expr, false, maps);
+                return aspeed_sig_expr_set(ctx, expr, false);
 
         return 0;
 }
@@ -280,13 +104,13 @@ static int aspeed_sig_expr_disable(const struct aspeed_sig_expr *expr,
 /**
  * Disable a signal on a pin by disabling all provided signal expressions.
  *
+ * @ctx: The pinmux context
  * @exprs: The list of signal expressions (from a priority level on a pin)
- * @maps: The list of regmap instances for pinmux register access.
  *
  * Return: 0 if all expressions are disabled, otherwise a negative error code
  */
-static int aspeed_disable_sig(const struct aspeed_sig_expr **exprs,
-                               struct regmap * const *maps)
+static int aspeed_disable_sig(const struct aspeed_pinmux_data *ctx,
+                              const struct aspeed_sig_expr **exprs)
 {
         int ret = 0;
 
@@ -294,7 +118,7 @@ static int aspeed_disable_sig(const struct aspeed_sig_expr **exprs,
                 return true;
 
         while (*exprs && !ret) {
-                ret = aspeed_sig_expr_disable(*exprs, maps);
+                ret = aspeed_sig_expr_disable(ctx, *exprs);
                 exprs++;
         }
 
@@ -395,9 +219,9 @@ int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
         int ret;
         const struct aspeed_pinctrl_data *pdata =
                 pinctrl_dev_get_drvdata(pctldev);
-        const struct aspeed_pin_group *pgroup = &pdata->groups[group];
+        const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
         const struct aspeed_pin_function *pfunc =
-                &pdata->functions[function];
+                &pdata->pinmux.functions[function];
 
         for (i = 0; i < pgroup->npins; i++) {
                 int pin = pgroup->pins[i];
@@ -423,7 +247,7 @@ int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
                         if (expr)
                                 break;
 
-                        ret = aspeed_disable_sig(funcs, pdata->maps);
+                        ret = aspeed_disable_sig(&pdata->pinmux, funcs);
                         if (ret)
                                 return ret;
 
@@ -443,7 +267,7 @@ int aspeed_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned int function,
                         return -ENXIO;
                 }
 
-                ret = aspeed_sig_expr_enable(expr, pdata->maps);
+                ret = aspeed_sig_expr_enable(&pdata->pinmux, expr);
                 if (ret)
                         return ret;
         }
@@ -500,7 +324,7 @@ int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
                 if (aspeed_gpio_in_exprs(funcs))
                         break;
 
-                ret = aspeed_disable_sig(funcs, pdata->maps);
+                ret = aspeed_disable_sig(&pdata->pinmux, funcs);
                 if (ret)
                         return ret;
 
@@ -531,7 +355,7 @@ int aspeed_gpio_request_enable(struct pinctrl_dev *pctldev,
          * If GPIO is not the lowest priority signal type, assume there is only
          * one expression defined to enable the GPIO function
          */
-        return aspeed_sig_expr_enable(expr, pdata->maps);
+        return aspeed_sig_expr_enable(&pdata->pinmux, expr);
 }
 
 int aspeed_pinctrl_probe(struct platform_device *pdev,
@@ -547,12 +371,14 @@ int aspeed_pinctrl_probe(struct platform_device *pdev,
                 return -ENODEV;
         }
 
-        pdata->maps[ASPEED_IP_SCU] = syscon_node_to_regmap(parent->of_node);
-        if (IS_ERR(pdata->maps[ASPEED_IP_SCU])) {
+        pdata->scu = syscon_node_to_regmap(parent->of_node);
+        if (IS_ERR(pdata->scu)) {
                 dev_err(&pdev->dev, "No regmap for syscon pincontroller parent\n");
-                return PTR_ERR(pdata->maps[ASPEED_IP_SCU]);
+                return PTR_ERR(pdata->scu);
         }
 
+        pdata->pinmux.maps[ASPEED_IP_SCU] = pdata->scu;
+
         pctl = pinctrl_register(pdesc, &pdev->dev, pdata);
 
         if (IS_ERR(pctl)) {
@@ -587,7 +413,9 @@ static inline const struct aspeed_pin_config *find_pinconf_config(
         return NULL;
 }
 
-/**
+/*
+ * Aspeed pin configuration description.
+ *
  * @param: pinconf configuration parameter
  * @arg: The supported argument for @param, or -1 if any value is supported
  * @val: The register value to write to configure @arg for @param
@@ -661,7 +489,7 @@ int aspeed_pin_config_get(struct pinctrl_dev *pctldev, unsigned int offset,
         if (!pconf)
                 return -ENOTSUPP;
 
-        rc = regmap_read(pdata->maps[ASPEED_IP_SCU], pconf->reg, &val);
+        rc = regmap_read(pdata->scu, pconf->reg, &val);
         if (rc < 0)
                 return rc;
 
@@ -716,8 +544,8 @@ int aspeed_pin_config_set(struct pinctrl_dev *pctldev, unsigned int offset,
 
                 val = pmap->val << pconf->bit;
 
-                rc = regmap_update_bits(pdata->maps[ASPEED_IP_SCU], pconf->reg,
-                                BIT(pconf->bit), val);
+                rc = regmap_update_bits(pdata->scu, pconf->reg,
+                                        BIT(pconf->bit), val);
 
                 if (rc < 0)
                         return rc;
diff --git a/drivers/pinctrl/aspeed/pinctrl-aspeed.h b/drivers/pinctrl/aspeed/pinctrl-aspeed.h
index 4b06ddbc6aec..a5d83986f32e 100644
--- a/drivers/pinctrl/aspeed/pinctrl-aspeed.h
+++ b/drivers/pinctrl/aspeed/pinctrl-aspeed.h
@@ -12,504 +12,7 @@
 #include <linux/pinctrl/pinconf-generic.h>
 #include <linux/regmap.h>
 
-/*
- * The ASPEED SoCs provide typically more than 200 pins for GPIO and other
- * functions. The SoC function enabled on a pin is determined on a priority
- * basis where a given pin can provide a number of different signal types.
- *
- * The signal active on a pin is described by both a priority level and
- * compound logical expressions involving multiple operators, registers and
- * bits. Some difficulty arises as the pin's function bit masks for each
- * priority level are frequently not the same (i.e. cannot just flip a bit to
- * change from a high to low priority signal), or even in the same register.
- * Further, not all signals can be unmuxed, as some expressions depend on
- * values in the hardware strapping register (which is treated as read-only).
- *
- * SoC Multi-function Pin Expression Examples
- * ------------------------------------------
- *
- * Here are some sample mux configurations from the AST2400 and AST2500
- * datasheets to illustrate the corner cases, roughly in order of least to most
- * corner. The signal priorities are in decending order from P0 (highest).
- *
- * D6 is a pin with a single function (beside GPIO); a high priority signal
- * that participates in one function:
- *
- * Ball | Default | P0 Signal | P0 Expression               | P1 Signal | P1 Expression | Other
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *  D6    GPIOA0    MAC1LINK    SCU80[0]=1                                                GPIOA0
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *
- * C5 is a multi-signal pin (high and low priority signals). Here we touch
- * different registers for the different functions that enable each signal:
- *
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *  C5    GPIOA4    SCL9        SCU90[22]=1                   TIMER5      SCU80[4]=1      GPIOA4
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *
- * E19 is a single-signal pin with two functions that influence the active
- * signal. In this case both bits have the same meaning - enable a dedicated
- * LPC reset pin. However it's not always the case that the bits in the
- * OR-relationship have the same meaning.
- *
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *  E19   GPIOB4    LPCRST#     SCU80[12]=1 | Strap[14]=1                                 GPIOB4
- * -----+---------+-----------+-----------------------------+-----------+---------------+----------
- *
- * For example, pin B19 has a low-priority signal that's enabled by two
- * distinct SoC functions: A specific SIOPBI bit in register SCUA4, and an ACPI
- * bit in the STRAP register. The ACPI bit configures signals on pins in
- * addition to B19. Both of the low priority functions as well as the high
- * priority function must be disabled for GPIOF1 to be used.
- *
- * Ball | Default | P0 Signal | P0 Expression                           | P1 Signal | P1 Expression                          | Other
- * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
- *  B19   GPIOF1    NDCD4       SCU80[25]=1                               SIOPBI#     SCUA4[12]=1 | Strap[19]=0                GPIOF1
- * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
- *
- * For pin E18, the SoC ANDs the expected state of three bits to determine the
- * pin's active signal:
- *
- * * SCU3C[3]: Enable external SOC reset function
- * * SCU80[15]: Enable SPICS1# or EXTRST# function pin
- * * SCU90[31]: Select SPI interface CS# output
- *
- * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
- *  E18   GPIOB7    EXTRST#     SCU3C[3]=1 & SCU80[15]=1 & SCU90[31]=0    SPICS1#     SCU3C[3]=1 & SCU80[15]=1 & SCU90[31]=1   GPIOB7
- * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
- *
- * (Bits SCU3C[3] and SCU80[15] appear to only be used in the expressions for
- * selecting the signals on pin E18)
- *
- * Pin T5 is a multi-signal pin with a more complex configuration:
- *
- * Ball | Default | P0 Signal | P0 Expression                | P1 Signal | P1 Expression | Other
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *  T5    GPIOL1    VPIDE       SCU90[5:4]!=0 & SCU84[17]=1    NDCD1       SCU84[17]=1     GPIOL1
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *
- * The high priority signal configuration is best thought of in terms of its
- * exploded form, with reference to the SCU90[5:4] bits:
- *
- * * SCU90[5:4]=00: disable
- * * SCU90[5:4]=01: 18 bits (R6/G6/B6) video mode.
- * * SCU90[5:4]=10: 24 bits (R8/G8/B8) video mode.
- * * SCU90[5:4]=11: 30 bits (R10/G10/B10) video mode.
- *
- * Re-writing:
- *
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *  T5    GPIOL1    VPIDE      (SCU90[5:4]=1 & SCU84[17]=1)    NDCD1       SCU84[17]=1     GPIOL1
- *                             | (SCU90[5:4]=2 & SCU84[17]=1)
- *                             | (SCU90[5:4]=3 & SCU84[17]=1)
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *
- * For reference the SCU84[17] bit configure the "UART1 NDCD1 or Video VPIDE
- * function pin", where the signal itself is determined by whether SCU94[5:4]
- * is disabled or in one of the 18, 24 or 30bit video modes.
- *
- * Other video-input-related pins require an explicit state in SCU90[5:4], e.g.
- * W1 and U5:
- *
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *  W1    GPIOL6    VPIB0       SCU90[5:4]=3 & SCU84[22]=1     TXD1        SCU84[22]=1     GPIOL6
- *  U5    GPIOL7    VPIB1       SCU90[5:4]=3 & SCU84[23]=1     RXD1        SCU84[23]=1     GPIOL7
- * -----+---------+-----------+------------------------------+-----------+---------------+----------
- *
- * The examples of T5 and W1 are particularly fertile, as they also demonstrate
- * that despite operating as part of the video input bus each signal needs to
- * be enabled individually via it's own SCU84 (in the cases of T5 and W1)
- * register bit. This is a little crazy if the bus doesn't have optional
- * signals, but is used to decent effect with some of the UARTs where not all
- * signals are required. However, this isn't done consistently - UART1 is
- * enabled on a per-pin basis, and by contrast, all signals for UART6 are
- * enabled by a single bit.
- *
- * Further, the high and low priority signals listed in the table above share
- * a configuration bit. The VPI signals should operate in concert in a single
- * function, but the UART signals should retain the ability to be configured
- * independently. This pushes the implementation down the path of tagging a
- * signal's expressions with the function they participate in, rather than
- * defining masks affecting multiple signals per function. The latter approach
- * fails in this instance where applying the configuration for the UART pin of
- * interest will stomp on the state of other UART signals when disabling the
- * VPI functions on the current pin.
- *
- * Ball |  Default   | P0 Signal | P0 Expression             | P1 Signal | P1 Expression | Other
- * -----+------------+-----------+---------------------------+-----------+---------------+------------
- *  A12   RGMII1TXCK   GPIOT0      SCUA0[0]=1                  RMII1TXEN   Strap[6]=0      RGMII1TXCK
- *  B12   RGMII1TXCTL  GPIOT1      SCUA0[1]=1                  –           Strap[6]=0      RGMII1TXCTL
- * -----+------------+-----------+---------------------------+-----------+---------------+------------
- *
- * A12 demonstrates that the "Other" signal isn't always GPIO - in this case
- * GPIOT0 is a high-priority signal and RGMII1TXCK is Other. Thus, GPIO
- * should be treated like any other signal type with full function expression
- * requirements, and not assumed to be the default case. Separately, GPIOT0 and
- * GPIOT1's signal descriptor bits are distinct, therefore we must iterate all
- * pins in the function's group to disable the higher-priority signals such
- * that the signal for the function of interest is correctly enabled.
- *
- * Finally, three priority levels aren't always enough; the AST2500 brings with
- * it 18 pins of five priority levels, however the 18 pins only use three of
- * the five priority levels.
- *
- * Ultimately the requirement to control pins in the examples above drive the
- * design:
- *
- * * Pins provide signals according to functions activated in the mux
- *   configuration
- *
- * * Pins provide up to five signal types in a priority order
- *
- * * For priorities levels defined on a pin, each priority provides one signal
- *
- * * Enabling lower priority signals requires higher priority signals be
- *   disabled
- *
- * * A function represents a set of signals; functions are distinct if their
- *   sets of signals are not equal
- *
- * * Signals participate in one or more functions
- *
- * * A function is described by an expression of one or more signal
- *   descriptors, which compare bit values in a register
- *
- * * A signal expression is the smallest set of signal descriptors whose
- *   comparisons must evaluate 'true' for a signal to be enabled on a pin.
- *
- * * A function's signal is active on a pin if evaluating all signal
- *   descriptors in the pin's signal expression for the function yields a 'true'
- *   result
- *
- * * A signal at a given priority on a given pin is active if any of the
- *   functions in which the signal participates are active, and no higher
- *   priority signal on the pin is active
- *
- * * GPIO is configured per-pin
- *
- * And so:
- *
- * * To disable a signal, any function(s) activating the signal must be
- *   disabled
- *
- * * Each pin must know the signal expressions of functions in which it
- *   participates, for the purpose of enabling the Other function. This is done
- *   by deactivating all functions that activate higher priority signals on the
- *   pin.
- *
- * As a concrete example:
- *
- * * T5 provides three signals types: VPIDE, NDCD1 and GPIO
- *
- * * The VPIDE signal participates in 3 functions: VPI18, VPI24 and VPI30
- *
- * * The NDCD1 signal participates in just its own NDCD1 function
- *
- * * VPIDE is high priority, NDCD1 is low priority, and GPIOL1 is the least
- *   prioritised
- *
- * * The prerequisit for activating the NDCD1 signal is that the VPI18, VPI24
- *   and VPI30 functions all be disabled
- *
- * * Similarly, all of VPI18, VPI24, VPI30 and NDCD1 functions must be disabled
- *   to provide GPIOL6
- *
- * Considerations
- * --------------
- *
- * If pinctrl allows us to allocate a pin we can configure a function without
- * concern for the function of already allocated pins, if pin groups are
- * created with respect to the SoC functions in which they participate. This is
- * intuitive, but it did not feel obvious from the bit/pin relationships.
- *
- * Conversely, failing to allocate all pins in a group indicates some bits (as
- * well as pins) required for the group's configuration will already be in use,
- * likely in a way that's inconsistent with the requirements of the failed
- * group.
- */
-
-#define ASPEED_IP_SCU           0
-#define ASPEED_IP_GFX           1
-#define ASPEED_IP_LPC           2
-#define ASPEED_NR_PINMUX_IPS    3
-
-/*
- * The "Multi-function Pins Mapping and Control" table in the SoC datasheet
- * references registers by the device/offset mnemonic. The register macros
- * below are named the same way to ease transcription and verification (as
- * opposed to naming them e.g. PINMUX_CTRL_[0-9]). Further, signal expressions
- * reference registers beyond those dedicated to pinmux, such as the system
- * reset control and MAC clock configuration registers. The AST2500 goes a step
- * further and references registers in the graphics IP block, but that isn't
- * handled yet.
- */
-#define SCU2C           0x2C /* Misc. Control Register */
-#define SCU3C           0x3C /* System Reset Control/Status Register */
-#define SCU48           0x48 /* MAC Interface Clock Delay Setting */
-#define HW_STRAP1       0x70 /* AST2400 strapping is 33 bits, is split */
-#define HW_REVISION_ID  0x7C /* Silicon revision ID register */
-#define SCU80           0x80 /* Multi-function Pin Control #1 */
-#define SCU84           0x84 /* Multi-function Pin Control #2 */
-#define SCU88           0x88 /* Multi-function Pin Control #3 */
-#define SCU8C           0x8C /* Multi-function Pin Control #4 */
-#define SCU90           0x90 /* Multi-function Pin Control #5 */
-#define SCU94           0x94 /* Multi-function Pin Control #6 */
-#define SCUA0           0xA0 /* Multi-function Pin Control #7 */
-#define SCUA4           0xA4 /* Multi-function Pin Control #8 */
-#define SCUA8           0xA8 /* Multi-function Pin Control #9 */
-#define SCUAC           0xAC /* Multi-function Pin Control #10 */
-#define HW_STRAP2       0xD0 /* Strapping */
-
- /**
-  * A signal descriptor, which describes the register, bits and the
-  * enable/disable values that should be compared or written.
-  *
-  * @ip: The IP block identifier, used as an index into the regmap array in
-  *      struct aspeed_pinctrl_data
-  * @reg: The register offset with respect to the base address of the IP block
-  * @mask: The mask to apply to the register. The lowest set bit of the mask is
-  *        used to derive the shift value.
-  * @enable: The value that enables the function. Value should be in the LSBs,
-  *          not at the position of the mask.
-  * @disable: The value that disables the function. Value should be in the
-  *           LSBs, not at the position of the mask.
-  */
-struct aspeed_sig_desc {
-        unsigned int ip;
-        unsigned int reg;
-        u32 mask;
-        u32 enable;
-        u32 disable;
-};
-
-/**
- * Describes a signal expression. The expression is evaluated by ANDing the
- * evaluation of the descriptors.
- *
- * @signal: The signal name for the priority level on the pin. If the signal
- *          type is GPIO, then the signal name must begin with the string
- *          "GPIO", e.g. GPIOA0, GPIOT4 etc.
- * @function: The name of the function the signal participates in for the
- *            associated expression
- * @ndescs: The number of signal descriptors in the expression
- * @descs: Pointer to an array of signal descriptors that comprise the
- *         function expression
- */
-struct aspeed_sig_expr {
-        const char *signal;
-        const char *function;
-        int ndescs;
-        const struct aspeed_sig_desc *descs;
-};
-
-/**
- * A struct capturing the list of expressions enabling signals at each priority
- * for a given pin. The signal configuration for a priority level is evaluated
- * by ORing the evaluation of the signal expressions in the respective
- * priority's list.
- *
- * @name: A name for the pin
- * @prios: A pointer to an array of expression list pointers
- *
- */
-struct aspeed_pin_desc {
-        const char *name;
-        const struct aspeed_sig_expr ***prios;
-};
-
-/* Macro hell */
-
-#define SIG_DESC_IP_BIT(ip, reg, idx, val) \
-        { ip, reg, BIT_MASK(idx), val, (((val) + 1) & 1) }
-
-/**
- * Short-hand macro for describing an SCU descriptor enabled by the state of
- * one bit. The disable value is derived.
- *
- * @reg: The signal's associated register, offset from base
- * @idx: The signal's bit index in the register
- * @val: The value (0 or 1) that enables the function
- */
-#define SIG_DESC_BIT(reg, idx, val) \
-        SIG_DESC_IP_BIT(ASPEED_IP_SCU, reg, idx, val)
-
-#define SIG_DESC_IP_SET(ip, reg, idx) SIG_DESC_IP_BIT(ip, reg, idx, 1)
-
-/**
- * A further short-hand macro expanding to an SCU descriptor enabled by a set
- * bit.
- *
- * @reg: The register, offset from base
- * @idx: The bit index in the register
- */
-#define SIG_DESC_SET(reg, idx) SIG_DESC_IP_BIT(ASPEED_IP_SCU, reg, idx, 1)
-
-#define SIG_DESC_LIST_SYM(sig, func) sig_descs_ ## sig ## _ ## func
-#define SIG_DESC_LIST_DECL(sig, func, ...) \
-        static const struct aspeed_sig_desc SIG_DESC_LIST_SYM(sig, func)[] = \
-                { __VA_ARGS__ }
-
-#define SIG_EXPR_SYM(sig, func) sig_expr_ ## sig ## _ ## func
-#define SIG_EXPR_DECL_(sig, func) \
-        static const struct aspeed_sig_expr SIG_EXPR_SYM(sig, func) = \
-        { \
-                .signal = #sig, \
-                .function = #func, \
-                .ndescs = ARRAY_SIZE(SIG_DESC_LIST_SYM(sig, func)), \
-                .descs = &(SIG_DESC_LIST_SYM(sig, func))[0], \
-        }
-
-/**
- * Declare a signal expression.
- *
- * @sig: A macro symbol name for the signal (is subjected to stringification
- *        and token pasting)
- * @func: The function in which the signal is participating
- * @...: Signal descriptors that define the signal expression
- *
- * For example, the following declares the ROMD8 signal for the ROM16 function:
- *
- *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
- *
- * And with multiple signal descriptors:
- *
- *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
- *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
- */
-#define SIG_EXPR_DECL(sig, func, ...) \
-        SIG_DESC_LIST_DECL(sig, func, __VA_ARGS__); \
-        SIG_EXPR_DECL_(sig, func)
-
-/**
- * Declare a pointer to a signal expression
- *
- * @sig: The macro symbol name for the signal (subjected to token pasting)
- * @func: The macro symbol name for the function (subjected to token pasting)
- */
-#define SIG_EXPR_PTR(sig, func) (&SIG_EXPR_SYM(sig, func))
-
-#define SIG_EXPR_LIST_SYM(sig) sig_exprs_ ## sig
-
-/**
- * Declare a signal expression list for reference in a struct aspeed_pin_prio.
- *
- * @sig: A macro symbol name for the signal (is subjected to token pasting)
- * @...: Signal expression structure pointers (use SIG_EXPR_PTR())
- *
- * For example, the 16-bit ROM bus can be enabled by one of two possible signal
- * expressions:
- *
- *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
- *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
- *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
- *     SIG_EXPR_LIST_DECL(ROMD8, SIG_EXPR_PTR(ROMD8, ROM16),
- *              SIG_EXPR_PTR(ROMD8, ROM16S));
- */
-#define SIG_EXPR_LIST_DECL(sig, ...) \
-        static const struct aspeed_sig_expr *SIG_EXPR_LIST_SYM(sig)[] = \
-                { __VA_ARGS__, NULL }
-
-/**
- * A short-hand macro for declaring a function expression and an expression
- * list with a single function.
- *
- * @func: A macro symbol name for the function (is subjected to token pasting)
- * @...: Function descriptors that define the function expression
- *
- * For example, signal NCTS6 participates in its own function with one group:
- *
- *     SIG_EXPR_LIST_DECL_SINGLE(NCTS6, NCTS6, SIG_DESC_SET(SCU90, 7));
- */
-#define SIG_EXPR_LIST_DECL_SINGLE(sig, func, ...) \
-        SIG_DESC_LIST_DECL(sig, func, __VA_ARGS__); \
-        SIG_EXPR_DECL_(sig, func); \
-        SIG_EXPR_LIST_DECL(sig, SIG_EXPR_PTR(sig, func))
-
-#define SIG_EXPR_LIST_DECL_DUAL(sig, f0, f1) \
-        SIG_EXPR_LIST_DECL(sig, SIG_EXPR_PTR(sig, f0), SIG_EXPR_PTR(sig, f1))
-
-#define SIG_EXPR_LIST_PTR(sig) (&SIG_EXPR_LIST_SYM(sig)[0])
-
-#define PIN_EXPRS_SYM(pin) pin_exprs_ ## pin
-#define PIN_EXPRS_PTR(pin) (&PIN_EXPRS_SYM(pin)[0])
-#define PIN_SYM(pin) pin_ ## pin
-
-#define MS_PIN_DECL_(pin, ...) \
-        static const struct aspeed_sig_expr **PIN_EXPRS_SYM(pin)[] = \
-                { __VA_ARGS__, NULL }; \
-        static const struct aspeed_pin_desc PIN_SYM(pin) = \
-                { #pin, PIN_EXPRS_PTR(pin) }
-
-/**
- * Declare a multi-signal pin
- *
- * @pin: The pin number
- * @other: Macro name for "other" functionality (subjected to stringification)
- * @high: Macro name for the highest priority signal functions
- * @low: Macro name for the low signal functions
- *
- * For example:
- *
- *     #define A8 56
- *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
- *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
- *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
- *     SIG_EXPR_LIST_DECL(ROMD8, SIG_EXPR_PTR(ROMD8, ROM16),
- *              SIG_EXPR_PTR(ROMD8, ROM16S));
- *     SIG_EXPR_LIST_DECL_SINGLE(NCTS6, NCTS6, SIG_DESC_SET(SCU90, 7));
- *     MS_PIN_DECL(A8, GPIOH0, ROMD8, NCTS6);
- */
-#define MS_PIN_DECL(pin, other, high, low) \
-        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
-        MS_PIN_DECL_(pin, \
-                        SIG_EXPR_LIST_PTR(high), \
-                        SIG_EXPR_LIST_PTR(low), \
-                        SIG_EXPR_LIST_PTR(other))
-
-#define PIN_GROUP_SYM(func) pins_ ## func
-#define FUNC_GROUP_SYM(func) groups_ ## func
-#define FUNC_GROUP_DECL(func, ...) \
-        static const int PIN_GROUP_SYM(func)[] = { __VA_ARGS__ }; \
-        static const char *FUNC_GROUP_SYM(func)[] = { #func }
-
-/**
- * Declare a single signal pin
- *
- * @pin: The pin number
- * @other: Macro name for "other" functionality (subjected to stringification)
- * @sig: Macro name for the signal (subjected to stringification)
- *
- * For example:
- *
- *     #define E3 80
- *     SIG_EXPR_LIST_DECL_SINGLE(SCL5, I2C5, I2C5_DESC);
- *     SS_PIN_DECL(E3, GPIOK0, SCL5);
- */
-#define SS_PIN_DECL(pin, other, sig) \
-        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
-        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(sig), SIG_EXPR_LIST_PTR(other))
-
-/**
- * Single signal, single function pin declaration
- *
- * @pin: The pin number
- * @other: Macro name for "other" functionality (subjected to stringification)
- * @sig: Macro name for the signal (subjected to stringification)
- * @...: Signal descriptors that define the function expression
- *
- * For example:
- *
- *    SSSF_PIN_DECL(A4, GPIOA2, TIMER3, SIG_DESC_SET(SCU80, 2));
- */
-#define SSSF_PIN_DECL(pin, other, sig, ...) \
-        SIG_EXPR_LIST_DECL_SINGLE(sig, sig, __VA_ARGS__); \
-        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
-        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(sig), SIG_EXPR_LIST_PTR(other)); \
-        FUNC_GROUP_DECL(sig, pin)
-
-#define GPIO_PIN_DECL(pin, gpio) \
-        SIG_EXPR_LIST_DECL_SINGLE(gpio, gpio); \
-        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(gpio))
+#include "pinmux-aspeed.h"
 
 /**
  * @param The pinconf parameter type
@@ -525,22 +28,6 @@ struct aspeed_pin_config {
         u8 value;
 };
 
-struct aspeed_pinctrl_data {
-        struct regmap *maps[ASPEED_NR_PINMUX_IPS];
-
-        const struct pinctrl_pin_desc *pins;
-        const unsigned int npins;
-
-        const struct aspeed_pin_group *groups;
-        const unsigned int ngroups;
-
-        const struct aspeed_pin_function *functions;
-        const unsigned int nfunctions;
-
-        const struct aspeed_pin_config *configs;
-        const unsigned int nconfigs;
-};
-
 #define ASPEED_PINCTRL_PIN(name_) \
         [name_] = { \
                 .number = name_, \
@@ -548,30 +35,19 @@ struct aspeed_pinctrl_data {
                 .drv_data = (void *) &(PIN_SYM(name_)) \
         }
 
-struct aspeed_pin_group {
-        const char *name;
-        const unsigned int *pins;
+struct aspeed_pinctrl_data {
+        struct regmap *scu;
+
+        const struct pinctrl_pin_desc *pins;
         const unsigned int npins;
-};
 
-#define ASPEED_PINCTRL_GROUP(name_) { \
-        .name = #name_, \
-        .pins = &(PIN_GROUP_SYM(name_))[0], \
-        .npins = ARRAY_SIZE(PIN_GROUP_SYM(name_)), \
-}
+        const struct aspeed_pin_config *configs;
+        const unsigned int nconfigs;
 
-struct aspeed_pin_function {
-        const char *name;
-        const char *const *groups;
-        unsigned int ngroups;
+        struct aspeed_pinmux_data pinmux;
 };
 
-#define ASPEED_PINCTRL_FUNC(name_, ...) { \
-        .name = #name_, \
-        .groups = &FUNC_GROUP_SYM(name_)[0], \
-        .ngroups = ARRAY_SIZE(FUNC_GROUP_SYM(name_)), \
-}
-
+/* Aspeed pinctrl helpers */
 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev *pctldev);
 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
                 unsigned int group);
diff --git a/drivers/pinctrl/aspeed/pinmux-aspeed.c b/drivers/pinctrl/aspeed/pinmux-aspeed.c
new file mode 100644
index 000000000000..5b0fe178ccf2
--- /dev/null
+++ b/drivers/pinctrl/aspeed/pinmux-aspeed.c
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Copyright (C) 2019 IBM Corp. */
+
+/* Pieces to enable drivers to implement the .set callback */
+
+#include "pinmux-aspeed.h"
+
+const char *const aspeed_pinmux_ips[] = {
+        [ASPEED_IP_SCU] = "SCU",
+        [ASPEED_IP_GFX] = "GFX",
+        [ASPEED_IP_LPC] = "LPC",
+};
+
+static inline void aspeed_sig_desc_print_val(
+                const struct aspeed_sig_desc *desc, bool enable, u32 rv)
+{
+        pr_debug("Want %s%X[0x%08X]=0x%X, got 0x%X from 0x%08X\n",
+                        aspeed_pinmux_ips[desc->ip], desc->reg,
+                        desc->mask, enable ? desc->enable : desc->disable,
+                        (rv & desc->mask) >> __ffs(desc->mask), rv);
+}
+
+/**
+ * Query the enabled or disabled state of a signal descriptor
+ *
+ * @desc: The signal descriptor of interest
+ * @enabled: True to query the enabled state, false to query disabled state
+ * @map: The IP block's regmap instance
+ *
+ * Return: 1 if the descriptor's bitfield is configured to the state
+ * selected by @enabled, 0 if not, and less than zero if an unrecoverable
+ * failure occurred
+ *
+ * Evaluation of descriptor state is non-trivial in that it is not a binary
+ * outcome: The bitfields can be greater than one bit in size and thus can take
+ * a value that is neither the enabled nor disabled state recorded in the
+ * descriptor (typically this means a different function to the one of interest
+ * is enabled). Thus we must explicitly test for either condition as required.
+ */
+int aspeed_sig_desc_eval(const struct aspeed_sig_desc *desc,
+                         bool enabled, struct regmap *map)
+{
+        int ret;
+        unsigned int raw;
+        u32 want;
+
+        if (!map)
+                return -ENODEV;
+
+        ret = regmap_read(map, desc->reg, &raw);
+        if (ret)
+                return ret;
+
+        aspeed_sig_desc_print_val(desc, enabled, raw);
+        want = enabled ? desc->enable : desc->disable;
+
+        return ((raw & desc->mask) >> __ffs(desc->mask)) == want;
+}
+
+/**
+ * Query the enabled or disabled state for a mux function's signal on a pin
+ *
+ * @ctx: The driver context for the pinctrl IP
+ * @expr: An expression controlling the signal for a mux function on a pin
+ * @enabled: True to query the enabled state, false to query disabled state
+ *
+ * Return: 1 if the expression composed by @enabled evaluates true, 0 if not,
+ * and less than zero if an unrecoverable failure occurred.
+ *
+ * A mux function is enabled or disabled if the function's signal expression
+ * for each pin in the function's pin group evaluates true for the desired
+ * state. An signal expression evaluates true if all of its associated signal
+ * descriptors evaluate true for the desired state.
+ *
+ * If an expression's state is described by more than one bit, either through
+ * multi-bit bitfields in a single signal descriptor or through multiple signal
+ * descriptors of a single bit then it is possible for the expression to be in
+ * neither the enabled nor disabled state. Thus we must explicitly test for
+ * either condition as required.
+ */
+int aspeed_sig_expr_eval(const struct aspeed_pinmux_data *ctx,
+                         const struct aspeed_sig_expr *expr, bool enabled)
+{
+        int i;
+        int ret;
+
+        for (i = 0; i < expr->ndescs; i++) {
+                const struct aspeed_sig_desc *desc = &expr->descs[i];
+
+                ret = aspeed_sig_desc_eval(desc, enabled, ctx->maps[desc->ip]);
+                if (ret <= 0)
+                        return ret;
+        }
+
+        return 1;
+}
diff --git a/drivers/pinctrl/aspeed/pinmux-aspeed.h b/drivers/pinctrl/aspeed/pinmux-aspeed.h
new file mode 100644
index 000000000000..329d54d48667
--- /dev/null
+++ b/drivers/pinctrl/aspeed/pinmux-aspeed.h
@@ -0,0 +1,735 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* Copyright (C) 2019 IBM Corp.  */
+
+#ifndef ASPEED_PINMUX_H
+#define ASPEED_PINMUX_H
+
+#include <linux/regmap.h>
+#include <stdbool.h>
+
+/*
+ * The ASPEED SoCs provide typically more than 200 pins for GPIO and other
+ * functions. The SoC function enabled on a pin is determined on a priority
+ * basis where a given pin can provide a number of different signal types.
+ *
+ * The signal active on a pin is described by both a priority level and
+ * compound logical expressions involving multiple operators, registers and
+ * bits. Some difficulty arises as the pin's function bit masks for each
+ * priority level are frequently not the same (i.e. cannot just flip a bit to
+ * change from a high to low priority signal), or even in the same register.
+ * Further, not all signals can be unmuxed, as some expressions depend on
+ * values in the hardware strapping register (which may be treated as
+ * read-only).
+ *
+ * SoC Multi-function Pin Expression Examples
+ * ------------------------------------------
+ *
+ * Here are some sample mux configurations from the AST2400 and AST2500
+ * datasheets to illustrate the corner cases, roughly in order of least to most
+ * corner. The signal priorities are in decending order from P0 (highest).
+ *
+ * D6 is a pin with a single function (beside GPIO); a high priority signal
+ * that participates in one function:
+ *
+ * Ball | Default | P0 Signal | P0 Expression               | P1 Signal | P1 Expression | Other
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *  D6    GPIOA0    MAC1LINK    SCU80[0]=1                                                GPIOA0
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *
+ * C5 is a multi-signal pin (high and low priority signals). Here we touch
+ * different registers for the different functions that enable each signal:
+ *
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *  C5    GPIOA4    SCL9        SCU90[22]=1                   TIMER5      SCU80[4]=1      GPIOA4
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *
+ * E19 is a single-signal pin with two functions that influence the active
+ * signal. In this case both bits have the same meaning - enable a dedicated
+ * LPC reset pin. However it's not always the case that the bits in the
+ * OR-relationship have the same meaning.
+ *
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *  E19   GPIOB4    LPCRST#     SCU80[12]=1 | Strap[14]=1                                 GPIOB4
+ * -----+---------+-----------+-----------------------------+-----------+---------------+----------
+ *
+ * For example, pin B19 has a low-priority signal that's enabled by two
+ * distinct SoC functions: A specific SIOPBI bit in register SCUA4, and an ACPI
+ * bit in the STRAP register. The ACPI bit configures signals on pins in
+ * addition to B19. Both of the low priority functions as well as the high
+ * priority function must be disabled for GPIOF1 to be used.
+ *
+ * Ball | Default | P0 Signal | P0 Expression                           | P1 Signal | P1 Expression                          | Other
+ * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
+ *  B19   GPIOF1    NDCD4       SCU80[25]=1                               SIOPBI#     SCUA4[12]=1 | Strap[19]=0                GPIOF1
+ * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
+ *
+ * For pin E18, the SoC ANDs the expected state of three bits to determine the
+ * pin's active signal:
+ *
+ * * SCU3C[3]: Enable external SOC reset function
+ * * SCU80[15]: Enable SPICS1# or EXTRST# function pin
+ * * SCU90[31]: Select SPI interface CS# output
+ *
+ * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
+ *  E18   GPIOB7    EXTRST#     SCU3C[3]=1 & SCU80[15]=1 & SCU90[31]=0    SPICS1#     SCU3C[3]=1 & SCU80[15]=1 & SCU90[31]=1   GPIOB7
+ * -----+---------+-----------+-----------------------------------------+-----------+----------------------------------------+----------
+ *
+ * (Bits SCU3C[3] and SCU80[15] appear to only be used in the expressions for
+ * selecting the signals on pin E18)
+ *
+ * Pin T5 is a multi-signal pin with a more complex configuration:
+ *
+ * Ball | Default | P0 Signal | P0 Expression                | P1 Signal | P1 Expression | Other
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *  T5    GPIOL1    VPIDE       SCU90[5:4]!=0 & SCU84[17]=1    NDCD1       SCU84[17]=1     GPIOL1
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *
+ * The high priority signal configuration is best thought of in terms of its
+ * exploded form, with reference to the SCU90[5:4] bits:
+ *
+ * * SCU90[5:4]=00: disable
+ * * SCU90[5:4]=01: 18 bits (R6/G6/B6) video mode.
+ * * SCU90[5:4]=10: 24 bits (R8/G8/B8) video mode.
+ * * SCU90[5:4]=11: 30 bits (R10/G10/B10) video mode.
+ *
+ * Re-writing:
+ *
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *  T5    GPIOL1    VPIDE      (SCU90[5:4]=1 & SCU84[17]=1)    NDCD1       SCU84[17]=1     GPIOL1
+ *                             | (SCU90[5:4]=2 & SCU84[17]=1)
+ *                             | (SCU90[5:4]=3 & SCU84[17]=1)
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *
+ * For reference the SCU84[17] bit configure the "UART1 NDCD1 or Video VPIDE
+ * function pin", where the signal itself is determined by whether SCU94[5:4]
+ * is disabled or in one of the 18, 24 or 30bit video modes.
+ *
+ * Other video-input-related pins require an explicit state in SCU90[5:4], e.g.
+ * W1 and U5:
+ *
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *  W1    GPIOL6    VPIB0       SCU90[5:4]=3 & SCU84[22]=1     TXD1        SCU84[22]=1     GPIOL6
+ *  U5    GPIOL7    VPIB1       SCU90[5:4]=3 & SCU84[23]=1     RXD1        SCU84[23]=1     GPIOL7
+ * -----+---------+-----------+------------------------------+-----------+---------------+----------
+ *
+ * The examples of T5 and W1 are particularly fertile, as they also demonstrate
+ * that despite operating as part of the video input bus each signal needs to
+ * be enabled individually via it's own SCU84 (in the cases of T5 and W1)
+ * register bit. This is a little crazy if the bus doesn't have optional
+ * signals, but is used to decent effect with some of the UARTs where not all
+ * signals are required. However, this isn't done consistently - UART1 is
+ * enabled on a per-pin basis, and by contrast, all signals for UART6 are
+ * enabled by a single bit.
+ *
+ * Further, the high and low priority signals listed in the table above share
+ * a configuration bit. The VPI signals should operate in concert in a single
+ * function, but the UART signals should retain the ability to be configured
+ * independently. This pushes the implementation down the path of tagging a
+ * signal's expressions with the function they participate in, rather than
+ * defining masks affecting multiple signals per function. The latter approach
+ * fails in this instance where applying the configuration for the UART pin of
+ * interest will stomp on the state of other UART signals when disabling the
+ * VPI functions on the current pin.
+ *
+ * Ball |  Default   | P0 Signal | P0 Expression             | P1 Signal | P1 Expression | Other
+ * -----+------------+-----------+---------------------------+-----------+---------------+------------
+ *  A12   RGMII1TXCK   GPIOT0      SCUA0[0]=1                  RMII1TXEN   Strap[6]=0      RGMII1TXCK
+ *  B12   RGMII1TXCTL  GPIOT1      SCUA0[1]=1                  –           Strap[6]=0      RGMII1TXCTL
+ * -----+------------+-----------+---------------------------+-----------+---------------+------------
+ *
+ * A12 demonstrates that the "Other" signal isn't always GPIO - in this case
+ * GPIOT0 is a high-priority signal and RGMII1TXCK is Other. Thus, GPIO
+ * should be treated like any other signal type with full function expression
+ * requirements, and not assumed to be the default case. Separately, GPIOT0 and
+ * GPIOT1's signal descriptor bits are distinct, therefore we must iterate all
+ * pins in the function's group to disable the higher-priority signals such
+ * that the signal for the function of interest is correctly enabled.
+ *
+ * Finally, three priority levels aren't always enough; the AST2500 brings with
+ * it 18 pins of five priority levels, however the 18 pins only use three of
+ * the five priority levels.
+ *
+ * Ultimately the requirement to control pins in the examples above drive the
+ * design:
+ *
+ * * Pins provide signals according to functions activated in the mux
+ *   configuration
+ *
+ * * Pins provide up to five signal types in a priority order
+ *
+ * * For priorities levels defined on a pin, each priority provides one signal
+ *
+ * * Enabling lower priority signals requires higher priority signals be
+ *   disabled
+ *
+ * * A function represents a set of signals; functions are distinct if their
+ *   sets of signals are not equal
+ *
+ * * Signals participate in one or more functions
+ *
+ * * A function is described by an expression of one or more signal
+ *   descriptors, which compare bit values in a register
+ *
+ * * A signal expression is the smallest set of signal descriptors whose
+ *   comparisons must evaluate 'true' for a signal to be enabled on a pin.
+ *
+ * * A signal participating in a function is active on a pin if evaluating all
+ *   signal descriptors in the pin's signal expression for the function yields
+ *   a 'true' result
+ *
+ * * A signal at a given priority on a given pin is active if any of the
+ *   functions in which the signal participates are active, and no higher
+ *   priority signal on the pin is active
+ *
+ * * GPIO is configured per-pin
+ *
+ * And so:
+ *
+ * * To disable a signal, any function(s) activating the signal must be
+ *   disabled
+ *
+ * * Each pin must know the signal expressions of functions in which it
+ *   participates, for the purpose of enabling the Other function. This is done
+ *   by deactivating all functions that activate higher priority signals on the
+ *   pin.
+ *
+ * As a concrete example:
+ *
+ * * T5 provides three signals types: VPIDE, NDCD1 and GPIO
+ *
+ * * The VPIDE signal participates in 3 functions: VPI18, VPI24 and VPI30
+ *
+ * * The NDCD1 signal participates in just its own NDCD1 function
+ *
+ * * VPIDE is high priority, NDCD1 is low priority, and GPIOL1 is the least
+ *   prioritised
+ *
+ * * The prerequisit for activating the NDCD1 signal is that the VPI18, VPI24
+ *   and VPI30 functions all be disabled
+ *
+ * * Similarly, all of VPI18, VPI24, VPI30 and NDCD1 functions must be disabled
+ *   to provide GPIOL6
+ *
+ * Considerations
+ * --------------
+ *
+ * If pinctrl allows us to allocate a pin we can configure a function without
+ * concern for the function of already allocated pins, if pin groups are
+ * created with respect to the SoC functions in which they participate. This is
+ * intuitive, but it did not feel obvious from the bit/pin relationships.
+ *
+ * Conversely, failing to allocate all pins in a group indicates some bits (as
+ * well as pins) required for the group's configuration will already be in use,
+ * likely in a way that's inconsistent with the requirements of the failed
+ * group.
+ *
+ * Implementation
+ * --------------
+ *
+ * Beyond the documentation below the various structures and helper macros that
+ * allow the implementation to hang together are defined. The macros are fairly
+ * dense, so below we walk through some raw examples of the configuration
+ * tables in an effort to clarify the concepts.
+ *
+ * The complexity of configuring the mux combined with the scale of the pins
+ * and functions was a concern, so the table design along with the macro jungle
+ * is an attempt to address it. The rough principles of the approach are:
+ *
+ * 1. Use a data-driven solution rather than embedding state into code
+ * 2. Minimise editing to the specifics of the given mux configuration
+ * 3. Detect as many errors as possible at compile time
+ *
+ * Addressing point 3 leads to naming of symbols in terms of the four
+ * properties associated with a given mux configuration: The pin, the signal,
+ * the group and the function. In this way copy/paste errors cause duplicate
+ * symbols to be defined, which prevents successful compilation. Failing to
+ * properly parent the tables leads to unused symbol warnings, and use of
+ * designated initialisers and additional warnings ensures that there are
+ * no override errors in the pin, group and function arrays.
+ *
+ * Addressing point 2 drives the development of the macro jungle, as it
+ * centralises the definition noise at the cost of taking some time to
+ * understand.
+ *
+ * Here's a complete, concrete "pre-processed" example of the table structures
+ * used to describe the D6 ball from the examples above:
+ *
+ * ```
+ * static const struct aspeed_sig_desc sig_descs_MAC1LINK_MAC1LINK[] = {
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x80,
+ *         .mask = BIT(0),
+ *         .enable = 1,
+ *         .disable = 0
+ *     },
+ * };
+ *
+ * static const struct aspeed_sig_expr sig_expr_MAC1LINK_MAC1LINK = {
+ *     .signal = "MAC1LINK",
+ *     .function = "MAC1LINK",
+ *     .ndescs = ARRAY_SIZE(sig_descs_MAC1LINK_MAC1LINK),
+ *     .descs = &(sig_descs_MAC1LINK_MAC1LINK)[0],
+ * };
+ *
+ * static const struct aspeed_sig_expr *sig_exprs_MAC1LINK_MAC1LINK[] = {
+ *     &sig_expr_MAC1LINK_MAC1LINK,
+ *     NULL,
+ * };
+ *
+ * static const struct aspeed_sig_desc sig_descs_GPIOA0_GPIOA0[] = { };
+ *
+ * static const struct aspeed_sig_expr sig_expr_GPIOA0_GPIOA0 = {
+ *     .signal = "GPIOA0",
+ *     .function = "GPIOA0",
+ *     .ndescs = ARRAY_SIZE(sig_descs_GPIOA0_GPIOA0),
+ *     .descs = &(sig_descs_GPIOA0_GPIOA0)[0],
+ * };
+ *
+ * static const struct aspeed_sig_expr *sig_exprs_GPIOA0_GPIOA0[] = {
+ *     &sig_expr_GPIOA0_GPIOA0,
+ *     NULL
+ * };
+ *
+ * static const struct aspeed_sig_expr **pin_exprs_0[] = {
+ *     sig_exprs_MAC1LINK_MAC1LINK,
+ *     sig_exprs_GPIOA0_GPIOA0,
+ *     NULL
+ * };
+ *
+ * static const struct aspeed_pin_desc pin_0 = { "0", (&pin_exprs_0[0]) };
+ * static const int group_pins_MAC1LINK[] = { 0 };
+ * static const char *func_groups_MAC1LINK[] = { "MAC1LINK" };
+ *
+ * static struct pinctrl_pin_desc aspeed_g4_pins[] = {
+ *     [0] = { .number = 0, .name = "D6", .drv_data = &pin_0 },
+ * };
+ *
+ * static const struct aspeed_pin_group aspeed_g4_groups[] = {
+ *     {
+ *         .name = "MAC1LINK",
+ *         .pins = &(group_pins_MAC1LINK)[0],
+ *         .npins = ARRAY_SIZE(group_pins_MAC1LINK),
+ *     },
+ * };
+ *
+ * static const struct aspeed_pin_function aspeed_g4_functions[] = {
+ *     {
+ *         .name = "MAC1LINK",
+ *         .groups = &func_groups_MAC1LINK[0],
+ *         .ngroups = ARRAY_SIZE(func_groups_MAC1LINK),
+ *     },
+ * };
+ * ```
+ *
+ * At the end of the day much of the above code is compressed into the
+ * following two lines:
+ *
+ * ```
+ * #define D6 0
+ * SSSF_PIN_DECL(D6, GPIOA0, MAC1LINK, SIG_DESC_SET(SCU80, 0));
+ * ```
+ *
+ * The two examples below show just the differences from the example above.
+ *
+ * Ball E18 demonstrates a function, EXTRST, that requires multiple descriptors
+ * be set for it to be muxed:
+ *
+ * ```
+ * static const struct aspeed_sig_desc sig_descs_EXTRST_EXTRST[] = {
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x3C,
+ *         .mask = BIT(3),
+ *         .enable = 1,
+ *         .disable = 0
+ *     },
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x80,
+ *         .mask = BIT(15),
+ *         .enable = 1,
+ *         .disable = 0
+ *     },
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x90,
+ *         .mask = BIT(31),
+ *         .enable = 0,
+ *         .disable = 1
+ *     },
+ * };
+ *
+ * static const struct aspeed_sig_expr sig_expr_EXTRST_EXTRST = {
+ *     .signal = "EXTRST",
+ *     .function = "EXTRST",
+ *     .ndescs = ARRAY_SIZE(sig_descs_EXTRST_EXTRST),
+ *     .descs = &(sig_descs_EXTRST_EXTRST)[0],
+ * };
+ * ...
+ * ```
+ *
+ * For ball E19, we have multiple functions enabling a single signal, LPCRST#.
+ * The data structures look like:
+ *
+ * static const struct aspeed_sig_desc sig_descs_LPCRST_LPCRST[] = {
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x80,
+ *         .mask = BIT(12),
+ *         .enable = 1,
+ *         .disable = 0
+ *     },
+ * };
+ *
+ * static const struct aspeed_sig_expr sig_expr_LPCRST_LPCRST = {
+ *     .signal = "LPCRST",
+ *     .function = "LPCRST",
+ *     .ndescs = ARRAY_SIZE(sig_descs_LPCRST_LPCRST),
+ *     .descs = &(sig_descs_LPCRST_LPCRST)[0],
+ * };
+ *
+ * static const struct aspeed_sig_desc sig_descs_LPCRST_LPCRSTS[] = {
+ *     {
+ *         .ip = ASPEED_IP_SCU,
+ *         .reg = 0x70,
+ *         .mask = BIT(14),
+ *         .enable = 1,
+ *         .disable = 0
+ *     },
+ * };
+ *
+ * static const struct aspeed_sig_expr sig_expr_LPCRST_LPCRSTS = {
+ *     .signal = "LPCRST",
+ *     .function = "LPCRSTS",
+ *     .ndescs = ARRAY_SIZE(sig_descs_LPCRST_LPCRSTS),
+ *     .descs = &(sig_descs_LPCRST_LPCRSTS)[0],
+ * };
+ *
+ * static const struct aspeed_sig_expr *sig_exprs_LPCRST_LPCRST[] = {
+ *     &sig_expr_LPCRST_LPCRST,
+ *     &sig_expr_LPCRST_LPCRSTS,
+ *     NULL,
+ * };
+ * ...
+ * ```
+ *
+ * Both expressions listed in the sig_exprs_LPCRST_LPCRST array need to be set
+ * to disabled for the associated GPIO to be muxed.
+ *
+ */
+
+#define ASPEED_IP_SCU           0
+#define ASPEED_IP_GFX           1
+#define ASPEED_IP_LPC           2
+#define ASPEED_NR_PINMUX_IPS    3
+
+ /**
+  * A signal descriptor, which describes the register, bits and the
+  * enable/disable values that should be compared or written.
+  *
+  * @ip: The IP block identifier, used as an index into the regmap array in
+  *      struct aspeed_pinctrl_data
+  * @reg: The register offset with respect to the base address of the IP block
+  * @mask: The mask to apply to the register. The lowest set bit of the mask is
+  *        used to derive the shift value.
+  * @enable: The value that enables the function. Value should be in the LSBs,
+  *          not at the position of the mask.
+  * @disable: The value that disables the function. Value should be in the
+  *           LSBs, not at the position of the mask.
+  */
+struct aspeed_sig_desc {
+        unsigned int ip;
+        unsigned int reg;
+        u32 mask;
+        u32 enable;
+        u32 disable;
+};
+
+/**
+ * Describes a signal expression. The expression is evaluated by ANDing the
+ * evaluation of the descriptors.
+ *
+ * @signal: The signal name for the priority level on the pin. If the signal
+ *          type is GPIO, then the signal name must begin with the string
+ *          "GPIO", e.g. GPIOA0, GPIOT4 etc.
+ * @function: The name of the function the signal participates in for the
+ *            associated expression
+ * @ndescs: The number of signal descriptors in the expression
+ * @descs: Pointer to an array of signal descriptors that comprise the
+ *         function expression
+ */
+struct aspeed_sig_expr {
+        const char *signal;
+        const char *function;
+        int ndescs;
+        const struct aspeed_sig_desc *descs;
+};
+
+/**
+ * A struct capturing the list of expressions enabling signals at each priority
+ * for a given pin. The signal configuration for a priority level is evaluated
+ * by ORing the evaluation of the signal expressions in the respective
+ * priority's list.
+ *
+ * @name: A name for the pin
+ * @prios: A pointer to an array of expression list pointers
+ *
+ */
+struct aspeed_pin_desc {
+        const char *name;
+        const struct aspeed_sig_expr ***prios;
+};
+
+/* Macro hell */
+
+#define SIG_DESC_IP_BIT(ip, reg, idx, val) \
+        { ip, reg, BIT_MASK(idx), val, (((val) + 1) & 1) }
+
+/**
+ * Short-hand macro for describing an SCU descriptor enabled by the state of
+ * one bit. The disable value is derived.
+ *
+ * @reg: The signal's associated register, offset from base
+ * @idx: The signal's bit index in the register
+ * @val: The value (0 or 1) that enables the function
+ */
+#define SIG_DESC_BIT(reg, idx, val) \
+        SIG_DESC_IP_BIT(ASPEED_IP_SCU, reg, idx, val)
+
+#define SIG_DESC_IP_SET(ip, reg, idx) SIG_DESC_IP_BIT(ip, reg, idx, 1)
+
+/**
+ * A further short-hand macro expanding to an SCU descriptor enabled by a set
+ * bit.
+ *
+ * @reg: The register, offset from base
+ * @idx: The bit index in the register
+ */
+#define SIG_DESC_SET(reg, idx) SIG_DESC_IP_BIT(ASPEED_IP_SCU, reg, idx, 1)
+
+#define SIG_DESC_LIST_SYM(sig, func) sig_descs_ ## sig ## _ ## func
+#define SIG_DESC_LIST_DECL(sig, func, ...) \
+        static const struct aspeed_sig_desc SIG_DESC_LIST_SYM(sig, func)[] = \
+                { __VA_ARGS__ }
+
+#define SIG_EXPR_SYM(sig, func) sig_expr_ ## sig ## _ ## func
+#define SIG_EXPR_DECL_(sig, func) \
+        static const struct aspeed_sig_expr SIG_EXPR_SYM(sig, func) = \
+        { \
+                .signal = #sig, \
+                .function = #func, \
+                .ndescs = ARRAY_SIZE(SIG_DESC_LIST_SYM(sig, func)), \
+                .descs = &(SIG_DESC_LIST_SYM(sig, func))[0], \
+        }
+
+/**
+ * Declare a signal expression.
+ *
+ * @sig: A macro symbol name for the signal (is subjected to stringification
+ *        and token pasting)
+ * @func: The function in which the signal is participating
+ * @...: Signal descriptors that define the signal expression
+ *
+ * For example, the following declares the ROMD8 signal for the ROM16 function:
+ *
+ *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
+ *
+ * And with multiple signal descriptors:
+ *
+ *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
+ *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
+ */
+#define SIG_EXPR_DECL(sig, func, ...) \
+        SIG_DESC_LIST_DECL(sig, func, __VA_ARGS__); \
+        SIG_EXPR_DECL_(sig, func)
+
+/**
+ * Declare a pointer to a signal expression
+ *
+ * @sig: The macro symbol name for the signal (subjected to token pasting)
+ * @func: The macro symbol name for the function (subjected to token pasting)
+ */
+#define SIG_EXPR_PTR(sig, func) (&SIG_EXPR_SYM(sig, func))
+
+#define SIG_EXPR_LIST_SYM(sig) sig_exprs_ ## sig
+
+/**
+ * Declare a signal expression list for reference in a struct aspeed_pin_prio.
+ *
+ * @sig: A macro symbol name for the signal (is subjected to token pasting)
+ * @...: Signal expression structure pointers (use SIG_EXPR_PTR())
+ *
+ * For example, the 16-bit ROM bus can be enabled by one of two possible signal
+ * expressions:
+ *
+ *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
+ *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
+ *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
+ *     SIG_EXPR_LIST_DECL(ROMD8, SIG_EXPR_PTR(ROMD8, ROM16),
+ *              SIG_EXPR_PTR(ROMD8, ROM16S));
+ */
+#define SIG_EXPR_LIST_DECL(sig, ...) \
+        static const struct aspeed_sig_expr *SIG_EXPR_LIST_SYM(sig)[] = \
+                { __VA_ARGS__, NULL }
+
+/**
+ * A short-hand macro for declaring a function expression and an expression
+ * list with a single function.
+ *
+ * @func: A macro symbol name for the function (is subjected to token pasting)
+ * @...: Function descriptors that define the function expression
+ *
+ * For example, signal NCTS6 participates in its own function with one group:
+ *
+ *     SIG_EXPR_LIST_DECL_SINGLE(NCTS6, NCTS6, SIG_DESC_SET(SCU90, 7));
+ */
+#define SIG_EXPR_LIST_DECL_SINGLE(sig, func, ...) \
+        SIG_DESC_LIST_DECL(sig, func, __VA_ARGS__); \
+        SIG_EXPR_DECL_(sig, func); \
+        SIG_EXPR_LIST_DECL(sig, SIG_EXPR_PTR(sig, func))
+
+#define SIG_EXPR_LIST_DECL_DUAL(sig, f0, f1) \
+        SIG_EXPR_LIST_DECL(sig, SIG_EXPR_PTR(sig, f0), SIG_EXPR_PTR(sig, f1))
+
+#define SIG_EXPR_LIST_PTR(sig) (&SIG_EXPR_LIST_SYM(sig)[0])
+
+#define PIN_EXPRS_SYM(pin) pin_exprs_ ## pin
+#define PIN_EXPRS_PTR(pin) (&PIN_EXPRS_SYM(pin)[0])
+#define PIN_SYM(pin) pin_ ## pin
+
+#define MS_PIN_DECL_(pin, ...) \
+        static const struct aspeed_sig_expr **PIN_EXPRS_SYM(pin)[] = \
+                { __VA_ARGS__, NULL }; \
+        static const struct aspeed_pin_desc PIN_SYM(pin) = \
+                { #pin, PIN_EXPRS_PTR(pin) }
+
+/**
+ * Declare a multi-signal pin
+ *
+ * @pin: The pin number
+ * @other: Macro name for "other" functionality (subjected to stringification)
+ * @high: Macro name for the highest priority signal functions
+ * @low: Macro name for the low signal functions
+ *
+ * For example:
+ *
+ *     #define A8 56
+ *     SIG_EXPR_DECL(ROMD8, ROM16, SIG_DESC_SET(SCU90, 6));
+ *     SIG_EXPR_DECL(ROMD8, ROM16S, SIG_DESC_SET(HW_STRAP1, 4),
+ *              { HW_STRAP1, GENMASK(1, 0), 0, 0 });
+ *     SIG_EXPR_LIST_DECL(ROMD8, SIG_EXPR_PTR(ROMD8, ROM16),
+ *              SIG_EXPR_PTR(ROMD8, ROM16S));
+ *     SIG_EXPR_LIST_DECL_SINGLE(NCTS6, NCTS6, SIG_DESC_SET(SCU90, 7));
+ *     MS_PIN_DECL(A8, GPIOH0, ROMD8, NCTS6);
+ */
+#define MS_PIN_DECL(pin, other, high, low) \
+        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
+        MS_PIN_DECL_(pin, \
+                        SIG_EXPR_LIST_PTR(high), \
+                        SIG_EXPR_LIST_PTR(low), \
+                        SIG_EXPR_LIST_PTR(other))
+
+#define PIN_GROUP_SYM(func) pins_ ## func
+#define FUNC_GROUP_SYM(func) groups_ ## func
+#define FUNC_GROUP_DECL(func, ...) \
+        static const int PIN_GROUP_SYM(func)[] = { __VA_ARGS__ }; \
+        static const char *FUNC_GROUP_SYM(func)[] = { #func }
+
+/**
+ * Declare a single signal pin
+ *
+ * @pin: The pin number
+ * @other: Macro name for "other" functionality (subjected to stringification)
+ * @sig: Macro name for the signal (subjected to stringification)
+ *
+ * For example:
+ *
+ *     #define E3 80
+ *     SIG_EXPR_LIST_DECL_SINGLE(SCL5, I2C5, I2C5_DESC);
+ *     SS_PIN_DECL(E3, GPIOK0, SCL5);
+ */
+#define SS_PIN_DECL(pin, other, sig) \
+        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
+        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(sig), SIG_EXPR_LIST_PTR(other))
+
+/**
+ * Single signal, single function pin declaration
+ *
+ * @pin: The pin number
+ * @other: Macro name for "other" functionality (subjected to stringification)
+ * @sig: Macro name for the signal (subjected to stringification)
+ * @...: Signal descriptors that define the function expression
+ *
+ * For example:
+ *
+ *    SSSF_PIN_DECL(A4, GPIOA2, TIMER3, SIG_DESC_SET(SCU80, 2));
+ */
+#define SSSF_PIN_DECL(pin, other, sig, ...) \
+        SIG_EXPR_LIST_DECL_SINGLE(sig, sig, __VA_ARGS__); \
+        SIG_EXPR_LIST_DECL_SINGLE(other, other); \
+        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(sig), SIG_EXPR_LIST_PTR(other)); \
+        FUNC_GROUP_DECL(sig, pin)
+
+#define GPIO_PIN_DECL(pin, gpio) \
+        SIG_EXPR_LIST_DECL_SINGLE(gpio, gpio); \
+        MS_PIN_DECL_(pin, SIG_EXPR_LIST_PTR(gpio))
+
+struct aspeed_pin_group {
+        const char *name;
+        const unsigned int *pins;
+        const unsigned int npins;
+};
+
+#define ASPEED_PINCTRL_GROUP(name_) { \
+        .name = #name_, \
+        .pins = &(PIN_GROUP_SYM(name_))[0], \
+        .npins = ARRAY_SIZE(PIN_GROUP_SYM(name_)), \
+}
+
+struct aspeed_pin_function {
+        const char *name;
+        const char *const *groups;
+        unsigned int ngroups;
+};
+
+#define ASPEED_PINCTRL_FUNC(name_, ...) { \
+        .name = #name_, \
+        .groups = &FUNC_GROUP_SYM(name_)[0], \
+        .ngroups = ARRAY_SIZE(FUNC_GROUP_SYM(name_)), \
+}
+
+struct aspeed_pinmux_data;
+
+struct aspeed_pinmux_ops {
+        int (*set)(const struct aspeed_pinmux_data *ctx,
+                   const struct aspeed_sig_expr *expr, bool enabled);
+};
+
+struct aspeed_pinmux_data {
+        struct regmap *maps[ASPEED_NR_PINMUX_IPS];
+
+        const struct aspeed_pinmux_ops *ops;
+
+        const struct aspeed_pin_group *groups;
+        const unsigned int ngroups;
+
+        const struct aspeed_pin_function *functions;
+        const unsigned int nfunctions;
+};
+
+int aspeed_sig_desc_eval(const struct aspeed_sig_desc *desc, bool enabled,
+                         struct regmap *map);
+
+int aspeed_sig_expr_eval(const struct aspeed_pinmux_data *ctx,
+                         const struct aspeed_sig_expr *expr,
+                         bool enabled);
+
+static inline int aspeed_sig_expr_set(const struct aspeed_pinmux_data *ctx,
+                                      const struct aspeed_sig_expr *expr,
+                                      bool enabled)
+{
+        return ctx->ops->set(ctx, expr, enabled);
+}
+
+#endif /* ASPEED_PINMUX_H */
diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig
index 97284c3f9e83..dcf7df797af7 100644
--- a/drivers/pinctrl/bcm/Kconfig
+++ b/drivers/pinctrl/bcm/Kconfig
@@ -18,11 +18,15 @@ config PINCTRL_BCM281XX
           framework.  GPIO is provided by a separate GPIO driver.
 
 config PINCTRL_BCM2835
-        bool
+        bool "Broadcom BCM2835 GPIO (with PINCONF) driver"
+        depends on OF && (ARCH_BCM2835 || ARCH_BRCMSTB || COMPILE_TEST)
         select PINMUX
         select PINCONF
         select GENERIC_PINCONF
         select GPIOLIB_IRQCHIP
+        default ARCH_BCM2835 || ARCH_BRCMSTB
+        help
+           Say Y here to enable the Broadcom BCM2835 GPIO driver.
 
 config PINCTRL_IPROC_GPIO
         bool "Broadcom iProc GPIO (with PINCONF) driver"
diff --git a/drivers/pinctrl/bcm/pinctrl-ns2-mux.c b/drivers/pinctrl/bcm/pinctrl-ns2-mux.c
index 4b5cf0e0f16e..2bf6af7df7d9 100644
--- a/drivers/pinctrl/bcm/pinctrl-ns2-mux.c
+++ b/drivers/pinctrl/bcm/pinctrl-ns2-mux.c
@@ -1048,6 +1048,8 @@ static int ns2_pinmux_probe(struct platform_device *pdev)
                 return PTR_ERR(pinctrl->base0);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res)
+                return -EINVAL;
         pinctrl->base1 = devm_ioremap_nocache(&pdev->dev, res->start,
                                         resource_size(res));
         if (!pinctrl->base1) {
diff --git a/drivers/pinctrl/cirrus/pinctrl-cs47l35.c b/drivers/pinctrl/cirrus/pinctrl-cs47l35.c
index 06b59160783d..53a8eab19aad 100644
--- a/drivers/pinctrl/cirrus/pinctrl-cs47l35.c
+++ b/drivers/pinctrl/cirrus/pinctrl-cs47l35.c
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Pinctrl for Cirrus Logic CS47L35
  *
  * Copyright (C) 2016-2017 Cirrus Logic
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by the
- * Free Software Foundation; version 2.
  */
 
 #include <linux/err.h>
diff --git a/drivers/pinctrl/cirrus/pinctrl-cs47l85.c b/drivers/pinctrl/cirrus/pinctrl-cs47l85.c
index 0a322e2a0fde..e08c7992d252 100644
--- a/drivers/pinctrl/cirrus/pinctrl-cs47l85.c
+++ b/drivers/pinctrl/cirrus/pinctrl-cs47l85.c
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Pinctrl for Cirrus Logic CS47L85
  *
  * Copyright (C) 2016-2017 Cirrus Logic
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by the
- * Free Software Foundation; version 2.
  */
 
 #include <linux/err.h>
diff --git a/drivers/pinctrl/cirrus/pinctrl-cs47l90.c b/drivers/pinctrl/cirrus/pinctrl-cs47l90.c
index fc38f579f492..3151f107adc4 100644
--- a/drivers/pinctrl/cirrus/pinctrl-cs47l90.c
+++ b/drivers/pinctrl/cirrus/pinctrl-cs47l90.c
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Pinctrl for Cirrus Logic CS47L90
  *
  * Copyright (C) 2016-2017 Cirrus Logic
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by the
- * Free Software Foundation; version 2.
  */
 
 #include <linux/err.h>
diff --git a/drivers/pinctrl/cirrus/pinctrl-madera-core.c b/drivers/pinctrl/cirrus/pinctrl-madera-core.c
index 7c9694593f79..c6b9f65f2362 100644
--- a/drivers/pinctrl/cirrus/pinctrl-madera-core.c
+++ b/drivers/pinctrl/cirrus/pinctrl-madera-core.c
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Pinctrl for Cirrus Logic Madera codecs
  *
  * Copyright (C) 2016-2018 Cirrus Logic
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by the
- * Free Software Foundation; version 2.
  */
 
 #include <linux/err.h>
diff --git a/drivers/pinctrl/cirrus/pinctrl-madera.h b/drivers/pinctrl/cirrus/pinctrl-madera.h
index 8000f4f832a1..4ae13918316f 100644
--- a/drivers/pinctrl/cirrus/pinctrl-madera.h
+++ b/drivers/pinctrl/cirrus/pinctrl-madera.h
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0
+/* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * Pinctrl for Cirrus Logic Madera codecs
  *
  * Copyright (C) 2016-2017 Cirrus Logic
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by the
- * Free Software Foundation; version 2.
  */
 
 #ifndef PINCTRL_MADERA_H
diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index a64849a9d1b0..b70df27874d1 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -98,7 +98,7 @@ EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
  */
 struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname)
 {
-        struct pinctrl_dev *pctldev = NULL;
+        struct pinctrl_dev *pctldev;
 
         if (!devname)
                 return NULL;
@@ -177,29 +177,6 @@ const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin)
         return desc->name;
 }
 
-/**
- * pin_is_valid() - check if pin exists on controller
- * @pctldev: the pin control device to check the pin on
- * @pin: pin to check, use the local pin controller index number
- *
- * This tells us whether a certain pin exist on a certain pin controller or
- * not. Pin lists may be sparse, so some pins may not exist.
- */
-bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
-{
-        struct pin_desc *pindesc;
-
-        if (pin < 0)
-                return false;
-
-        mutex_lock(&pctldev->mutex);
-        pindesc = pin_desc_get(pctldev, pin);
-        mutex_unlock(&pctldev->mutex);
-
-        return pindesc != NULL;
-}
-EXPORT_SYMBOL_GPL(pin_is_valid);
-
 /* Deletes a range of pin descriptors */
 static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
                                   const struct pinctrl_pin_desc *pins,
@@ -311,7 +288,7 @@ static inline int gpio_to_pin(struct pinctrl_gpio_range *range,
 static struct pinctrl_gpio_range *
 pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
 {
-        struct pinctrl_gpio_range *range = NULL;
+        struct pinctrl_gpio_range *range;
 
         mutex_lock(&pctldev->mutex);
         /* Loop over the ranges */
@@ -391,7 +368,7 @@ static int pinctrl_get_device_gpio_range(unsigned gpio,
                                          struct pinctrl_dev **outdev,
                                          struct pinctrl_gpio_range **outrange)
 {
-        struct pinctrl_dev *pctldev = NULL;
+        struct pinctrl_dev *pctldev;
 
         mutex_lock(&pinctrldev_list_mutex);
 
@@ -1215,6 +1192,15 @@ struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p,
 }
 EXPORT_SYMBOL_GPL(pinctrl_lookup_state);
 
+static void pinctrl_link_add(struct pinctrl_dev *pctldev,
+                             struct device *consumer)
+{
+        if (pctldev->desc->link_consumers)
+                device_link_add(consumer, pctldev->dev,
+                                DL_FLAG_PM_RUNTIME |
+                                DL_FLAG_AUTOREMOVE_CONSUMER);
+}
+
 /**
  * pinctrl_commit_state() - select/activate/program a pinctrl state to HW
  * @p: the pinctrl handle for the device that requests configuration
@@ -1260,6 +1246,10 @@ static int pinctrl_commit_state(struct pinctrl *p, struct pinctrl_state *state)
                 if (ret < 0) {
                         goto unapply_new_state;
                 }
+
+                /* Do not link hogs (circular dependency) */
+                if (p != setting->pctldev->p)
+                        pinctrl_link_add(setting->pctldev, p->dev);
         }
 
         p->state = state;
@@ -1665,7 +1655,7 @@ DEFINE_SHOW_ATTRIBUTE(pinctrl_groups);
 static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
 {
         struct pinctrl_dev *pctldev = s->private;
-        struct pinctrl_gpio_range *range = NULL;
+        struct pinctrl_gpio_range *range;
 
         seq_puts(s, "GPIO ranges handled:\n");
 
diff --git a/drivers/pinctrl/freescale/Kconfig b/drivers/pinctrl/freescale/Kconfig
index aeab0d9af23e..5f4058033ec6 100644
--- a/drivers/pinctrl/freescale/Kconfig
+++ b/drivers/pinctrl/freescale/Kconfig
@@ -130,6 +130,13 @@ config PINCTRL_IMX8MM
         help
           Say Y here to enable the imx8mm pinctrl driver
 
+config PINCTRL_IMX8MN
+        bool "IMX8MN pinctrl driver"
+        depends on ARCH_MXC && ARM64
+        select PINCTRL_IMX
+        help
+          Say Y here to enable the imx8mn pinctrl driver
+
 config PINCTRL_IMX8MQ
         bool "IMX8MQ pinctrl driver"
         depends on ARCH_MXC && ARM64
diff --git a/drivers/pinctrl/freescale/Makefile b/drivers/pinctrl/freescale/Makefile
index 02020a76bd9c..78e9140c13e3 100644
--- a/drivers/pinctrl/freescale/Makefile
+++ b/drivers/pinctrl/freescale/Makefile
@@ -19,6 +19,7 @@ obj-$(CONFIG_PINCTRL_IMX6UL)	+= pinctrl-imx6ul.o
 obj-$(CONFIG_PINCTRL_IMX7D)     += pinctrl-imx7d.o
 obj-$(CONFIG_PINCTRL_IMX7ULP)   += pinctrl-imx7ulp.o
 obj-$(CONFIG_PINCTRL_IMX8MM)    += pinctrl-imx8mm.o
+obj-$(CONFIG_PINCTRL_IMX8MN)    += pinctrl-imx8mn.o
 obj-$(CONFIG_PINCTRL_IMX8MQ)    += pinctrl-imx8mq.o
 obj-$(CONFIG_PINCTRL_IMX8QM)    += pinctrl-imx8qm.o
 obj-$(CONFIG_PINCTRL_IMX8QXP)   += pinctrl-imx8qxp.o
diff --git a/drivers/pinctrl/freescale/pinctrl-imx8mn.c b/drivers/pinctrl/freescale/pinctrl-imx8mn.c
new file mode 100644
index 000000000000..100ed8c1039a
--- /dev/null
+++ b/drivers/pinctrl/freescale/pinctrl-imx8mn.c
@@ -0,0 +1,348 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright 2018-2019 NXP
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/of.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/platform_device.h>
+
+#include "pinctrl-imx.h"
+
+enum imx8mn_pads {
+        MX8MN_PAD_RESERVE0 = 0,
+        MX8MN_PAD_RESERVE1 = 1,
+        MX8MN_PAD_RESERVE2 = 2,
+        MX8MN_PAD_RESERVE3 = 3,
+        MX8MN_PAD_RESERVE4 = 4,
+        MX8MN_PAD_RESERVE5 = 5,
+        MX8MN_PAD_RESERVE6 = 6,
+        MX8MN_PAD_RESERVE7 = 7,
+        MX8MN_IOMUXC_BOOT_MODE2 = 8,
+        MX8MN_IOMUXC_BOOT_MODE3 = 9,
+        MX8MN_IOMUXC_GPIO1_IO00 = 10,
+        MX8MN_IOMUXC_GPIO1_IO01 = 11,
+        MX8MN_IOMUXC_GPIO1_IO02 = 12,
+        MX8MN_IOMUXC_GPIO1_IO03 = 13,
+        MX8MN_IOMUXC_GPIO1_IO04 = 14,
+        MX8MN_IOMUXC_GPIO1_IO05 = 15,
+        MX8MN_IOMUXC_GPIO1_IO06 = 16,
+        MX8MN_IOMUXC_GPIO1_IO07 = 17,
+        MX8MN_IOMUXC_GPIO1_IO08 = 18,
+        MX8MN_IOMUXC_GPIO1_IO09 = 19,
+        MX8MN_IOMUXC_GPIO1_IO10 = 20,
+        MX8MN_IOMUXC_GPIO1_IO11 = 21,
+        MX8MN_IOMUXC_GPIO1_IO12 = 22,
+        MX8MN_IOMUXC_GPIO1_IO13 = 23,
+        MX8MN_IOMUXC_GPIO1_IO14 = 24,
+        MX8MN_IOMUXC_GPIO1_IO15 = 25,
+        MX8MN_IOMUXC_ENET_MDC = 26,
+        MX8MN_IOMUXC_ENET_MDIO = 27,
+        MX8MN_IOMUXC_ENET_TD3 = 28,
+        MX8MN_IOMUXC_ENET_TD2 = 29,
+        MX8MN_IOMUXC_ENET_TD1 = 30,
+        MX8MN_IOMUXC_ENET_TD0 = 31,
+        MX8MN_IOMUXC_ENET_TX_CTL = 32,
+        MX8MN_IOMUXC_ENET_TXC = 33,
+        MX8MN_IOMUXC_ENET_RX_CTL = 34,
+        MX8MN_IOMUXC_ENET_RXC = 35,
+        MX8MN_IOMUXC_ENET_RD0 = 36,
+        MX8MN_IOMUXC_ENET_RD1 = 37,
+        MX8MN_IOMUXC_ENET_RD2 = 38,
+        MX8MN_IOMUXC_ENET_RD3 = 39,
+        MX8MN_IOMUXC_SD1_CLK = 40,
+        MX8MN_IOMUXC_SD1_CMD = 41,
+        MX8MN_IOMUXC_SD1_DATA0 = 42,
+        MX8MN_IOMUXC_SD1_DATA1 = 43,
+        MX8MN_IOMUXC_SD1_DATA2 = 44,
+        MX8MN_IOMUXC_SD1_DATA3 = 45,
+        MX8MN_IOMUXC_SD1_DATA4 = 46,
+        MX8MN_IOMUXC_SD1_DATA5 = 47,
+        MX8MN_IOMUXC_SD1_DATA6 = 48,
+        MX8MN_IOMUXC_SD1_DATA7 = 49,
+        MX8MN_IOMUXC_SD1_RESET_B = 50,
+        MX8MN_IOMUXC_SD1_STROBE = 51,
+        MX8MN_IOMUXC_SD2_CD_B = 52,
+        MX8MN_IOMUXC_SD2_CLK = 53,
+        MX8MN_IOMUXC_SD2_CMD = 54,
+        MX8MN_IOMUXC_SD2_DATA0 = 55,
+        MX8MN_IOMUXC_SD2_DATA1 = 56,
+        MX8MN_IOMUXC_SD2_DATA2 = 57,
+        MX8MN_IOMUXC_SD2_DATA3 = 58,
+        MX8MN_IOMUXC_SD2_RESET_B = 59,
+        MX8MN_IOMUXC_SD2_WP = 60,
+        MX8MN_IOMUXC_NAND_ALE = 61,
+        MX8MN_IOMUXC_NAND_CE0 = 62,
+        MX8MN_IOMUXC_NAND_CE1 = 63,
+        MX8MN_IOMUXC_NAND_CE2 = 64,
+        MX8MN_IOMUXC_NAND_CE3 = 65,
+        MX8MN_IOMUXC_NAND_CLE = 66,
+        MX8MN_IOMUXC_NAND_DATA00 = 67,
+        MX8MN_IOMUXC_NAND_DATA01 = 68,
+        MX8MN_IOMUXC_NAND_DATA02 = 69,
+        MX8MN_IOMUXC_NAND_DATA03 = 70,
+        MX8MN_IOMUXC_NAND_DATA04 = 71,
+        MX8MN_IOMUXC_NAND_DATA05 = 72,
+        MX8MN_IOMUXC_NAND_DATA06 = 73,
+        MX8MN_IOMUXC_NAND_DATA07 = 74,
+        MX8MN_IOMUXC_NAND_DQS = 75,
+        MX8MN_IOMUXC_NAND_RE_B = 76,
+        MX8MN_IOMUXC_NAND_READY_B = 77,
+        MX8MN_IOMUXC_NAND_WE_B = 78,
+        MX8MN_IOMUXC_NAND_WP_B = 79,
+        MX8MN_IOMUXC_SAI5_RXFS = 80,
+        MX8MN_IOMUXC_SAI5_RXC = 81,
+        MX8MN_IOMUXC_SAI5_RXD0 = 82,
+        MX8MN_IOMUXC_SAI5_RXD1 = 83,
+        MX8MN_IOMUXC_SAI5_RXD2 = 84,
+        MX8MN_IOMUXC_SAI5_RXD3 = 85,
+        MX8MN_IOMUXC_SAI5_MCLK = 86,
+        MX8MN_IOMUXC_SAI1_RXFS = 87,
+        MX8MN_IOMUXC_SAI1_RXC = 88,
+        MX8MN_IOMUXC_SAI1_RXD0 = 89,
+        MX8MN_IOMUXC_SAI1_RXD1 = 90,
+        MX8MN_IOMUXC_SAI1_RXD2 = 91,
+        MX8MN_IOMUXC_SAI1_RXD3 = 92,
+        MX8MN_IOMUXC_SAI1_RXD4 = 93,
+        MX8MN_IOMUXC_SAI1_RXD5 = 94,
+        MX8MN_IOMUXC_SAI1_RXD6 = 95,
+        MX8MN_IOMUXC_SAI1_RXD7 = 96,
+        MX8MN_IOMUXC_SAI1_TXFS = 97,
+        MX8MN_IOMUXC_SAI1_TXC = 98,
+        MX8MN_IOMUXC_SAI1_TXD0 = 99,
+        MX8MN_IOMUXC_SAI1_TXD1 = 100,
+        MX8MN_IOMUXC_SAI1_TXD2 = 101,
+        MX8MN_IOMUXC_SAI1_TXD3 = 102,
+        MX8MN_IOMUXC_SAI1_TXD4 = 103,
+        MX8MN_IOMUXC_SAI1_TXD5 = 104,
+        MX8MN_IOMUXC_SAI1_TXD6 = 105,
+        MX8MN_IOMUXC_SAI1_TXD7 = 106,
+        MX8MN_IOMUXC_SAI1_MCLK = 107,
+        MX8MN_IOMUXC_SAI2_RXFS = 108,
+        MX8MN_IOMUXC_SAI2_RXC = 109,
+        MX8MN_IOMUXC_SAI2_RXD0 = 110,
+        MX8MN_IOMUXC_SAI2_TXFS = 111,
+        MX8MN_IOMUXC_SAI2_TXC = 112,
+        MX8MN_IOMUXC_SAI2_TXD0 = 113,
+        MX8MN_IOMUXC_SAI2_MCLK = 114,
+        MX8MN_IOMUXC_SAI3_RXFS = 115,
+        MX8MN_IOMUXC_SAI3_RXC = 116,
+        MX8MN_IOMUXC_SAI3_RXD = 117,
+        MX8MN_IOMUXC_SAI3_TXFS = 118,
+        MX8MN_IOMUXC_SAI3_TXC = 119,
+        MX8MN_IOMUXC_SAI3_TXD = 120,
+        MX8MN_IOMUXC_SAI3_MCLK = 121,
+        MX8MN_IOMUXC_SPDIF_TX = 122,
+        MX8MN_IOMUXC_SPDIF_RX = 123,
+        MX8MN_IOMUXC_SPDIF_EXT_CLK = 124,
+        MX8MN_IOMUXC_ECSPI1_SCLK = 125,
+        MX8MN_IOMUXC_ECSPI1_MOSI = 126,
+        MX8MN_IOMUXC_ECSPI1_MISO = 127,
+        MX8MN_IOMUXC_ECSPI1_SS0 = 128,
+        MX8MN_IOMUXC_ECSPI2_SCLK = 129,
+        MX8MN_IOMUXC_ECSPI2_MOSI = 130,
+        MX8MN_IOMUXC_ECSPI2_MISO = 131,
+        MX8MN_IOMUXC_ECSPI2_SS0 = 132,
+        MX8MN_IOMUXC_I2C1_SCL = 133,
+        MX8MN_IOMUXC_I2C1_SDA = 134,
+        MX8MN_IOMUXC_I2C2_SCL = 135,
+        MX8MN_IOMUXC_I2C2_SDA = 136,
+        MX8MN_IOMUXC_I2C3_SCL = 137,
+        MX8MN_IOMUXC_I2C3_SDA = 138,
+        MX8MN_IOMUXC_I2C4_SCL = 139,
+        MX8MN_IOMUXC_I2C4_SDA = 140,
+        MX8MN_IOMUXC_UART1_RXD = 141,
+        MX8MN_IOMUXC_UART1_TXD = 142,
+        MX8MN_IOMUXC_UART2_RXD = 143,
+        MX8MN_IOMUXC_UART2_TXD = 144,
+        MX8MN_IOMUXC_UART3_RXD = 145,
+        MX8MN_IOMUXC_UART3_TXD = 146,
+        MX8MN_IOMUXC_UART4_RXD = 147,
+        MX8MN_IOMUXC_UART4_TXD = 148,
+};
+
+/* Pad names for the pinmux subsystem */
+static const struct pinctrl_pin_desc imx8mn_pinctrl_pads[] = {
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE0),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE1),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE2),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE3),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE4),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE5),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE6),
+        IMX_PINCTRL_PIN(MX8MN_PAD_RESERVE7),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_BOOT_MODE2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_BOOT_MODE3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO00),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO01),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO02),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO03),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO04),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO05),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO06),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO07),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO08),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO09),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO10),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO11),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO12),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO13),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO14),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_GPIO1_IO15),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_MDC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_MDIO),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TD3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TD2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TD1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TX_CTL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_TXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RX_CTL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RD1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RD2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ENET_RD3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_CLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_CMD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA4),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA5),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA6),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_DATA7),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_RESET_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD1_STROBE),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_CD_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_CLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_CMD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_DATA0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_DATA1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_DATA2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_DATA3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_RESET_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SD2_WP),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_ALE),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_CE0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_CE1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_CE2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_CE3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_CLE),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA00),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA01),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA02),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA03),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA04),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA05),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA06),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DATA07),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_DQS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_RE_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_READY_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_WE_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_NAND_WP_B),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXD1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXD2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_RXD3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI5_MCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD4),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD5),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD6),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_RXD7),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD1),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD2),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD3),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD4),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD5),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD6),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_TXD7),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI1_MCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_RXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_RXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_RXD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_TXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_TXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_TXD0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI2_MCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_RXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_RXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_RXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_TXFS),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_TXC),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_TXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SAI3_MCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SPDIF_TX),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SPDIF_RX),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_SPDIF_EXT_CLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI1_SCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI1_MOSI),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI1_MISO),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI1_SS0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI2_SCLK),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI2_MOSI),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI2_MISO),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_ECSPI2_SS0),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C1_SCL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C1_SDA),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C2_SCL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C2_SDA),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C3_SCL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C3_SDA),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C4_SCL),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_I2C4_SDA),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART1_RXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART1_TXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART2_RXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART2_TXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART3_RXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART3_TXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART4_RXD),
+        IMX_PINCTRL_PIN(MX8MN_IOMUXC_UART4_TXD),
+};
+
+static struct imx_pinctrl_soc_info imx8mn_pinctrl_info = {
+        .pins = imx8mn_pinctrl_pads,
+        .npins = ARRAY_SIZE(imx8mn_pinctrl_pads),
+        .gpr_compatible = "fsl,imx8mn-iomuxc-gpr",
+};
+
+static const struct of_device_id imx8mn_pinctrl_of_match[] = {
+        { .compatible = "fsl,imx8mn-iomuxc", .data = &imx8mn_pinctrl_info, },
+        { /* sentinel */ }
+};
+
+static int imx8mn_pinctrl_probe(struct platform_device *pdev)
+{
+        return imx_pinctrl_probe(pdev, &imx8mn_pinctrl_info);
+}
+
+static struct platform_driver imx8mn_pinctrl_driver = {
+        .driver = {
+                .name = "imx8mn-pinctrl",
+                .of_match_table = of_match_ptr(imx8mn_pinctrl_of_match),
+                .suppress_bind_attrs = true,
+        },
+        .probe = imx8mn_pinctrl_probe,
+};
+
+static int __init imx8mn_pinctrl_init(void)
+{
+        return platform_driver_register(&imx8mn_pinctrl_driver);
+}
+arch_initcall(imx8mn_pinctrl_init);
diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c
index 18d9ad504194..e5a112a8e067 100644
--- a/drivers/pinctrl/intel/pinctrl-baytrail.c
+++ b/drivers/pinctrl/intel/pinctrl-baytrail.c
@@ -24,6 +24,8 @@
 #include <linux/pinctrl/pinconf.h>
 #include <linux/pinctrl/pinconf-generic.h>
 
+#include "pinctrl-intel.h"
+
 /* memory mapped register offsets */
 #define BYT_CONF0_REG           0x000
 #define BYT_CONF1_REG           0x004
@@ -35,6 +37,7 @@
 /* BYT_CONF0_REG register bits */
 #define BYT_IODEN               BIT(31)
 #define BYT_DIRECT_IRQ_EN       BIT(27)
+#define BYT_TRIG_MASK           GENMASK(26, 24)
 #define BYT_TRIG_NEG            BIT(26)
 #define BYT_TRIG_POS            BIT(25)
 #define BYT_TRIG_LVL            BIT(24)
@@ -43,31 +46,28 @@
 #define BYT_GLITCH_F_SLOW_CLK   BIT(17)
 #define BYT_GLITCH_F_FAST_CLK   BIT(16)
 #define BYT_PULL_STR_SHIFT      9
-#define BYT_PULL_STR_MASK       (3 << BYT_PULL_STR_SHIFT)
+#define BYT_PULL_STR_MASK       GENMASK(10, 9)
 #define BYT_PULL_STR_2K         (0 << BYT_PULL_STR_SHIFT)
 #define BYT_PULL_STR_10K        (1 << BYT_PULL_STR_SHIFT)
 #define BYT_PULL_STR_20K        (2 << BYT_PULL_STR_SHIFT)
 #define BYT_PULL_STR_40K        (3 << BYT_PULL_STR_SHIFT)
 #define BYT_PULL_ASSIGN_SHIFT   7
-#define BYT_PULL_ASSIGN_MASK    (3 << BYT_PULL_ASSIGN_SHIFT)
+#define BYT_PULL_ASSIGN_MASK    GENMASK(8, 7)
 #define BYT_PULL_ASSIGN_UP      (1 << BYT_PULL_ASSIGN_SHIFT)
 #define BYT_PULL_ASSIGN_DOWN    (2 << BYT_PULL_ASSIGN_SHIFT)
-#define BYT_PIN_MUX             0x07
+#define BYT_PIN_MUX             GENMASK(2, 0)
 
 /* BYT_VAL_REG register bits */
+#define BYT_DIR_MASK            GENMASK(2, 1)
 #define BYT_INPUT_EN            BIT(2)  /* 0: input enabled (active low)*/
 #define BYT_OUTPUT_EN           BIT(1)  /* 0: output enabled (active low)*/
 #define BYT_LEVEL               BIT(0)
 
-#define BYT_DIR_MASK            (BIT(1) | BIT(2))
-#define BYT_TRIG_MASK           (BIT(26) | BIT(25) | BIT(24))
-
-#define BYT_CONF0_RESTORE_MASK  (BYT_DIRECT_IRQ_EN | BYT_TRIG_MASK | \
-                                 BYT_PIN_MUX)
+#define BYT_CONF0_RESTORE_MASK  (BYT_DIRECT_IRQ_EN | BYT_TRIG_MASK | BYT_PIN_MUX)
 #define BYT_VAL_RESTORE_MASK    (BYT_DIR_MASK | BYT_LEVEL)
 
 /* BYT_DEBOUNCE_REG bits */
-#define BYT_DEBOUNCE_PULSE_MASK         0x7
+#define BYT_DEBOUNCE_PULSE_MASK         GENMASK(2, 0)
 #define BYT_DEBOUNCE_PULSE_375US        1
 #define BYT_DEBOUNCE_PULSE_750US        2
 #define BYT_DEBOUNCE_PULSE_1500US       3
@@ -91,40 +91,13 @@
  * does not find a match for the requested function.
  */
 #define BYT_DEFAULT_GPIO_MUX    0
+#define BYT_ALTER_GPIO_MUX      1
 
 struct byt_gpio_pin_context {
         u32 conf0;
         u32 val;
 };
 
-struct byt_simple_func_mux {
-        const char *name;
-        unsigned short func;
-};
-
-struct byt_mixed_func_mux {
-        const char *name;
-        const unsigned short *func_values;
-};
-
-struct byt_pingroup {
-        const char *name;
-        const unsigned int *pins;
-        size_t npins;
-        unsigned short has_simple_funcs;
-        union {
-                const struct byt_simple_func_mux *simple_funcs;
-                const struct byt_mixed_func_mux *mixed_funcs;
-        };
-        size_t nfuncs;
-};
-
-struct byt_function {
-        const char *name;
-        const char * const *groups;
-        size_t ngroups;
-};
-
 struct byt_community {
         unsigned int pin_base;
         size_t npins;
@@ -132,47 +105,6 @@ struct byt_community {
         void __iomem *reg_base;
 };
 
-#define SIMPLE_FUNC(n, f)       \
-        {                       \
-                .name   = (n),  \
-                .func   = (f),  \
-        }
-#define MIXED_FUNC(n, f)                \
-        {                               \
-                .name           = (n),  \
-                .func_values    = (f),  \
-        }
-
-#define PIN_GROUP_SIMPLE(n, p, f)                               \
-        {                                                       \
-                .name                   = (n),                  \
-                .pins                   = (p),                  \
-                .npins                  = ARRAY_SIZE((p)),      \
-                .has_simple_funcs       = 1,                    \
-                {                                               \
-                        .simple_funcs           = (f),          \
-                },                                              \
-                .nfuncs                 = ARRAY_SIZE((f)),      \
-        }
-#define PIN_GROUP_MIXED(n, p, f)                                \
-        {                                                       \
-                .name                   = (n),                  \
-                .pins                   = (p),                  \
-                .npins                  = ARRAY_SIZE((p)),      \
-                .has_simple_funcs       = 0,                    \
-                {                                               \
-                        .mixed_funcs            = (f),          \
-                },                                              \
-                .nfuncs                 = ARRAY_SIZE((f)),      \
-        }
-
-#define FUNCTION(n, g)                                  \
-        {                                               \
-                .name           = (n),                  \
-                .groups         = (g),                  \
-                .ngroups        = ARRAY_SIZE((g)),      \
-        }
-
 #define COMMUNITY(p, n, map)            \
         {                               \
                 .pin_base       = (p),  \
@@ -184,9 +116,9 @@ struct byt_pinctrl_soc_data {
         const char *uid;
         const struct pinctrl_pin_desc *pins;
         size_t npins;
-        const struct byt_pingroup *groups;
+        const struct intel_pingroup *groups;
         size_t ngroups;
-        const struct byt_function *functions;
+        const struct intel_function *functions;
         size_t nfunctions;
         const struct byt_community *communities;
         size_t ncommunities;
@@ -326,20 +258,11 @@ static const unsigned int byt_score_pins_map[BYT_NGPIO_SCORE] = {
 /* SCORE groups */
 static const unsigned int byt_score_uart1_pins[] = { 70, 71, 72, 73 };
 static const unsigned int byt_score_uart2_pins[] = { 74, 75, 76, 77 };
-static const struct byt_simple_func_mux byt_score_uart_mux[] = {
-        SIMPLE_FUNC("uart", 1),
-};
 
 static const unsigned int byt_score_pwm0_pins[] = { 94 };
 static const unsigned int byt_score_pwm1_pins[] = { 95 };
-static const struct byt_simple_func_mux byt_score_pwm_mux[] = {
-        SIMPLE_FUNC("pwm", 1),
-};
 
 static const unsigned int byt_score_sio_spi_pins[] = { 66, 67, 68, 69 };
-static const struct byt_simple_func_mux byt_score_spi_mux[] = {
-        SIMPLE_FUNC("spi", 1),
-};
 
 static const unsigned int byt_score_i2c5_pins[] = { 88, 89 };
 static const unsigned int byt_score_i2c6_pins[] = { 90, 91 };
@@ -348,50 +271,29 @@ static const unsigned int byt_score_i2c3_pins[] = { 84, 85 };
 static const unsigned int byt_score_i2c2_pins[] = { 82, 83 };
 static const unsigned int byt_score_i2c1_pins[] = { 80, 81 };
 static const unsigned int byt_score_i2c0_pins[] = { 78, 79 };
-static const struct byt_simple_func_mux byt_score_i2c_mux[] = {
-        SIMPLE_FUNC("i2c", 1),
-};
 
 static const unsigned int byt_score_ssp0_pins[] = { 8, 9, 10, 11 };
 static const unsigned int byt_score_ssp1_pins[] = { 12, 13, 14, 15 };
 static const unsigned int byt_score_ssp2_pins[] = { 62, 63, 64, 65 };
-static const struct byt_simple_func_mux byt_score_ssp_mux[] = {
-        SIMPLE_FUNC("ssp", 1),
-};
 
 static const unsigned int byt_score_sdcard_pins[] = {
         7, 33, 34, 35, 36, 37, 38, 39, 40, 41,
 };
-static const unsigned short byt_score_sdcard_mux_values[] = {
+static const unsigned int byt_score_sdcard_mux_values[] = {
         2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 };
-static const struct byt_mixed_func_mux byt_score_sdcard_mux[] = {
-        MIXED_FUNC("sdcard", byt_score_sdcard_mux_values),
-};
 
 static const unsigned int byt_score_sdio_pins[] = { 27, 28, 29, 30, 31, 32 };
-static const struct byt_simple_func_mux byt_score_sdio_mux[] = {
-        SIMPLE_FUNC("sdio", 1),
-};
 
 static const unsigned int byt_score_emmc_pins[] = {
         16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
 };
-static const struct byt_simple_func_mux byt_score_emmc_mux[] = {
-        SIMPLE_FUNC("emmc", 1),
-};
 
 static const unsigned int byt_score_ilb_lpc_pins[] = {
         42, 43, 44, 45, 46, 47, 48, 49, 50,
 };
-static const struct byt_simple_func_mux byt_score_lpc_mux[] = {
-        SIMPLE_FUNC("lpc", 1),
-};
 
 static const unsigned int byt_score_sata_pins[] = { 0, 1, 2 };
-static const struct byt_simple_func_mux byt_score_sata_mux[] = {
-        SIMPLE_FUNC("sata", 1),
-};
 
 static const unsigned int byt_score_plt_clk0_pins[] = { 96 };
 static const unsigned int byt_score_plt_clk1_pins[] = { 97 };
@@ -399,70 +301,37 @@ static const unsigned int byt_score_plt_clk2_pins[] = { 98 };
 static const unsigned int byt_score_plt_clk3_pins[] = { 99 };
 static const unsigned int byt_score_plt_clk4_pins[] = { 100 };
 static const unsigned int byt_score_plt_clk5_pins[] = { 101 };
-static const struct byt_simple_func_mux byt_score_plt_clk_mux[] = {
-        SIMPLE_FUNC("plt_clk", 1),
-};
 
 static const unsigned int byt_score_smbus_pins[] = { 51, 52, 53 };
-static const struct byt_simple_func_mux byt_score_smbus_mux[] = {
-        SIMPLE_FUNC("smbus", 1),
-};
 
-static const struct byt_pingroup byt_score_groups[] = {
-        PIN_GROUP_SIMPLE("uart1_grp",
-                         byt_score_uart1_pins, byt_score_uart_mux),
-        PIN_GROUP_SIMPLE("uart2_grp",
-                         byt_score_uart2_pins, byt_score_uart_mux),
-        PIN_GROUP_SIMPLE("pwm0_grp",
-                         byt_score_pwm0_pins, byt_score_pwm_mux),
-        PIN_GROUP_SIMPLE("pwm1_grp",
-                         byt_score_pwm1_pins, byt_score_pwm_mux),
-        PIN_GROUP_SIMPLE("ssp2_grp",
-                         byt_score_ssp2_pins, byt_score_pwm_mux),
-        PIN_GROUP_SIMPLE("sio_spi_grp",
-                         byt_score_sio_spi_pins, byt_score_spi_mux),
-        PIN_GROUP_SIMPLE("i2c5_grp",
-                         byt_score_i2c5_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c6_grp",
-                         byt_score_i2c6_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c4_grp",
-                         byt_score_i2c4_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c3_grp",
-                         byt_score_i2c3_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c2_grp",
-                         byt_score_i2c2_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c1_grp",
-                         byt_score_i2c1_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("i2c0_grp",
-                         byt_score_i2c0_pins, byt_score_i2c_mux),
-        PIN_GROUP_SIMPLE("ssp0_grp",
-                         byt_score_ssp0_pins, byt_score_ssp_mux),
-        PIN_GROUP_SIMPLE("ssp1_grp",
-                         byt_score_ssp1_pins, byt_score_ssp_mux),
-        PIN_GROUP_MIXED("sdcard_grp",
-                        byt_score_sdcard_pins, byt_score_sdcard_mux),
-        PIN_GROUP_SIMPLE("sdio_grp",
-                         byt_score_sdio_pins, byt_score_sdio_mux),
-        PIN_GROUP_SIMPLE("emmc_grp",
-                         byt_score_emmc_pins, byt_score_emmc_mux),
-        PIN_GROUP_SIMPLE("lpc_grp",
-                         byt_score_ilb_lpc_pins, byt_score_lpc_mux),
-        PIN_GROUP_SIMPLE("sata_grp",
-                         byt_score_sata_pins, byt_score_sata_mux),
-        PIN_GROUP_SIMPLE("plt_clk0_grp",
-                         byt_score_plt_clk0_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("plt_clk1_grp",
-                         byt_score_plt_clk1_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("plt_clk2_grp",
-                         byt_score_plt_clk2_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("plt_clk3_grp",
-                         byt_score_plt_clk3_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("plt_clk4_grp",
-                         byt_score_plt_clk4_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("plt_clk5_grp",
-                         byt_score_plt_clk5_pins, byt_score_plt_clk_mux),
-        PIN_GROUP_SIMPLE("smbus_grp",
-                         byt_score_smbus_pins, byt_score_smbus_mux),
+static const struct intel_pingroup byt_score_groups[] = {
+        PIN_GROUP("uart1_grp", byt_score_uart1_pins, 1),
+        PIN_GROUP("uart2_grp", byt_score_uart2_pins, 1),
+        PIN_GROUP("pwm0_grp", byt_score_pwm0_pins, 1),
+        PIN_GROUP("pwm1_grp", byt_score_pwm1_pins, 1),
+        PIN_GROUP("ssp2_grp", byt_score_ssp2_pins, 1),
+        PIN_GROUP("sio_spi_grp", byt_score_sio_spi_pins, 1),
+        PIN_GROUP("i2c5_grp", byt_score_i2c5_pins, 1),
+        PIN_GROUP("i2c6_grp", byt_score_i2c6_pins, 1),
+        PIN_GROUP("i2c4_grp", byt_score_i2c4_pins, 1),
+        PIN_GROUP("i2c3_grp", byt_score_i2c3_pins, 1),
+        PIN_GROUP("i2c2_grp", byt_score_i2c2_pins, 1),
+        PIN_GROUP("i2c1_grp", byt_score_i2c1_pins, 1),
+        PIN_GROUP("i2c0_grp", byt_score_i2c0_pins, 1),
+        PIN_GROUP("ssp0_grp", byt_score_ssp0_pins, 1),
+        PIN_GROUP("ssp1_grp", byt_score_ssp1_pins, 1),
+        PIN_GROUP("sdcard_grp", byt_score_sdcard_pins, byt_score_sdcard_mux_values),
+        PIN_GROUP("sdio_grp", byt_score_sdio_pins, 1),
+        PIN_GROUP("emmc_grp", byt_score_emmc_pins, 1),
+        PIN_GROUP("lpc_grp", byt_score_ilb_lpc_pins, 1),
+        PIN_GROUP("sata_grp", byt_score_sata_pins, 1),
+        PIN_GROUP("plt_clk0_grp", byt_score_plt_clk0_pins, 1),
+        PIN_GROUP("plt_clk1_grp", byt_score_plt_clk1_pins, 1),
+        PIN_GROUP("plt_clk2_grp", byt_score_plt_clk2_pins, 1),
+        PIN_GROUP("plt_clk3_grp", byt_score_plt_clk3_pins, 1),
+        PIN_GROUP("plt_clk4_grp", byt_score_plt_clk4_pins, 1),
+        PIN_GROUP("plt_clk5_grp", byt_score_plt_clk5_pins, 1),
+        PIN_GROUP("smbus_grp", byt_score_smbus_pins, 1),
 };
 
 static const char * const byt_score_uart_groups[] = {
@@ -496,10 +365,9 @@ static const char * const byt_score_gpio_groups[] = {
         "sdcard_grp", "sdio_grp", "emmc_grp", "lpc_grp", "sata_grp",
         "plt_clk0_grp", "plt_clk1_grp", "plt_clk2_grp", "plt_clk3_grp",
         "plt_clk4_grp", "plt_clk5_grp", "smbus_grp",
-
 };
 
-static const struct byt_function byt_score_functions[] = {
+static const struct intel_function byt_score_functions[] = {
         FUNCTION("uart", byt_score_uart_groups),
         FUNCTION("pwm", byt_score_pwm_groups),
         FUNCTION("ssp", byt_score_ssp_groups),
@@ -588,38 +456,30 @@ static const unsigned int byt_sus_pins_map[BYT_NGPIO_SUS] = {
 };
 
 static const unsigned int byt_sus_usb_over_current_pins[] = { 19, 20 };
-static const struct byt_simple_func_mux byt_sus_usb_oc_mux[] = {
-        SIMPLE_FUNC("usb", 0),
-        SIMPLE_FUNC("gpio", 1),
-};
+static const unsigned int byt_sus_usb_over_current_mode_values[] = { 0, 0 };
+static const unsigned int byt_sus_usb_over_current_gpio_mode_values[] = { 1, 1 };
 
 static const unsigned int byt_sus_usb_ulpi_pins[] = {
         14, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 };
-static const unsigned short byt_sus_usb_ulpi_mode_values[] = {
+static const unsigned int byt_sus_usb_ulpi_mode_values[] = {
         2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 };
-static const unsigned short byt_sus_usb_ulpi_gpio_mode_values[] = {
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-static const struct byt_mixed_func_mux byt_sus_usb_ulpi_mux[] = {
-        MIXED_FUNC("usb", byt_sus_usb_ulpi_mode_values),
-        MIXED_FUNC("gpio", byt_sus_usb_ulpi_gpio_mode_values),
+static const unsigned int byt_sus_usb_ulpi_gpio_mode_values[] = {
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 
 static const unsigned int byt_sus_pcu_spi_pins[] = { 21 };
-static const struct byt_simple_func_mux byt_sus_pcu_spi_mux[] = {
-        SIMPLE_FUNC("spi", 0),
-        SIMPLE_FUNC("gpio", 1),
-};
+static const unsigned int byt_sus_pcu_spi_mode_values[] = { 0 };
+static const unsigned int byt_sus_pcu_spi_gpio_mode_values[] = { 1 };
 
-static const struct byt_pingroup byt_sus_groups[] = {
-        PIN_GROUP_SIMPLE("usb_oc_grp",
-                        byt_sus_usb_over_current_pins, byt_sus_usb_oc_mux),
-        PIN_GROUP_MIXED("usb_ulpi_grp",
-                        byt_sus_usb_ulpi_pins, byt_sus_usb_ulpi_mux),
-        PIN_GROUP_SIMPLE("pcu_spi_grp",
-                        byt_sus_pcu_spi_pins, byt_sus_pcu_spi_mux),
+static const struct intel_pingroup byt_sus_groups[] = {
+        PIN_GROUP("usb_oc_grp", byt_sus_usb_over_current_pins, byt_sus_usb_over_current_mode_values),
+        PIN_GROUP("usb_ulpi_grp", byt_sus_usb_ulpi_pins, byt_sus_usb_ulpi_mode_values),
+        PIN_GROUP("pcu_spi_grp", byt_sus_pcu_spi_pins, byt_sus_pcu_spi_mode_values),
+        PIN_GROUP("usb_oc_grp_gpio", byt_sus_usb_over_current_pins, byt_sus_usb_over_current_gpio_mode_values),
+        PIN_GROUP("usb_ulpi_grp_gpio", byt_sus_usb_ulpi_pins, byt_sus_usb_ulpi_gpio_mode_values),
+        PIN_GROUP("pcu_spi_grp_gpio", byt_sus_pcu_spi_pins, byt_sus_pcu_spi_gpio_mode_values),
 };
 
 static const char * const byt_sus_usb_groups[] = {
@@ -627,10 +487,10 @@ static const char * const byt_sus_usb_groups[] = {
 };
 static const char * const byt_sus_spi_groups[] = { "pcu_spi_grp" };
 static const char * const byt_sus_gpio_groups[] = {
-        "usb_oc_grp", "usb_ulpi_grp", "pcu_spi_grp",
+        "usb_oc_grp_gpio", "usb_ulpi_grp_gpio", "pcu_spi_grp_gpio",
 };
 
-static const struct byt_function byt_sus_functions[] = {
+static const struct intel_function byt_sus_functions[] = {
         FUNCTION("usb", byt_sus_usb_groups),
         FUNCTION("spi", byt_sus_spi_groups),
         FUNCTION("gpio", byt_sus_gpio_groups),
@@ -810,41 +670,9 @@ static int byt_get_function_groups(struct pinctrl_dev *pctldev,
         return 0;
 }
 
-static int byt_get_group_simple_mux(const struct byt_pingroup group,
-                                    const char *func_name,
-                                    unsigned short *func)
-{
-        int i;
-
-        for (i = 0; i < group.nfuncs; i++) {
-                if (!strcmp(group.simple_funcs[i].name, func_name)) {
-                        *func = group.simple_funcs[i].func;
-                        return 0;
-                }
-        }
-
-        return 1;
-}
-
-static int byt_get_group_mixed_mux(const struct byt_pingroup group,
-                                   const char *func_name,
-                                   const unsigned short **func)
-{
-        int i;
-
-        for (i = 0; i < group.nfuncs; i++) {
-                if (!strcmp(group.mixed_funcs[i].name, func_name)) {
-                        *func = group.mixed_funcs[i].func_values;
-                        return 0;
-                }
-        }
-
-        return 1;
-}
-
 static void byt_set_group_simple_mux(struct byt_gpio *vg,
-                                     const struct byt_pingroup group,
-                                     unsigned short func)
+                                     const struct intel_pingroup group,
+                                     unsigned int func)
 {
         unsigned long flags;
         int i;
@@ -873,8 +701,8 @@ static void byt_set_group_simple_mux(struct byt_gpio *vg,
 }
 
 static void byt_set_group_mixed_mux(struct byt_gpio *vg,
-                                    const struct byt_pingroup group,
-                                    const unsigned short *func)
+                                    const struct intel_pingroup group,
+                                    const unsigned int *func)
 {
         unsigned long flags;
         int i;
@@ -906,23 +734,15 @@ static int byt_set_mux(struct pinctrl_dev *pctldev, unsigned int func_selector,
                        unsigned int group_selector)
 {
         struct byt_gpio *vg = pinctrl_dev_get_drvdata(pctldev);
-        const struct byt_function func = vg->soc_data->functions[func_selector];
-        const struct byt_pingroup group = vg->soc_data->groups[group_selector];
-        const unsigned short *mixed_func;
-        unsigned short simple_func;
-        int ret = 1;
-
-        if (group.has_simple_funcs)
-                ret = byt_get_group_simple_mux(group, func.name, &simple_func);
-        else
-                ret = byt_get_group_mixed_mux(group, func.name, &mixed_func);
+        const struct intel_function func = vg->soc_data->functions[func_selector];
+        const struct intel_pingroup group = vg->soc_data->groups[group_selector];
 
-        if (ret)
+        if (group.modes)
+                byt_set_group_mixed_mux(vg, group, group.modes);
+        else if (!strcmp(func.name, "gpio"))
                 byt_set_group_simple_mux(vg, group, BYT_DEFAULT_GPIO_MUX);
-        else if (group.has_simple_funcs)
-                byt_set_group_simple_mux(vg, group, simple_func);
         else
-                byt_set_group_mixed_mux(vg, group, mixed_func);
+                byt_set_group_simple_mux(vg, group, group.mode);
 
         return 0;
 }
@@ -932,14 +752,14 @@ static u32 byt_get_gpio_mux(struct byt_gpio *vg, unsigned int offset)
         /* SCORE pin 92-93 */
         if (!strcmp(vg->soc_data->uid, BYT_SCORE_ACPI_UID) &&
             offset >= 92 && offset <= 93)
-                return 1;
+                return BYT_ALTER_GPIO_MUX;
 
         /* SUS pin 11-21 */
         if (!strcmp(vg->soc_data->uid, BYT_SUS_ACPI_UID) &&
             offset >= 11 && offset <= 21)
-                return 1;
+                return BYT_ALTER_GPIO_MUX;
 
-        return 0;
+        return BYT_DEFAULT_GPIO_MUX;
 }
 
 static void byt_gpio_clear_triggering(struct byt_gpio *vg, unsigned int offset)
diff --git a/drivers/pinctrl/mediatek/pinctrl-mt8183.c b/drivers/pinctrl/mediatek/pinctrl-mt8183.c
index 2c7409ed16fa..9a74d5025be6 100644
--- a/drivers/pinctrl/mediatek/pinctrl-mt8183.c
+++ b/drivers/pinctrl/mediatek/pinctrl-mt8183.c
@@ -583,6 +583,7 @@ static struct platform_driver mt8183_pinctrl_driver = {
         .driver = {
                 .name = "mt8183-pinctrl",
                 .of_match_table = mt8183_pinctrl_of_match,
+                .pm = &mtk_paris_pinctrl_pm_ops,
         },
         .probe = mt8183_pinctrl_probe,
 };
diff --git a/drivers/pinctrl/mediatek/pinctrl-paris.c b/drivers/pinctrl/mediatek/pinctrl-paris.c
index d3b34e9a7507..923264d0e9ef 100644
--- a/drivers/pinctrl/mediatek/pinctrl-paris.c
+++ b/drivers/pinctrl/mediatek/pinctrl-paris.c
@@ -926,3 +926,22 @@ int mtk_paris_pinctrl_probe(struct platform_device *pdev,
 
         return 0;
 }
+
+static int mtk_paris_pinctrl_suspend(struct device *device)
+{
+        struct mtk_pinctrl *pctl = dev_get_drvdata(device);
+
+        return mtk_eint_do_suspend(pctl->eint);
+}
+
+static int mtk_paris_pinctrl_resume(struct device *device)
+{
+        struct mtk_pinctrl *pctl = dev_get_drvdata(device);
+
+        return mtk_eint_do_resume(pctl->eint);
+}
+
+const struct dev_pm_ops mtk_paris_pinctrl_pm_ops = {
+        .suspend_noirq = mtk_paris_pinctrl_suspend,
+        .resume_noirq = mtk_paris_pinctrl_resume,
+};
diff --git a/drivers/pinctrl/mediatek/pinctrl-paris.h b/drivers/pinctrl/mediatek/pinctrl-paris.h
index 37146caa667d..3d43771074e6 100644
--- a/drivers/pinctrl/mediatek/pinctrl-paris.h
+++ b/drivers/pinctrl/mediatek/pinctrl-paris.h
@@ -60,4 +60,6 @@
 int mtk_paris_pinctrl_probe(struct platform_device *pdev,
                             const struct mtk_pin_soc *soc);
 
+extern const struct dev_pm_ops mtk_paris_pinctrl_pm_ops;
+
 #endif /* __PINCTRL_PARIS_H */
diff --git a/drivers/pinctrl/meson/pinctrl-meson-g12a.c b/drivers/pinctrl/meson/pinctrl-meson-g12a.c
index d494492e98e9..3475cd7bd2af 100644
--- a/drivers/pinctrl/meson/pinctrl-meson-g12a.c
+++ b/drivers/pinctrl/meson/pinctrl-meson-g12a.c
@@ -1304,28 +1304,28 @@ static struct meson_pmx_func meson_g12a_aobus_functions[] = {
 };
 
 static struct meson_bank meson_g12a_periphs_banks[] = {
-        /* name  first  last  irq  pullen  pull  dir  out  in */
-        BANK("Z",    GPIOZ_0,    GPIOZ_15, 12, 27,
-             4,  0,  4,  0,  12,  0,  13, 0,  14, 0),
-        BANK("H",    GPIOH_0,    GPIOH_8, 28, 36,
-             3,  0,  3,  0,  9,  0,  10,  0,  11,  0),
-        BANK("BOOT", BOOT_0,     BOOT_15,  37, 52,
-             0,  0,  0,  0,  0, 0,  1, 0,  2, 0),
-        BANK("C",    GPIOC_0,    GPIOC_7,  53, 60,
-             1,  0,  1,  0,  3, 0,  4, 0,  5, 0),
-        BANK("A",    GPIOA_0,    GPIOA_15,  61, 76,
-             5,  0,  5,  0,  16,  0,  17,  0,  18,  0),
-        BANK("X",    GPIOX_0,    GPIOX_19,   77, 96,
-             2,  0,  2,  0,  6,  0,  7,  0,  8,  0),
+        /* name  first  last  irq  pullen  pull  dir  out  in  ds */
+        BANK_DS("Z",    GPIOZ_0,    GPIOZ_15, 12, 27,
+                4,  0,  4,  0,  12,  0,  13, 0,  14, 0, 5, 0),
+        BANK_DS("H",    GPIOH_0,    GPIOH_8, 28, 36,
+                3,  0,  3,  0,  9,  0,  10,  0,  11,  0, 4, 0),
+        BANK_DS("BOOT", BOOT_0,     BOOT_15,  37, 52,
+                0,  0,  0,  0,  0, 0,  1, 0,  2, 0, 0, 0),
+        BANK_DS("C",    GPIOC_0,    GPIOC_7,  53, 60,
+                1,  0,  1,  0,  3, 0,  4, 0,  5, 0, 1, 0),
+        BANK_DS("A",    GPIOA_0,    GPIOA_15,  61, 76,
+                5,  0,  5,  0,  16,  0,  17,  0,  18,  0, 6, 0),
+        BANK_DS("X",    GPIOX_0,    GPIOX_19,   77, 96,
+                2,  0,  2,  0,  6,  0,  7,  0,  8,  0, 2, 0),
 };
 
 static struct meson_bank meson_g12a_aobus_banks[] = {
-        /* name  first  last  irq  pullen  pull  dir  out  in  */
-        BANK("AO",   GPIOAO_0,  GPIOAO_11,  0, 11,
-             3,  0,  2, 0,  0,  0,  4, 0,  1,  0),
+        /* name  first  last  irq  pullen  pull  dir  out  in  ds */
+        BANK_DS("AO", GPIOAO_0, GPIOAO_11, 0, 11, 3, 0, 2, 0, 0, 0, 4, 0, 1, 0,
+                0, 0),
         /* GPIOE actually located in the AO bank */
-        BANK("E",   GPIOE_0,  GPIOE_2,   97, 99,
-             3,  16,  2, 16,  0,  16,  4, 16,  1,  16),
+        BANK_DS("E", GPIOE_0, GPIOE_2, 97, 99, 3, 16, 2, 16, 0, 16, 4, 16, 1,
+                16, 1, 0),
 };
 
 static struct meson_pmx_bank meson_g12a_periphs_pmx_banks[] = {
diff --git a/drivers/pinctrl/meson/pinctrl-meson.c b/drivers/pinctrl/meson/pinctrl-meson.c
index 077de5925783..596786926209 100644
--- a/drivers/pinctrl/meson/pinctrl-meson.c
+++ b/drivers/pinctrl/meson/pinctrl-meson.c
@@ -168,68 +168,223 @@ int meson_pmx_get_groups(struct pinctrl_dev *pcdev, unsigned selector,
         return 0;
 }
 
-static int meson_pinconf_set(struct pinctrl_dev *pcdev, unsigned int pin,
-                             unsigned long *configs, unsigned num_configs)
+static int meson_pinconf_set_gpio_bit(struct meson_pinctrl *pc,
+                                      unsigned int pin,
+                                      unsigned int reg_type,
+                                      bool arg)
 {
-        struct meson_pinctrl *pc = pinctrl_dev_get_drvdata(pcdev);
         struct meson_bank *bank;
-        enum pin_config_param param;
         unsigned int reg, bit;
-        int i, ret;
+        int ret;
+
+        ret = meson_get_bank(pc, pin, &bank);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, reg_type, &reg, &bit);
+        return regmap_update_bits(pc->reg_gpio, reg, BIT(bit),
+                                  arg ? BIT(bit) : 0);
+}
+
+static int meson_pinconf_get_gpio_bit(struct meson_pinctrl *pc,
+                                      unsigned int pin,
+                                      unsigned int reg_type)
+{
+        struct meson_bank *bank;
+        unsigned int reg, bit, val;
+        int ret;
 
         ret = meson_get_bank(pc, pin, &bank);
         if (ret)
                 return ret;
 
+        meson_calc_reg_and_bit(bank, pin, reg_type, &reg, &bit);
+        ret = regmap_read(pc->reg_gpio, reg, &val);
+        if (ret)
+                return ret;
+
+        return BIT(bit) & val ? 1 : 0;
+}
+
+static int meson_pinconf_set_output(struct meson_pinctrl *pc,
+                                    unsigned int pin,
+                                    bool out)
+{
+        return meson_pinconf_set_gpio_bit(pc, pin, REG_DIR, !out);
+}
+
+static int meson_pinconf_get_output(struct meson_pinctrl *pc,
+                                    unsigned int pin)
+{
+        int ret = meson_pinconf_get_gpio_bit(pc, pin, REG_DIR);
+
+        if (ret < 0)
+                return ret;
+
+        return !ret;
+}
+
+static int meson_pinconf_set_drive(struct meson_pinctrl *pc,
+                                   unsigned int pin,
+                                   bool high)
+{
+        return meson_pinconf_set_gpio_bit(pc, pin, REG_OUT, high);
+}
+
+static int meson_pinconf_get_drive(struct meson_pinctrl *pc,
+                                   unsigned int pin)
+{
+        return meson_pinconf_get_gpio_bit(pc, pin, REG_OUT);
+}
+
+static int meson_pinconf_set_output_drive(struct meson_pinctrl *pc,
+                                          unsigned int pin,
+                                          bool high)
+{
+        int ret;
+
+        ret = meson_pinconf_set_output(pc, pin, true);
+        if (ret)
+                return ret;
+
+        return meson_pinconf_set_drive(pc, pin, high);
+}
+
+static int meson_pinconf_disable_bias(struct meson_pinctrl *pc,
+                                      unsigned int pin)
+{
+        struct meson_bank *bank;
+        unsigned int reg, bit = 0;
+        int ret;
+
+        ret = meson_get_bank(pc, pin, &bank);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg, &bit);
+        ret = regmap_update_bits(pc->reg_pullen, reg, BIT(bit), 0);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int meson_pinconf_enable_bias(struct meson_pinctrl *pc, unsigned int pin,
+                                     bool pull_up)
+{
+        struct meson_bank *bank;
+        unsigned int reg, bit, val = 0;
+        int ret;
+
+        ret = meson_get_bank(pc, pin, &bank);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, REG_PULL, &reg, &bit);
+        if (pull_up)
+                val = BIT(bit);
+
+        ret = regmap_update_bits(pc->reg_pull, reg, BIT(bit), val);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg, &bit);
+        ret = regmap_update_bits(pc->reg_pullen, reg, BIT(bit), BIT(bit));
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int meson_pinconf_set_drive_strength(struct meson_pinctrl *pc,
+                                            unsigned int pin,
+                                            u16 drive_strength_ua)
+{
+        struct meson_bank *bank;
+        unsigned int reg, bit, ds_val;
+        int ret;
+
+        if (!pc->reg_ds) {
+                dev_err(pc->dev, "drive-strength not supported\n");
+                return -ENOTSUPP;
+        }
+
+        ret = meson_get_bank(pc, pin, &bank);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);
+        bit = bit << 1;
+
+        if (drive_strength_ua <= 500) {
+                ds_val = MESON_PINCONF_DRV_500UA;
+        } else if (drive_strength_ua <= 2500) {
+                ds_val = MESON_PINCONF_DRV_2500UA;
+        } else if (drive_strength_ua <= 3000) {
+                ds_val = MESON_PINCONF_DRV_3000UA;
+        } else if (drive_strength_ua <= 4000) {
+                ds_val = MESON_PINCONF_DRV_4000UA;
+        } else {
+                dev_warn_once(pc->dev,
+                              "pin %u: invalid drive-strength : %d , default to 4mA\n",
+                              pin, drive_strength_ua);
+                ds_val = MESON_PINCONF_DRV_4000UA;
+        }
+
+        ret = regmap_update_bits(pc->reg_ds, reg, 0x3 << bit, ds_val << bit);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int meson_pinconf_set(struct pinctrl_dev *pcdev, unsigned int pin,
+                             unsigned long *configs, unsigned num_configs)
+{
+        struct meson_pinctrl *pc = pinctrl_dev_get_drvdata(pcdev);
+        enum pin_config_param param;
+        unsigned int arg = 0;
+        int i, ret;
+
         for (i = 0; i < num_configs; i++) {
                 param = pinconf_to_config_param(configs[i]);
 
                 switch (param) {
+                case PIN_CONFIG_DRIVE_STRENGTH_UA:
+                case PIN_CONFIG_OUTPUT_ENABLE:
+                case PIN_CONFIG_OUTPUT:
+                        arg = pinconf_to_config_argument(configs[i]);
+                        break;
+
+                default:
+                        break;
+                }
+
+                switch (param) {
                 case PIN_CONFIG_BIAS_DISABLE:
-                        dev_dbg(pc->dev, "pin %u: disable bias\n", pin);
-
-                        meson_calc_reg_and_bit(bank, pin, REG_PULLEN, &reg,
-                                               &bit);
-                        ret = regmap_update_bits(pc->reg_pullen, reg,
-                                                 BIT(bit), 0);
-                        if (ret)
-                                return ret;
+                        ret = meson_pinconf_disable_bias(pc, pin);
                         break;
                 case PIN_CONFIG_BIAS_PULL_UP:
-                        dev_dbg(pc->dev, "pin %u: enable pull-up\n", pin);
-
-                        meson_calc_reg_and_bit(bank, pin, REG_PULLEN,
-                                               &reg, &bit);
-                        ret = regmap_update_bits(pc->reg_pullen, reg,
-                                                 BIT(bit), BIT(bit));
-                        if (ret)
-                                return ret;
-
-                        meson_calc_reg_and_bit(bank, pin, REG_PULL, &reg, &bit);
-                        ret = regmap_update_bits(pc->reg_pull, reg,
-                                                 BIT(bit), BIT(bit));
-                        if (ret)
-                                return ret;
+                        ret = meson_pinconf_enable_bias(pc, pin, true);
                         break;
                 case PIN_CONFIG_BIAS_PULL_DOWN:
-                        dev_dbg(pc->dev, "pin %u: enable pull-down\n", pin);
-
-                        meson_calc_reg_and_bit(bank, pin, REG_PULLEN,
-                                               &reg, &bit);
-                        ret = regmap_update_bits(pc->reg_pullen, reg,
-                                                 BIT(bit), BIT(bit));
-                        if (ret)
-                                return ret;
-
-                        meson_calc_reg_and_bit(bank, pin, REG_PULL, &reg, &bit);
-                        ret = regmap_update_bits(pc->reg_pull, reg,
-                                                 BIT(bit), 0);
-                        if (ret)
-                                return ret;
+                        ret = meson_pinconf_enable_bias(pc, pin, false);
+                        break;
+                case PIN_CONFIG_DRIVE_STRENGTH_UA:
+                        ret = meson_pinconf_set_drive_strength(pc, pin, arg);
+                        break;
+                case PIN_CONFIG_OUTPUT_ENABLE:
+                        ret = meson_pinconf_set_output(pc, pin, arg);
+                        break;
+                case PIN_CONFIG_OUTPUT:
+                        ret = meson_pinconf_set_output_drive(pc, pin, arg);
                         break;
                 default:
-                        return -ENOTSUPP;
+                        ret = -ENOTSUPP;
                 }
+
+                if (ret)
+                        return ret;
         }
 
         return 0;
@@ -269,12 +424,55 @@ static int meson_pinconf_get_pull(struct meson_pinctrl *pc, unsigned int pin)
         return conf;
 }
 
+static int meson_pinconf_get_drive_strength(struct meson_pinctrl *pc,
+                                            unsigned int pin,
+                                            u16 *drive_strength_ua)
+{
+        struct meson_bank *bank;
+        unsigned int reg, bit;
+        unsigned int val;
+        int ret;
+
+        if (!pc->reg_ds)
+                return -ENOTSUPP;
+
+        ret = meson_get_bank(pc, pin, &bank);
+        if (ret)
+                return ret;
+
+        meson_calc_reg_and_bit(bank, pin, REG_DS, &reg, &bit);
+
+        ret = regmap_read(pc->reg_ds, reg, &val);
+        if (ret)
+                return ret;
+
+        switch ((val >> bit) & 0x3) {
+        case MESON_PINCONF_DRV_500UA:
+                *drive_strength_ua = 500;
+                break;
+        case MESON_PINCONF_DRV_2500UA:
+                *drive_strength_ua = 2500;
+                break;
+        case MESON_PINCONF_DRV_3000UA:
+                *drive_strength_ua = 3000;
+                break;
+        case MESON_PINCONF_DRV_4000UA:
+                *drive_strength_ua = 4000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int meson_pinconf_get(struct pinctrl_dev *pcdev, unsigned int pin,
                              unsigned long *config)
 {
         struct meson_pinctrl *pc = pinctrl_dev_get_drvdata(pcdev);
         enum pin_config_param param = pinconf_to_config_param(*config);
         u16 arg;
+        int ret;
 
         switch (param) {
         case PIN_CONFIG_BIAS_DISABLE:
@@ -285,6 +483,29 @@ static int meson_pinconf_get(struct pinctrl_dev *pcdev, unsigned int pin,
                 else
                         return -EINVAL;
                 break;
+        case PIN_CONFIG_DRIVE_STRENGTH_UA:
+                ret = meson_pinconf_get_drive_strength(pc, pin, &arg);
+                if (ret)
+                        return ret;
+                break;
+        case PIN_CONFIG_OUTPUT_ENABLE:
+                ret = meson_pinconf_get_output(pc, pin);
+                if (ret <= 0)
+                        return -EINVAL;
+                arg = 1;
+                break;
+        case PIN_CONFIG_OUTPUT:
+                ret = meson_pinconf_get_output(pc, pin);
+                if (ret <= 0)
+                        return -EINVAL;
+
+                ret = meson_pinconf_get_drive(pc, pin);
+                if (ret < 0)
+                        return -EINVAL;
+
+                arg = ret;
+                break;
+
         default:
                 return -ENOTSUPP;
         }
@@ -329,56 +550,19 @@ static const struct pinconf_ops meson_pinconf_ops = {
 
 static int meson_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 {
-        struct meson_pinctrl *pc = gpiochip_get_data(chip);
-        unsigned int reg, bit;
-        struct meson_bank *bank;
-        int ret;
-
-        ret = meson_get_bank(pc, gpio, &bank);
-        if (ret)
-                return ret;
-
-        meson_calc_reg_and_bit(bank, gpio, REG_DIR, &reg, &bit);
-
-        return regmap_update_bits(pc->reg_gpio, reg, BIT(bit), BIT(bit));
+        return meson_pinconf_set_output(gpiochip_get_data(chip), gpio, false);
 }
 
 static int meson_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
                                        int value)
 {
-        struct meson_pinctrl *pc = gpiochip_get_data(chip);
-        unsigned int reg, bit;
-        struct meson_bank *bank;
-        int ret;
-
-        ret = meson_get_bank(pc, gpio, &bank);
-        if (ret)
-                return ret;
-
-        meson_calc_reg_and_bit(bank, gpio, REG_DIR, &reg, &bit);
-        ret = regmap_update_bits(pc->reg_gpio, reg, BIT(bit), 0);
-        if (ret)
-                return ret;
-
-        meson_calc_reg_and_bit(bank, gpio, REG_OUT, &reg, &bit);
-        return regmap_update_bits(pc->reg_gpio, reg, BIT(bit),
-                                  value ? BIT(bit) : 0);
+        return meson_pinconf_set_output_drive(gpiochip_get_data(chip),
+                                              gpio, value);
 }
 
 static void meson_gpio_set(struct gpio_chip *chip, unsigned gpio, int value)
 {
-        struct meson_pinctrl *pc = gpiochip_get_data(chip);
-        unsigned int reg, bit;
-        struct meson_bank *bank;
-        int ret;
-
-        ret = meson_get_bank(pc, gpio, &bank);
-        if (ret)
-                return;
-
-        meson_calc_reg_and_bit(bank, gpio, REG_OUT, &reg, &bit);
-        regmap_update_bits(pc->reg_gpio, reg, BIT(bit),
-                           value ? BIT(bit) : 0);
+        meson_pinconf_set_drive(gpiochip_get_data(chip), gpio, value);
 }
 
 static int meson_gpio_get(struct gpio_chip *chip, unsigned gpio)
diff --git a/drivers/pinctrl/meson/pinctrl-meson.h b/drivers/pinctrl/meson/pinctrl-meson.h
index adab4ea078f9..c696f3241a36 100644
--- a/drivers/pinctrl/meson/pinctrl-meson.h
+++ b/drivers/pinctrl/meson/pinctrl-meson.h
@@ -65,10 +65,21 @@ enum meson_reg_type {
         REG_DIR,
         REG_OUT,
         REG_IN,
+        REG_DS,
         NUM_REG,
 };
 
 /**
+ * enum meson_pinconf_drv - value of drive-strength supported
+ */
+enum meson_pinconf_drv {
+        MESON_PINCONF_DRV_500UA,
+        MESON_PINCONF_DRV_2500UA,
+        MESON_PINCONF_DRV_3000UA,
+        MESON_PINCONF_DRV_4000UA,
+};
+
+/**
  * struct meson bank
  *
  * @name:       bank name
@@ -126,7 +137,8 @@ struct meson_pinctrl {
                 .num_groups = ARRAY_SIZE(fn ## _groups),                \
         }
 
-#define BANK(n, f, l, fi, li, per, peb, pr, pb, dr, db, or, ob, ir, ib) \
+#define BANK_DS(n, f, l, fi, li, per, peb, pr, pb, dr, db, or, ob, ir, ib,     \
+                dsr, dsb)                                                      \
         {                                                               \
                 .name           = n,                                    \
                 .first          = f,                                    \
@@ -139,9 +151,13 @@ struct meson_pinctrl {
                         [REG_DIR]       = { dr, db },                   \
                         [REG_OUT]       = { or, ob },                   \
                         [REG_IN]        = { ir, ib },                   \
+                        [REG_DS]        = { dsr, dsb },                 \
                 },                                                      \
          }
 
+#define BANK(n, f, l, fi, li, per, peb, pr, pb, dr, db, or, ob, ir, ib) \
+        BANK_DS(n, f, l, fi, li, per, peb, pr, pb, dr, db, or, ob, ir, ib, 0, 0)
+
 #define MESON_PIN(x) PINCTRL_PIN(x, #x)
 
 /* Common pmx functions */
diff --git a/drivers/pinctrl/mvebu/pinctrl-kirkwood.c b/drivers/pinctrl/mvebu/pinctrl-kirkwood.c
index 19e69701747d..d45c31f281c8 100644
--- a/drivers/pinctrl/mvebu/pinctrl-kirkwood.c
+++ b/drivers/pinctrl/mvebu/pinctrl-kirkwood.c
@@ -16,341 +16,347 @@
 
 #include "pinctrl-mvebu.h"
 
-#define V(f6180, f6190, f6192, f6281, f6282, dx4122)    \
+#define V(f6180, f6190, f6192, f6281, f6282, dx4122, dx1135)    \
         ((f6180 << 0) | (f6190 << 1) | (f6192 << 2) |   \
-         (f6281 << 3) | (f6282 << 4) | (dx4122 << 5))
+         (f6281 << 3) | (f6282 << 4) | (dx4122 << 5) |  \
+         (dx1135 << 6))
 
 enum kirkwood_variant {
-        VARIANT_MV88F6180       = V(1, 0, 0, 0, 0, 0),
-        VARIANT_MV88F6190       = V(0, 1, 0, 0, 0, 0),
-        VARIANT_MV88F6192       = V(0, 0, 1, 0, 0, 0),
-        VARIANT_MV88F6281       = V(0, 0, 0, 1, 0, 0),
-        VARIANT_MV88F6282       = V(0, 0, 0, 0, 1, 0),
-        VARIANT_MV98DX4122      = V(0, 0, 0, 0, 0, 1),
+        VARIANT_MV88F6180       = V(1, 0, 0, 0, 0, 0, 0),
+        VARIANT_MV88F6190       = V(0, 1, 0, 0, 0, 0, 0),
+        VARIANT_MV88F6192       = V(0, 0, 1, 0, 0, 0, 0),
+        VARIANT_MV88F6281       = V(0, 0, 0, 1, 0, 0, 0),
+        VARIANT_MV88F6282       = V(0, 0, 0, 0, 1, 0, 0),
+        VARIANT_MV98DX4122      = V(0, 0, 0, 0, 0, 1, 0),
+        VARIANT_MV98DX1135      = V(0, 0, 0, 0, 0, 0, 1),
 };
 
 static struct mvebu_mpp_mode mv88f6xxx_mpp_modes[] = {
         MPP_MODE(0,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io2",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "cs",       V(1, 1, 1, 1, 1, 1))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io2",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "cs",       V(1, 1, 1, 1, 1, 1, 1))),
         MPP_MODE(1,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io3",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "mosi",     V(1, 1, 1, 1, 1, 1))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io3",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "mosi",     V(1, 1, 1, 1, 1, 1, 1))),
         MPP_MODE(2,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io4",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "sck",      V(1, 1, 1, 1, 1, 1))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io4",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "sck",      V(1, 1, 1, 1, 1, 1, 1))),
         MPP_MODE(3,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io5",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "miso",     V(1, 1, 1, 1, 1, 1))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io5",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "miso",     V(1, 1, 1, 1, 1, 1, 1))),
         MPP_MODE(4,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io6",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "rxd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "hsync",    V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xd, "ptp", "clk",      V(1, 1, 1, 1, 0, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io6",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "rxd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "hsync",    V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "ptp", "clk",      V(1, 1, 1, 1, 0, 0, 0))),
         MPP_MODE(5,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io7",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "txd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x4, "ptp", "trig",     V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "vsync",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io7",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "txd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x4, "ptp", "trig",     V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "vsync",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(6,
-                MPP_VAR_FUNCTION(0x1, "sysrst", "out",   V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "mosi",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "ptp", "trig",     V(1, 1, 1, 1, 0, 0))),
+                MPP_VAR_FUNCTION(0x1, "sysrst", "out",   V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "mosi",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "ptp", "trig",     V(1, 1, 1, 1, 0, 0, 0))),
         MPP_MODE(7,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "pex", "rsto",     V(1, 1, 1, 1, 0, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "cs",       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "ptp", "trig",     V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "pwm",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "pex", "rsto",     V(1, 1, 1, 1, 0, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "cs",       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "ptp", "trig",     V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "pwm",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(8,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "twsi0", "sda",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "rts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "rts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x4, "mii-1", "rxerr",  V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xc, "ptp", "clk",      V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xd, "mii", "col",      V(1, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "twsi0", "sda",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "rts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "rts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x4, "mii-1", "rxerr",  V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "ptp", "clk",      V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "mii", "col",      V(1, 1, 1, 1, 1, 0, 0))),
         MPP_MODE(9,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "twsi0", "sck",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "cts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "cts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xc, "ptp", "evreq",    V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xd, "mii", "crs",      V(1, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "twsi0", "sck",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "cts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "cts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "ptp", "evreq",    V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "mii", "crs",      V(1, 1, 1, 1, 1, 0, 0))),
         MPP_MODE(10,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "sck",      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0X3, "uart0", "txd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xc, "ptp", "trig",     V(1, 1, 1, 1, 0, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "sck",      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0X3, "uart0", "txd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "ptp", "trig",     V(1, 1, 1, 1, 0, 0, 0))),
         MPP_MODE(11,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "spi", "miso",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "uart0", "rxd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x4, "ptp-1", "evreq",  V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xc, "ptp-2", "trig",   V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xd, "ptp", "clk",      V(1, 1, 1, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "spi", "miso",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "uart0", "rxd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x4, "ptp-1", "evreq",  V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "ptp-2", "trig",   V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "ptp", "clk",      V(1, 1, 1, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0, 0))),
         MPP_MODE(12,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "clk",     V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xa, "audio", "spdifo", V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "spi", "mosi",     V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xd, "twsi1", "sda",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "clk",     V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xa, "audio", "spdifo", V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "spi", "mosi",     V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "twsi1", "sda",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(13,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "cmd",     V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "txd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0xa, "audio", "rmclk",  V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "pwm",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "cmd",     V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "txd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0xa, "audio", "rmclk",  V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "pwm",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(14,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "d0",      V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "rxd",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x4, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xa, "audio", "spdifi", V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "audio-1", "sdi",  V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xd, "mii", "col",      V(1, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "d0",      V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "rxd",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x4, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xa, "audio", "spdifi", V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "audio-1", "sdi",  V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "mii", "col",      V(1, 1, 1, 1, 1, 0, 0))),
         MPP_MODE(15,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "d1",      V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "rts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "txd",    V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "sata0", "act",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "spi", "cs",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "d1",      V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "rts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "txd",    V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "sata0", "act",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "spi", "cs",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(16,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "d2",      V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "uart0", "cts",    V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x3, "uart1", "rxd",    V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "sata1", "act",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "extclk",   V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xd, "mii", "crs",      V(1, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "d2",      V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "uart0", "cts",    V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x3, "uart1", "rxd",    V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "sata1", "act",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "extclk",   V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "mii", "crs",      V(1, 1, 1, 1, 1, 0, 0))),
         MPP_MODE(17,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "sdio", "d3",      V(1, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xa, "sata1", "act",    V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xd, "twsi1", "sck",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "sdio", "d3",      V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xa, "sata1", "act",    V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xd, "twsi1", "sck",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(18,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io0",     V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "pex", "clkreq",   V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io0",     V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "pex", "clkreq",   V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(19,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "nand", "io1",     V(1, 1, 1, 1, 1, 1))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "nand", "io1",     V(1, 1, 1, 1, 1, 1, 1))),
         MPP_MODE(20,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp0",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "tx0ql",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txd0",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d0",       V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xc, "mii", "rxerr",    V(0, 0, 0, 0, 0, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp0",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "tx0ql",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txd0",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d0",       V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "mii", "rxerr",    V(0, 0, 0, 0, 0, 0, 0))),
         MPP_MODE(21,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp1",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rx0ql",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txd1",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d1",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp1",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rx0ql",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txd1",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d1",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(22,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp2",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "tx2ql",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txd2",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d2",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp2",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "tx2ql",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txd2",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "prsnt",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d2",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(23,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp3",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rx2ql",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txd3",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d3",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp3",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rx2ql",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txd3",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "prsnt",  V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d3",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(24,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp4",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs0",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxd0",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d4",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp4",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs0",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxd0",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d4",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(25,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp5",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-sck",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxd1",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d5",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp5",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-sck",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxd1",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d5",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(26,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp6",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-miso", V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxd2",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d6",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp6",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-miso", V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxd2",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d6",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(27,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp7",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-mosi", V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxd3",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d7",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp7",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-mosi", V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxd3",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d7",       V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(28,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp8",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "int",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "col",      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d8",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp8",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "int",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "col",      V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d8",       V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "nand", "ren",     V(0, 0, 0, 0, 0, 0, 1))),
         MPP_MODE(29,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rst",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txclk",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(0, 0, 0, 0, 0, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d9",       V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rst",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txclk",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(0, 0, 0, 0, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d9",       V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "nand", "wen",     V(0, 0, 0, 0, 0, 0, 1))),
         MPP_MODE(30,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp10",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "pclk",     V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxctl",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d10",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp10",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "pclk",     V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxctl",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d10",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(31,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp11",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "fs",       V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxclk",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d11",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp11",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "fs",       V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxclk",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d11",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(32,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp12",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "drx",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txclko",   V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d12",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp12",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "drx",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txclko",   V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d12",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(33,
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "dtx",      V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txctl",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d13",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(0, 1, 1, 1, 1, 0, 1)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "dtx",      V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txctl",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d13",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(34,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs1",  V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "txen",     V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d14",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs1",  V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "txen",     V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata1", "act",    V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d14",      V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "nand", "ale",     V(0, 0, 0, 0, 0, 0, 1))),
         MPP_MODE(35,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "tx0ql",    V(0, 0, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x3, "ge1", "rxerr",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d15",      V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xc, "mii", "rxerr",    V(1, 1, 1, 1, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 1, 1, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "tx0ql",    V(0, 0, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x3, "ge1", "rxerr",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "sata0", "act",    V(0, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d15",      V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xc, "mii", "rxerr",    V(1, 1, 1, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "nand", "cen",     V(0, 0, 0, 0, 0, 0, 1))),
         MPP_MODE(36,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp0",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs1",  V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "twsi1", "sda",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp0",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs1",  V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifi", V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "twsi1", "sda",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(37,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp1",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "tx2ql",    V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "twsi1", "sck",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp1",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "tx2ql",    V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "spdifo", V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "twsi1", "sck",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(38,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp2",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rx2ql",    V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d18",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp2",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rx2ql",    V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "rmclk",  V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d18",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(39,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp3",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs0",  V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d19",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp3",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-cs0",  V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "bclk",   V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d19",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(40,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp4",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-sck",  V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d20",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp4",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-sck",  V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdo",    V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d20",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(41,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp5",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-miso", V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d21",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp5",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-miso", V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "lrclk",  V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d21",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(42,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp6",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "spi-mosi", V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d22",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp6",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "spi-mosi", V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "mclk",   V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d22",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(43,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp7",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "int",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d23",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp7",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "int",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "sdi",    V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d23",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(44,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp8",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rst",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(1, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "clk",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(1, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp8",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rst",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x4, "audio", "extclk", V(1, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "clk",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(45,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 1)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "pclk",     V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "e",        V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 1, 1)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "pclk",     V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "e",        V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(46,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp10",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "fs",       V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "hsync",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp10",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "fs",       V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "hsync",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(47,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp11",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "drx",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "vsync",    V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp11",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "drx",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "vsync",    V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(48,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp12",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "dtx",      V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d16",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp12",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "dtx",      V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d16",      V(0, 0, 0, 0, 1, 0, 0))),
         MPP_MODE(49,
-                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 0, 1)),
-                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 0, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0x2, "tdm", "rx0ql",    V(0, 0, 0, 1, 1, 0)),
-                MPP_VAR_FUNCTION(0x5, "ptp", "clk",      V(0, 0, 0, 1, 0, 0)),
-                MPP_VAR_FUNCTION(0xa, "pex", "clkreq",   V(0, 0, 0, 0, 1, 0)),
-                MPP_VAR_FUNCTION(0xb, "lcd", "d17",      V(0, 0, 0, 0, 1, 0))),
+                MPP_VAR_FUNCTION(0x0, "gpio", NULL,      V(0, 0, 0, 1, 0, 1, 1)),
+                MPP_VAR_FUNCTION(0x0, "gpo", NULL,       V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x1, "ts", "mp9",       V(0, 0, 0, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0x2, "tdm", "rx0ql",    V(0, 0, 0, 1, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0x5, "ptp", "clk",      V(0, 0, 0, 1, 0, 0, 0)),
+                MPP_VAR_FUNCTION(0xa, "pex", "clkreq",   V(0, 0, 0, 0, 1, 0, 0)),
+                MPP_VAR_FUNCTION(0xb, "lcd", "d17",      V(0, 0, 0, 0, 1, 0, 0))),
 };
 
 static const struct mvebu_mpp_ctrl mv88f6180_mpp_controls[] = {
@@ -440,6 +446,17 @@ static struct mvebu_pinctrl_soc_info mv98dx4122_info = {
         .ngpioranges = ARRAY_SIZE(mv88f628x_gpio_ranges),
 };
 
+static struct mvebu_pinctrl_soc_info mv98dx1135_info = {
+        .variant = VARIANT_MV98DX1135,
+        .controls = mv88f628x_mpp_controls,
+        .ncontrols = ARRAY_SIZE(mv88f628x_mpp_controls),
+        .modes = mv88f6xxx_mpp_modes,
+        .nmodes = ARRAY_SIZE(mv88f6xxx_mpp_modes),
+        .gpioranges = mv88f628x_gpio_ranges,
+        .ngpioranges = ARRAY_SIZE(mv88f628x_gpio_ranges),
+};
+
+
 static const struct of_device_id kirkwood_pinctrl_of_match[] = {
         { .compatible = "marvell,88f6180-pinctrl", .data = &mv88f6180_info },
         { .compatible = "marvell,88f6190-pinctrl", .data = &mv88f6190_info },
@@ -447,6 +464,7 @@ static const struct of_device_id kirkwood_pinctrl_of_match[] = {
         { .compatible = "marvell,88f6281-pinctrl", .data = &mv88f6281_info },
         { .compatible = "marvell,88f6282-pinctrl", .data = &mv88f6282_info },
         { .compatible = "marvell,98dx4122-pinctrl", .data = &mv98dx4122_info },
+        { .compatible = "marvell,98dx1135-pinctrl", .data = &mv98dx1135_info },
         { }
 };
 
diff --git a/drivers/pinctrl/pinconf-generic.c b/drivers/pinctrl/pinconf-generic.c
index 4ccd71bbc72a..9eb86309c70b 100644
--- a/drivers/pinctrl/pinconf-generic.c
+++ b/drivers/pinctrl/pinconf-generic.c
@@ -38,6 +38,7 @@ static const struct pin_config_item conf_items[] = {
         PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_SOURCE, "output drive open source", NULL, false),
         PCONFDUMP(PIN_CONFIG_DRIVE_PUSH_PULL, "output drive push pull", NULL, false),
         PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH, "output drive strength", "mA", true),
+        PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH_UA, "output drive strength", "uA", true),
         PCONFDUMP(PIN_CONFIG_INPUT_DEBOUNCE, "input debounce", "usec", true),
         PCONFDUMP(PIN_CONFIG_INPUT_ENABLE, "input enabled", NULL, false),
         PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT, "input schmitt trigger", NULL, false),
@@ -166,6 +167,7 @@ static const struct pinconf_generic_params dt_params[] = {
         { "drive-open-source", PIN_CONFIG_DRIVE_OPEN_SOURCE, 0 },
         { "drive-push-pull", PIN_CONFIG_DRIVE_PUSH_PULL, 0 },
         { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, 0 },
+        { "drive-strength-microamp", PIN_CONFIG_DRIVE_STRENGTH_UA, 0 },
         { "input-debounce", PIN_CONFIG_INPUT_DEBOUNCE, 0 },
         { "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 },
         { "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 },
diff --git a/drivers/pinctrl/pinctrl-bm1880.c b/drivers/pinctrl/pinctrl-bm1880.c
index 446b07d8fbfc..63b130cb1ffb 100644
--- a/drivers/pinctrl/pinctrl-bm1880.c
+++ b/drivers/pinctrl/pinctrl-bm1880.c
@@ -27,6 +27,7 @@
  * @ngroups:    Number of @groups
  * @funcs:      Pinmux functions
  * @nfuncs:     Number of @funcs
+ * @pconf:      Pinconf data
  */
 struct bm1880_pinctrl {
         void __iomem *base;
@@ -35,6 +36,7 @@ struct bm1880_pinctrl {
         unsigned int ngroups;
         const struct bm1880_pinmux_function *funcs;
         unsigned int nfuncs;
+        const struct bm1880_pinconf_data *pinconf;
 };
 
 /**
@@ -55,7 +57,6 @@ struct bm1880_pctrl_group {
  * @groups:     List of pingroups for this function.
  * @ngroups:    Number of entries in @groups.
  * @mux_val:    Selector for this function
- * @mux_mask:   Mask for function specific selector
  * @mux:        Offset of function specific mux
  * @mux_shift:  Shift for function specific selector
  */
@@ -64,11 +65,18 @@ struct bm1880_pinmux_function {
         const char * const *groups;
         unsigned int ngroups;
         u32 mux_val;
-        u32 mux_mask;
         u32 mux;
         u8 mux_shift;
 };
 
+/**
+ * struct bm1880_pinconf_data - pinconf data
+ * @drv_bits:   Drive strength bit width
+ */
+struct bm1880_pinconf_data {
+        u32 drv_bits;
+};
+
 static const struct pinctrl_pin_desc bm1880_pins[] = {
         PINCTRL_PIN(0,   "MIO0"),
         PINCTRL_PIN(1,   "MIO1"),
@@ -636,165 +644,273 @@ static const char * const i2s1_group[] = { "i2s1_grp" };
 static const char * const i2s1_mclkin_group[] = { "i2s1_mclkin_grp" };
 static const char * const spi0_group[] = { "spi0_grp" };
 
-#define BM1880_PINMUX_FUNCTION(fname, mval, mask)       \
+#define BM1880_PINMUX_FUNCTION(fname, mval)             \
         [F_##fname] = {                                 \
                 .name = #fname,                         \
                 .groups = fname##_group,                \
                 .ngroups = ARRAY_SIZE(fname##_group),   \
                 .mux_val = mval,                        \
-                .mux_mask = mask,                       \
         }
 
-#define BM1880_PINMUX_FUNCTION_MUX(fname, mval, mask, offset, shift)\
-        [F_##fname] = {                                 \
-                .name = #fname,                         \
-                .groups = fname##_group,                \
-                .ngroups = ARRAY_SIZE(fname##_group),   \
-                .mux_val = mval,                        \
-                .mux_mask = mask,                       \
-                .mux = offset,                          \
-                .mux_shift = shift,                     \
+static const struct bm1880_pinmux_function bm1880_pmux_functions[] = {
+        BM1880_PINMUX_FUNCTION(nand, 2),
+        BM1880_PINMUX_FUNCTION(spi, 0),
+        BM1880_PINMUX_FUNCTION(emmc, 1),
+        BM1880_PINMUX_FUNCTION(sdio, 0),
+        BM1880_PINMUX_FUNCTION(eth0, 0),
+        BM1880_PINMUX_FUNCTION(pwm0, 2),
+        BM1880_PINMUX_FUNCTION(pwm1, 2),
+        BM1880_PINMUX_FUNCTION(pwm2, 2),
+        BM1880_PINMUX_FUNCTION(pwm3, 2),
+        BM1880_PINMUX_FUNCTION(pwm4, 2),
+        BM1880_PINMUX_FUNCTION(pwm5, 2),
+        BM1880_PINMUX_FUNCTION(pwm6, 2),
+        BM1880_PINMUX_FUNCTION(pwm7, 2),
+        BM1880_PINMUX_FUNCTION(pwm8, 2),
+        BM1880_PINMUX_FUNCTION(pwm9, 2),
+        BM1880_PINMUX_FUNCTION(pwm10, 2),
+        BM1880_PINMUX_FUNCTION(pwm11, 2),
+        BM1880_PINMUX_FUNCTION(pwm12, 2),
+        BM1880_PINMUX_FUNCTION(pwm13, 2),
+        BM1880_PINMUX_FUNCTION(pwm14, 2),
+        BM1880_PINMUX_FUNCTION(pwm15, 2),
+        BM1880_PINMUX_FUNCTION(pwm16, 2),
+        BM1880_PINMUX_FUNCTION(pwm17, 2),
+        BM1880_PINMUX_FUNCTION(pwm18, 2),
+        BM1880_PINMUX_FUNCTION(pwm19, 2),
+        BM1880_PINMUX_FUNCTION(pwm20, 2),
+        BM1880_PINMUX_FUNCTION(pwm21, 2),
+        BM1880_PINMUX_FUNCTION(pwm22, 2),
+        BM1880_PINMUX_FUNCTION(pwm23, 2),
+        BM1880_PINMUX_FUNCTION(pwm24, 2),
+        BM1880_PINMUX_FUNCTION(pwm25, 2),
+        BM1880_PINMUX_FUNCTION(pwm26, 2),
+        BM1880_PINMUX_FUNCTION(pwm27, 2),
+        BM1880_PINMUX_FUNCTION(pwm28, 2),
+        BM1880_PINMUX_FUNCTION(pwm29, 2),
+        BM1880_PINMUX_FUNCTION(pwm30, 2),
+        BM1880_PINMUX_FUNCTION(pwm31, 2),
+        BM1880_PINMUX_FUNCTION(pwm32, 2),
+        BM1880_PINMUX_FUNCTION(pwm33, 2),
+        BM1880_PINMUX_FUNCTION(pwm34, 2),
+        BM1880_PINMUX_FUNCTION(pwm35, 2),
+        BM1880_PINMUX_FUNCTION(pwm36, 2),
+        BM1880_PINMUX_FUNCTION(pwm37, 2),
+        BM1880_PINMUX_FUNCTION(i2c0, 1),
+        BM1880_PINMUX_FUNCTION(i2c1, 1),
+        BM1880_PINMUX_FUNCTION(i2c2, 1),
+        BM1880_PINMUX_FUNCTION(i2c3, 1),
+        BM1880_PINMUX_FUNCTION(i2c4, 1),
+        BM1880_PINMUX_FUNCTION(uart0, 3),
+        BM1880_PINMUX_FUNCTION(uart1, 3),
+        BM1880_PINMUX_FUNCTION(uart2, 3),
+        BM1880_PINMUX_FUNCTION(uart3, 3),
+        BM1880_PINMUX_FUNCTION(uart4, 1),
+        BM1880_PINMUX_FUNCTION(uart5, 1),
+        BM1880_PINMUX_FUNCTION(uart6, 1),
+        BM1880_PINMUX_FUNCTION(uart7, 1),
+        BM1880_PINMUX_FUNCTION(uart8, 1),
+        BM1880_PINMUX_FUNCTION(uart9, 1),
+        BM1880_PINMUX_FUNCTION(uart10, 1),
+        BM1880_PINMUX_FUNCTION(uart11, 1),
+        BM1880_PINMUX_FUNCTION(uart12, 3),
+        BM1880_PINMUX_FUNCTION(uart13, 3),
+        BM1880_PINMUX_FUNCTION(uart14, 3),
+        BM1880_PINMUX_FUNCTION(uart15, 3),
+        BM1880_PINMUX_FUNCTION(gpio0, 0),
+        BM1880_PINMUX_FUNCTION(gpio1, 0),
+        BM1880_PINMUX_FUNCTION(gpio2, 0),
+        BM1880_PINMUX_FUNCTION(gpio3, 0),
+        BM1880_PINMUX_FUNCTION(gpio4, 0),
+        BM1880_PINMUX_FUNCTION(gpio5, 0),
+        BM1880_PINMUX_FUNCTION(gpio6, 0),
+        BM1880_PINMUX_FUNCTION(gpio7, 0),
+        BM1880_PINMUX_FUNCTION(gpio8, 0),
+        BM1880_PINMUX_FUNCTION(gpio9, 0),
+        BM1880_PINMUX_FUNCTION(gpio10, 0),
+        BM1880_PINMUX_FUNCTION(gpio11, 0),
+        BM1880_PINMUX_FUNCTION(gpio12, 1),
+        BM1880_PINMUX_FUNCTION(gpio13, 1),
+        BM1880_PINMUX_FUNCTION(gpio14, 0),
+        BM1880_PINMUX_FUNCTION(gpio15, 0),
+        BM1880_PINMUX_FUNCTION(gpio16, 0),
+        BM1880_PINMUX_FUNCTION(gpio17, 0),
+        BM1880_PINMUX_FUNCTION(gpio18, 0),
+        BM1880_PINMUX_FUNCTION(gpio19, 0),
+        BM1880_PINMUX_FUNCTION(gpio20, 0),
+        BM1880_PINMUX_FUNCTION(gpio21, 0),
+        BM1880_PINMUX_FUNCTION(gpio22, 0),
+        BM1880_PINMUX_FUNCTION(gpio23, 0),
+        BM1880_PINMUX_FUNCTION(gpio24, 0),
+        BM1880_PINMUX_FUNCTION(gpio25, 0),
+        BM1880_PINMUX_FUNCTION(gpio26, 0),
+        BM1880_PINMUX_FUNCTION(gpio27, 0),
+        BM1880_PINMUX_FUNCTION(gpio28, 0),
+        BM1880_PINMUX_FUNCTION(gpio29, 0),
+        BM1880_PINMUX_FUNCTION(gpio30, 0),
+        BM1880_PINMUX_FUNCTION(gpio31, 0),
+        BM1880_PINMUX_FUNCTION(gpio32, 0),
+        BM1880_PINMUX_FUNCTION(gpio33, 0),
+        BM1880_PINMUX_FUNCTION(gpio34, 0),
+        BM1880_PINMUX_FUNCTION(gpio35, 0),
+        BM1880_PINMUX_FUNCTION(gpio36, 0),
+        BM1880_PINMUX_FUNCTION(gpio37, 0),
+        BM1880_PINMUX_FUNCTION(gpio38, 0),
+        BM1880_PINMUX_FUNCTION(gpio39, 0),
+        BM1880_PINMUX_FUNCTION(gpio40, 0),
+        BM1880_PINMUX_FUNCTION(gpio41, 0),
+        BM1880_PINMUX_FUNCTION(gpio42, 0),
+        BM1880_PINMUX_FUNCTION(gpio43, 0),
+        BM1880_PINMUX_FUNCTION(gpio44, 0),
+        BM1880_PINMUX_FUNCTION(gpio45, 0),
+        BM1880_PINMUX_FUNCTION(gpio46, 0),
+        BM1880_PINMUX_FUNCTION(gpio47, 0),
+        BM1880_PINMUX_FUNCTION(gpio48, 0),
+        BM1880_PINMUX_FUNCTION(gpio49, 0),
+        BM1880_PINMUX_FUNCTION(gpio50, 0),
+        BM1880_PINMUX_FUNCTION(gpio51, 0),
+        BM1880_PINMUX_FUNCTION(gpio52, 0),
+        BM1880_PINMUX_FUNCTION(gpio53, 0),
+        BM1880_PINMUX_FUNCTION(gpio54, 0),
+        BM1880_PINMUX_FUNCTION(gpio55, 0),
+        BM1880_PINMUX_FUNCTION(gpio56, 0),
+        BM1880_PINMUX_FUNCTION(gpio57, 0),
+        BM1880_PINMUX_FUNCTION(gpio58, 0),
+        BM1880_PINMUX_FUNCTION(gpio59, 0),
+        BM1880_PINMUX_FUNCTION(gpio60, 0),
+        BM1880_PINMUX_FUNCTION(gpio61, 0),
+        BM1880_PINMUX_FUNCTION(gpio62, 0),
+        BM1880_PINMUX_FUNCTION(gpio63, 0),
+        BM1880_PINMUX_FUNCTION(gpio64, 0),
+        BM1880_PINMUX_FUNCTION(gpio65, 0),
+        BM1880_PINMUX_FUNCTION(gpio66, 0),
+        BM1880_PINMUX_FUNCTION(gpio67, 0),
+        BM1880_PINMUX_FUNCTION(eth1, 1),
+        BM1880_PINMUX_FUNCTION(i2s0, 2),
+        BM1880_PINMUX_FUNCTION(i2s0_mclkin, 1),
+        BM1880_PINMUX_FUNCTION(i2s1, 2),
+        BM1880_PINMUX_FUNCTION(i2s1_mclkin, 1),
+        BM1880_PINMUX_FUNCTION(spi0, 1),
+};
+
+#define BM1880_PINCONF_DAT(_width)              \
+        {                                       \
+                .drv_bits = _width,             \
         }
 
-static const struct bm1880_pinmux_function bm1880_pmux_functions[] = {
-        BM1880_PINMUX_FUNCTION(nand, 2, 0x03),
-        BM1880_PINMUX_FUNCTION(spi, 0, 0x03),
-        BM1880_PINMUX_FUNCTION(emmc, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(sdio, 0, 0x03),
-        BM1880_PINMUX_FUNCTION(eth0, 0, 0x03),
-        BM1880_PINMUX_FUNCTION_MUX(pwm0, 2, 0x0F, 0x50, 0x00),
-        BM1880_PINMUX_FUNCTION_MUX(pwm1, 2, 0x0F, 0x50, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(pwm2, 2, 0x0F, 0x50, 0x08),
-        BM1880_PINMUX_FUNCTION_MUX(pwm3, 2, 0x0F, 0x50, 0x0C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm4, 2, 0x0F, 0x50, 0x10),
-        BM1880_PINMUX_FUNCTION_MUX(pwm5, 2, 0x0F, 0x50, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(pwm6, 2, 0x0F, 0x50, 0x18),
-        BM1880_PINMUX_FUNCTION_MUX(pwm7, 2, 0x0F, 0x50, 0x1C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm8, 2, 0x0F, 0x54, 0x00),
-        BM1880_PINMUX_FUNCTION_MUX(pwm9, 2, 0x0F, 0x54, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(pwm10, 2, 0x0F, 0x54, 0x08),
-        BM1880_PINMUX_FUNCTION_MUX(pwm11, 2, 0x0F, 0x54, 0x0C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm12, 2, 0x0F, 0x54, 0x10),
-        BM1880_PINMUX_FUNCTION_MUX(pwm13, 2, 0x0F, 0x54, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(pwm14, 2, 0x0F, 0x54, 0x18),
-        BM1880_PINMUX_FUNCTION_MUX(pwm15, 2, 0x0F, 0x54, 0x1C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm16, 2, 0x0F, 0x58, 0x00),
-        BM1880_PINMUX_FUNCTION_MUX(pwm17, 2, 0x0F, 0x58, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(pwm18, 2, 0x0F, 0x58, 0x08),
-        BM1880_PINMUX_FUNCTION_MUX(pwm19, 2, 0x0F, 0x58, 0x0C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm20, 2, 0x0F, 0x58, 0x10),
-        BM1880_PINMUX_FUNCTION_MUX(pwm21, 2, 0x0F, 0x58, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(pwm22, 2, 0x0F, 0x58, 0x18),
-        BM1880_PINMUX_FUNCTION_MUX(pwm23, 2, 0x0F, 0x58, 0x1C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm24, 2, 0x0F, 0x5C, 0x00),
-        BM1880_PINMUX_FUNCTION_MUX(pwm25, 2, 0x0F, 0x5C, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(pwm26, 2, 0x0F, 0x5C, 0x08),
-        BM1880_PINMUX_FUNCTION_MUX(pwm27, 2, 0x0F, 0x5C, 0x0C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm28, 2, 0x0F, 0x5C, 0x10),
-        BM1880_PINMUX_FUNCTION_MUX(pwm29, 2, 0x0F, 0x5C, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(pwm30, 2, 0x0F, 0x5C, 0x18),
-        BM1880_PINMUX_FUNCTION_MUX(pwm31, 2, 0x0F, 0x5C, 0x1C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm32, 2, 0x0F, 0x60, 0x00),
-        BM1880_PINMUX_FUNCTION_MUX(pwm33, 2, 0x0F, 0x60, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(pwm34, 2, 0x0F, 0x60, 0x08),
-        BM1880_PINMUX_FUNCTION_MUX(pwm35, 2, 0x0F, 0x60, 0x0C),
-        BM1880_PINMUX_FUNCTION_MUX(pwm36, 2, 0x0F, 0x60, 0x10),
-        BM1880_PINMUX_FUNCTION_MUX(pwm37, 2, 0x0F, 0x60, 0x1C),
-        BM1880_PINMUX_FUNCTION(i2c0, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2c1, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2c2, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2c3, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2c4, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart0, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart1, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart2, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart3, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart4, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart5, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart6, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart7, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart8, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart9, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart10, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart11, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(uart12, 3, 0x03),
-        BM1880_PINMUX_FUNCTION(uart13, 3, 0x03),
-        BM1880_PINMUX_FUNCTION(uart14, 3, 0x03),
-        BM1880_PINMUX_FUNCTION(uart15, 3, 0x03),
-        BM1880_PINMUX_FUNCTION_MUX(gpio0, 0, 0x03, 0x4E0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio1, 0, 0x03, 0x4E4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio2, 0, 0x03, 0x4E4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio3, 0, 0x03, 0x4E8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio4, 0, 0x03, 0x4E8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio5, 0, 0x03, 0x4EC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio6, 0, 0x03, 0x4EC, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio7, 0, 0x03, 0x4F0, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio8, 0, 0x03, 0x4F0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio9, 0, 0x03, 0x4F4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio10, 0, 0x03, 0x4F4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio11, 0, 0x03, 0x4F8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio12, 1, 0x03, 0x4F8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio13, 1, 0x03, 0x4FC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio14, 0, 0x03, 0x474, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio15, 0, 0x03, 0x478, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio16, 0, 0x03, 0x478, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio17, 0, 0x03, 0x47C, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio18, 0, 0x03, 0x47C, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio19, 0, 0x03, 0x480, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio20, 0, 0x03, 0x480, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio21, 0, 0x03, 0x484, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio22, 0, 0x03, 0x484, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio23, 0, 0x03, 0x488, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio24, 0, 0x03, 0x488, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio25, 0, 0x03, 0x48C, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio26, 0, 0x03, 0x48C, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio27, 0, 0x03, 0x490, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio28, 0, 0x03, 0x490, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio29, 0, 0x03, 0x494, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio30, 0, 0x03, 0x494, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio31, 0, 0x03, 0x498, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio32, 0, 0x03, 0x498, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio33, 0, 0x03, 0x49C, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio34, 0, 0x03, 0x49C, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio35, 0, 0x03, 0x4A0, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio36, 0, 0x03, 0x4A0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio37, 0, 0x03, 0x4A4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio38, 0, 0x03, 0x4A4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio39, 0, 0x03, 0x4A8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio40, 0, 0x03, 0x4A8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio41, 0, 0x03, 0x4AC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio42, 0, 0x03, 0x4AC, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio43, 0, 0x03, 0x4B0, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio44, 0, 0x03, 0x4B0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio45, 0, 0x03, 0x4B4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio46, 0, 0x03, 0x4B4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio47, 0, 0x03, 0x4B8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio48, 0, 0x03, 0x4B8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio49, 0, 0x03, 0x4BC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio50, 0, 0x03, 0x4BC, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio51, 0, 0x03, 0x4C0, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio52, 0, 0x03, 0x4C0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio53, 0, 0x03, 0x4C4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio54, 0, 0x03, 0x4C4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio55, 0, 0x03, 0x4C8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio56, 0, 0x03, 0x4C8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio57, 0, 0x03, 0x4CC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio58, 0, 0x03, 0x4CC, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio59, 0, 0x03, 0x4D0, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio60, 0, 0x03, 0x4D0, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio61, 0, 0x03, 0x4D4, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio62, 0, 0x03, 0x4D4, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio63, 0, 0x03, 0x4D8, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio64, 0, 0x03, 0x4D8, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio65, 0, 0x03, 0x4DC, 0x04),
-        BM1880_PINMUX_FUNCTION_MUX(gpio66, 0, 0x03, 0x4DC, 0x14),
-        BM1880_PINMUX_FUNCTION_MUX(gpio67, 0, 0x03, 0x4E0, 0x04),
-        BM1880_PINMUX_FUNCTION(eth1, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2s0, 2, 0x03),
-        BM1880_PINMUX_FUNCTION(i2s0_mclkin, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(i2s1, 2, 0x03),
-        BM1880_PINMUX_FUNCTION(i2s1_mclkin, 1, 0x03),
-        BM1880_PINMUX_FUNCTION(spi0, 1, 0x03),
+static const struct bm1880_pinconf_data bm1880_pinconf[] = {
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x03),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
+        BM1880_PINCONF_DAT(0x02),
 };
 
 static int bm1880_pctrl_get_groups_count(struct pinctrl_dev *pctldev)
@@ -870,33 +986,308 @@ static int bm1880_pinmux_set_mux(struct pinctrl_dev *pctldev,
         const struct bm1880_pinmux_function *func = &pctrl->funcs[function];
         int i;
 
-        if (func->mux) {
+        for (i = 0; i < pgrp->npins; i++) {
+                unsigned int pin = pgrp->pins[i];
+                u32 offset = (pin >> 1) << 2;
+                u32 mux_offset = ((!((pin + 1) & 1) << 4) + 4);
                 u32 regval = readl_relaxed(pctrl->base + BM1880_REG_MUX +
-                                           func->mux);
+                                           offset);
+
+                regval &= ~(0x03 << mux_offset);
+                regval |= func->mux_val << mux_offset;
+
+                writel_relaxed(regval, pctrl->base + BM1880_REG_MUX + offset);
+        }
+
+        return 0;
+}
+
+#define BM1880_PINCONF(pin, idx) ((!((pin + 1) & 1) << 4) + idx)
+#define BM1880_PINCONF_PULLCTRL(pin)    BM1880_PINCONF(pin, 0)
+#define BM1880_PINCONF_PULLUP(pin)      BM1880_PINCONF(pin, 1)
+#define BM1880_PINCONF_PULLDOWN(pin)    BM1880_PINCONF(pin, 2)
+#define BM1880_PINCONF_DRV(pin)         BM1880_PINCONF(pin, 6)
+#define BM1880_PINCONF_SCHMITT(pin)     BM1880_PINCONF(pin, 9)
+#define BM1880_PINCONF_SLEW(pin)        BM1880_PINCONF(pin, 10)
+
+static int bm1880_pinconf_drv_set(unsigned int mA, u32 width,
+                                  u32 *regval, u32 bit_offset)
+{
+        u32 _regval;
+
+        _regval = *regval;
+
+        /*
+         * There are two sets of drive strength bit width exposed by the
+         * SoC at 4mA step, hence we need to handle them separately.
+         */
+        if (width == 0x03) {
+                switch (mA) {
+                case 4:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (0 << bit_offset);
+                        break;
+                case 8:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (1 << bit_offset);
+                        break;
+                case 12:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (2 << bit_offset);
+                        break;
+                case 16:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (3 << bit_offset);
+                        break;
+                case 20:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (4 << bit_offset);
+                        break;
+                case 24:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (5 << bit_offset);
+                        break;
+                case 28:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (6 << bit_offset);
+                        break;
+                case 32:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (7 << bit_offset);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        } else {
+                switch (mA) {
+                case 4:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (0 << bit_offset);
+                        break;
+                case 8:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (1 << bit_offset);
+                        break;
+                case 12:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (2 << bit_offset);
+                        break;
+                case 16:
+                        _regval &= ~(width << bit_offset);
+                        _regval |= (3 << bit_offset);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        *regval = _regval;
+
+        return 0;
+}
+
+static int bm1880_pinconf_drv_get(u32 width, u32 drv)
+{
+        int ret = -ENOTSUPP;
 
-                regval &= ~(func->mux_mask << func->mux_shift);
-                regval |= func->mux_val << func->mux_shift;
-                writel_relaxed(regval, pctrl->base + BM1880_REG_MUX +
-                               func->mux);
+        /*
+         * There are two sets of drive strength bit width exposed by the
+         * SoC at 4mA step, hence we need to handle them separately.
+         */
+        if (width == 0x03) {
+                switch (drv) {
+                case 0:
+                        ret  = 4;
+                        break;
+                case 1:
+                        ret  = 8;
+                        break;
+                case 2:
+                        ret  = 12;
+                        break;
+                case 3:
+                        ret  = 16;
+                        break;
+                case 4:
+                        ret  = 20;
+                        break;
+                case 5:
+                        ret  = 24;
+                        break;
+                case 6:
+                        ret  = 28;
+                        break;
+                case 7:
+                        ret  = 32;
+                        break;
+                default:
+                        break;
+                }
         } else {
-                for (i = 0; i < pgrp->npins; i++) {
-                        unsigned int pin = pgrp->pins[i];
-                        u32 offset = (pin >> 1) << 2;
-                        u32 mux_offset = ((!((pin + 1) & 1) << 4) + 4);
-                        u32 regval = readl_relaxed(pctrl->base +
-                                                   BM1880_REG_MUX + offset);
-
-                        regval &= ~(func->mux_mask << mux_offset);
-                        regval |= func->mux_val << mux_offset;
-
-                        writel_relaxed(regval, pctrl->base +
-                                       BM1880_REG_MUX + offset);
+                switch (drv) {
+                case 0:
+                        ret  = 4;
+                        break;
+                case 1:
+                        ret  = 8;
+                        break;
+                case 2:
+                        ret  = 12;
+                        break;
+                case 3:
+                        ret  = 16;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        return ret;
+}
+
+static int bm1880_pinconf_cfg_get(struct pinctrl_dev *pctldev,
+                                  unsigned int pin,
+                                  unsigned long *config)
+{
+        struct bm1880_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        unsigned int param = pinconf_to_config_param(*config);
+        unsigned int arg = 0;
+        u32 regval, offset, bit_offset;
+        int ret;
+
+        offset = (pin >> 1) << 2;
+        regval = readl_relaxed(pctrl->base + BM1880_REG_MUX + offset);
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_PULL_UP:
+                bit_offset = BM1880_PINCONF_PULLUP(pin);
+                arg = !!(regval & BIT(bit_offset));
+                break;
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                bit_offset = BM1880_PINCONF_PULLDOWN(pin);
+                arg = !!(regval & BIT(bit_offset));
+                break;
+        case PIN_CONFIG_BIAS_DISABLE:
+                bit_offset = BM1880_PINCONF_PULLCTRL(pin);
+                arg = !!(regval & BIT(bit_offset));
+                break;
+        case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
+                bit_offset = BM1880_PINCONF_SCHMITT(pin);
+                arg = !!(regval & BIT(bit_offset));
+                break;
+        case PIN_CONFIG_SLEW_RATE:
+                bit_offset = BM1880_PINCONF_SLEW(pin);
+                arg = !!(regval & BIT(bit_offset));
+                break;
+        case PIN_CONFIG_DRIVE_STRENGTH:
+                bit_offset = BM1880_PINCONF_DRV(pin);
+                ret = bm1880_pinconf_drv_get(pctrl->pinconf[pin].drv_bits,
+                                             !!(regval & BIT(bit_offset)));
+                if (ret < 0)
+                        return ret;
+
+                arg = ret;
+                break;
+        default:
+                return -ENOTSUPP;
+        }
+
+        *config = pinconf_to_config_packed(param, arg);
+
+        return 0;
+}
+
+static int bm1880_pinconf_cfg_set(struct pinctrl_dev *pctldev,
+                                  unsigned int pin,
+                                  unsigned long *configs,
+                                  unsigned int num_configs)
+{
+        struct bm1880_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        u32 regval, offset, bit_offset;
+        int i, ret;
+
+        offset = (pin >> 1) << 2;
+        regval = readl_relaxed(pctrl->base + BM1880_REG_MUX + offset);
+
+        for (i = 0; i < num_configs; i++) {
+                unsigned int param = pinconf_to_config_param(configs[i]);
+                unsigned int arg = pinconf_to_config_argument(configs[i]);
+
+                switch (param) {
+                case PIN_CONFIG_BIAS_PULL_UP:
+                        bit_offset = BM1880_PINCONF_PULLUP(pin);
+                        regval |= BIT(bit_offset);
+                        break;
+                case PIN_CONFIG_BIAS_PULL_DOWN:
+                        bit_offset = BM1880_PINCONF_PULLDOWN(pin);
+                        regval |= BIT(bit_offset);
+                        break;
+                case PIN_CONFIG_BIAS_DISABLE:
+                        bit_offset = BM1880_PINCONF_PULLCTRL(pin);
+                        regval |= BIT(bit_offset);
+                        break;
+                case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
+                        bit_offset = BM1880_PINCONF_SCHMITT(pin);
+                        if (arg)
+                                regval |= BIT(bit_offset);
+                        else
+                                regval &= ~BIT(bit_offset);
+                        break;
+                case PIN_CONFIG_SLEW_RATE:
+                        bit_offset = BM1880_PINCONF_SLEW(pin);
+                        if (arg)
+                                regval |= BIT(bit_offset);
+                        else
+                                regval &= ~BIT(bit_offset);
+                        break;
+                case PIN_CONFIG_DRIVE_STRENGTH:
+                        bit_offset = BM1880_PINCONF_DRV(pin);
+                        ret = bm1880_pinconf_drv_set(arg,
+                                                pctrl->pinconf[pin].drv_bits,
+                                                &regval, bit_offset);
+                        if (ret < 0)
+                                return ret;
+
+                        break;
+                default:
+                        dev_warn(pctldev->dev,
+                                 "unsupported configuration parameter '%u'\n",
+                                 param);
+                        continue;
                 }
+
+                writel_relaxed(regval, pctrl->base + BM1880_REG_MUX + offset);
         }
 
         return 0;
 }
 
+static int bm1880_pinconf_group_set(struct pinctrl_dev *pctldev,
+                                    unsigned int selector,
+                                    unsigned long *configs,
+                                    unsigned int  num_configs)
+{
+        int i, ret;
+        struct bm1880_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        const struct bm1880_pctrl_group *pgrp = &pctrl->groups[selector];
+
+        for (i = 0; i < pgrp->npins; i++) {
+                ret = bm1880_pinconf_cfg_set(pctldev, pgrp->pins[i], configs,
+                                             num_configs);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static const struct pinconf_ops bm1880_pinconf_ops = {
+        .is_generic = true,
+        .pin_config_get = bm1880_pinconf_cfg_get,
+        .pin_config_set = bm1880_pinconf_cfg_set,
+        .pin_config_group_set = bm1880_pinconf_group_set,
+};
+
 static const struct pinmux_ops bm1880_pinmux_ops = {
         .get_functions_count = bm1880_pmux_get_functions_count,
         .get_function_name = bm1880_pmux_get_function_name,
@@ -910,6 +1301,7 @@ static struct pinctrl_desc bm1880_desc = {
         .npins = ARRAY_SIZE(bm1880_pins),
         .pctlops = &bm1880_pctrl_ops,
         .pmxops = &bm1880_pinmux_ops,
+        .confops = &bm1880_pinconf_ops,
         .owner = THIS_MODULE,
 };
 
@@ -932,6 +1324,7 @@ static int bm1880_pinctrl_probe(struct platform_device *pdev)
         pctrl->ngroups = ARRAY_SIZE(bm1880_pctrl_groups);
         pctrl->funcs = bm1880_pmux_functions;
         pctrl->nfuncs = ARRAY_SIZE(bm1880_pmux_functions);
+        pctrl->pinconf = bm1880_pinconf;
 
         pctrl->pctrldev = devm_pinctrl_register(&pdev->dev, &bm1880_desc,
                                                 pctrl);
diff --git a/drivers/pinctrl/pinctrl-rockchip.c b/drivers/pinctrl/pinctrl-rockchip.c
index 807a3263d849..62a622159006 100644
--- a/drivers/pinctrl/pinctrl-rockchip.c
+++ b/drivers/pinctrl/pinctrl-rockchip.c
@@ -3204,6 +3204,7 @@ static int rockchip_get_bank_data(struct rockchip_pin_bank *bank,
                                                     base,
                                                     &rockchip_regmap_config);
                 }
+                of_node_put(node);
         }
 
         bank->irq = irq_of_parse_and_map(bank->of_node, 0);
diff --git a/drivers/pinctrl/pinctrl-stmfx.c b/drivers/pinctrl/pinctrl-stmfx.c
index eba872ce4a7c..d3332da35637 100644
--- a/drivers/pinctrl/pinctrl-stmfx.c
+++ b/drivers/pinctrl/pinctrl-stmfx.c
@@ -622,6 +622,7 @@ static int stmfx_pinctrl_probe(struct platform_device *pdev)
         pctl->pctl_desc.pins = stmfx_pins;
         pctl->pctl_desc.npins = ARRAY_SIZE(stmfx_pins);
         pctl->pctl_desc.owner = THIS_MODULE;
+        pctl->pctl_desc.link_consumers = true;
 
         ret = devm_pinctrl_register_and_init(pctl->dev, &pctl->pctl_desc,
                                              pctl, &pctl->pctl_dev);
diff --git a/drivers/pinctrl/pinctrl-tb10x.c b/drivers/pinctrl/pinctrl-tb10x.c
index 02b43f559e83..1f64e2e7efd9 100644
--- a/drivers/pinctrl/pinctrl-tb10x.c
+++ b/drivers/pinctrl/pinctrl-tb10x.c
@@ -471,22 +471,22 @@ struct tb10x_port {
  * @base: register set base address.
  * @pingroups: pointer to an array of the pin groups this driver manages.
  * @pinfuncgrpcnt: number of pingroups in @pingroups.
- * @pinfuncs: pointer to an array of pin functions this driver manages.
  * @pinfuncnt: number of pin functions in @pinfuncs.
  * @mutex: mutex for exclusive access to a pin controller's state.
  * @ports: current state of each port.
  * @gpios: Indicates if a given pin is currently used as GPIO (1) or not (0).
+ * @pinfuncs: flexible array of pin functions this driver manages.
  */
 struct tb10x_pinctrl {
         struct pinctrl_dev *pctl;
         void *base;
         const struct tb10x_pinfuncgrp *pingroups;
         unsigned int pinfuncgrpcnt;
-        struct tb10x_of_pinfunc *pinfuncs;
         unsigned int pinfuncnt;
         struct mutex mutex;
         struct tb10x_port ports[TB10X_PORTS];
         DECLARE_BITMAP(gpios, MAX_PIN + 1);
+        struct tb10x_of_pinfunc pinfuncs[];
 };
 
 static inline void tb10x_pinctrl_set_config(struct tb10x_pinctrl *state,
@@ -759,15 +759,13 @@ static int tb10x_pinctrl_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        state = devm_kzalloc(dev, sizeof(struct tb10x_pinctrl) +
-                                        of_get_child_count(of_node)
-                                        * sizeof(struct tb10x_of_pinfunc),
-                                GFP_KERNEL);
+        state = devm_kzalloc(dev, struct_size(state, pinfuncs,
+                                              of_get_child_count(of_node)),
+                             GFP_KERNEL);
         if (!state)
                 return -ENOMEM;
 
         platform_set_drvdata(pdev, state);
-        state->pinfuncs = (struct tb10x_of_pinfunc *)(state + 1);
         mutex_init(&state->mutex);
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/pinctrl/qcom/Kconfig b/drivers/pinctrl/qcom/Kconfig
index 890d0a3a790b..8e14a5f2e970 100644
--- a/drivers/pinctrl/qcom/Kconfig
+++ b/drivers/pinctrl/qcom/Kconfig
@@ -169,11 +169,20 @@ config PINCTRL_SDM660
 
 config PINCTRL_SDM845
        tristate "Qualcomm Technologies Inc SDM845 pin controller driver"
-       depends on GPIOLIB && OF
+       depends on GPIOLIB && (OF || ACPI)
        select PINCTRL_MSM
        help
          This is the pinctrl, pinmux, pinconf and gpiolib driver for the
          Qualcomm Technologies Inc TLMM block found on the Qualcomm
          Technologies Inc SDM845 platform.
 
+config PINCTRL_SM8150
+       tristate "Qualcomm Technologies Inc SM8150 pin controller driver"
+       depends on GPIOLIB && OF
+       select PINCTRL_MSM
+       help
+         This is the pinctrl, pinmux, pinconf and gpiolib driver for the
+         Qualcomm Technologies Inc TLMM block found on the Qualcomm
+         Technologies Inc SM8150 platform.
+
 endif
diff --git a/drivers/pinctrl/qcom/Makefile b/drivers/pinctrl/qcom/Makefile
index 344b4c6a6c6e..ebe906872272 100644
--- a/drivers/pinctrl/qcom/Makefile
+++ b/drivers/pinctrl/qcom/Makefile
@@ -22,3 +22,4 @@ obj-$(CONFIG_PINCTRL_QCOM_SSBI_PMIC) += pinctrl-ssbi-gpio.o
 obj-$(CONFIG_PINCTRL_QCOM_SSBI_PMIC) += pinctrl-ssbi-mpp.o
 obj-$(CONFIG_PINCTRL_SDM660)   += pinctrl-sdm660.o
 obj-$(CONFIG_PINCTRL_SDM845) += pinctrl-sdm845.o
+obj-$(CONFIG_PINCTRL_SM8150) += pinctrl-sm8150.o
diff --git a/drivers/pinctrl/qcom/pinctrl-msm.c b/drivers/pinctrl/qcom/pinctrl-msm.c
index 6e319bcc2326..7f35c196bb3e 100644
--- a/drivers/pinctrl/qcom/pinctrl-msm.c
+++ b/drivers/pinctrl/qcom/pinctrl-msm.c
@@ -599,8 +599,23 @@ static int msm_gpio_init_valid_mask(struct gpio_chip *chip)
         int ret;
         unsigned int len, i;
         unsigned int max_gpios = pctrl->soc->ngpios;
+        const int *reserved = pctrl->soc->reserved_gpios;
         u16 *tmp;
 
+        /* Driver provided reserved list overrides DT and ACPI */
+        if (reserved) {
+                bitmap_fill(chip->valid_mask, max_gpios);
+                for (i = 0; reserved[i] >= 0; i++) {
+                        if (i >= max_gpios || reserved[i] >= max_gpios) {
+                                dev_err(pctrl->dev, "invalid list of reserved GPIOs\n");
+                                return -EINVAL;
+                        }
+                        clear_bit(reserved[i], chip->valid_mask);
+                }
+
+                return 0;
+        }
+
         /* The number of GPIOs in the ACPI tables */
         len = ret = device_property_read_u16_array(pctrl->dev, "gpios", NULL,
                                                    0);
@@ -729,7 +744,7 @@ static void msm_gpio_irq_mask(struct irq_data *d)
         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 }
 
-static void msm_gpio_irq_unmask(struct irq_data *d)
+static void msm_gpio_irq_clear_unmask(struct irq_data *d, bool status_clear)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct msm_pinctrl *pctrl = gpiochip_get_data(gc);
@@ -741,6 +756,17 @@ static void msm_gpio_irq_unmask(struct irq_data *d)
 
         raw_spin_lock_irqsave(&pctrl->lock, flags);
 
+        if (status_clear) {
+                /*
+                 * clear the interrupt status bit before unmask to avoid
+                 * any erroneous interrupts that would have got latched
+                 * when the interrupt is not in use.
+                 */
+                val = msm_readl_intr_status(pctrl, g);
+                val &= ~BIT(g->intr_status_bit);
+                msm_writel_intr_status(val, pctrl, g);
+        }
+
         val = msm_readl_intr_cfg(pctrl, g);
         val |= BIT(g->intr_raw_status_bit);
         val |= BIT(g->intr_enable_bit);
@@ -751,6 +777,17 @@ static void msm_gpio_irq_unmask(struct irq_data *d)
         raw_spin_unlock_irqrestore(&pctrl->lock, flags);
 }
 
+static void msm_gpio_irq_enable(struct irq_data *d)
+{
+
+        msm_gpio_irq_clear_unmask(d, true);
+}
+
+static void msm_gpio_irq_unmask(struct irq_data *d)
+{
+        msm_gpio_irq_clear_unmask(d, false);
+}
+
 static void msm_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
@@ -956,6 +993,9 @@ static void msm_gpio_irq_handler(struct irq_desc *desc)
 
 static bool msm_gpio_needs_valid_mask(struct msm_pinctrl *pctrl)
 {
+        if (pctrl->soc->reserved_gpios)
+                return true;
+
         return device_property_read_u16_array(pctrl->dev, "gpios", NULL, 0) > 0;
 }
 
@@ -978,6 +1018,7 @@ static int msm_gpio_init(struct msm_pinctrl *pctrl)
         chip->need_valid_mask = msm_gpio_needs_valid_mask(pctrl);
 
         pctrl->irq_chip.name = "msmgpio";
+        pctrl->irq_chip.irq_enable = msm_gpio_irq_enable;
         pctrl->irq_chip.irq_mask = msm_gpio_irq_mask;
         pctrl->irq_chip.irq_unmask = msm_gpio_irq_unmask;
         pctrl->irq_chip.irq_ack = msm_gpio_irq_ack;
diff --git a/drivers/pinctrl/qcom/pinctrl-msm.h b/drivers/pinctrl/qcom/pinctrl-msm.h
index b724581c605c..48569cda8471 100644
--- a/drivers/pinctrl/qcom/pinctrl-msm.h
+++ b/drivers/pinctrl/qcom/pinctrl-msm.h
@@ -113,6 +113,7 @@ struct msm_pinctrl_soc_data {
         bool pull_no_keeper;
         const char *const *tiles;
         unsigned int ntiles;
+        const int *reserved_gpios;
 };
 
 extern const struct dev_pm_ops msm_pinctrl_dev_pm_ops;
diff --git a/drivers/pinctrl/qcom/pinctrl-sdm845.c b/drivers/pinctrl/qcom/pinctrl-sdm845.c
index c97f20fca5fd..39f498c09906 100644
--- a/drivers/pinctrl/qcom/pinctrl-sdm845.c
+++ b/drivers/pinctrl/qcom/pinctrl-sdm845.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
  */
 
+#include <linux/acpi.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
@@ -420,10 +421,10 @@ DECLARE_MSM_GPIO_PINS(147);
 DECLARE_MSM_GPIO_PINS(148);
 DECLARE_MSM_GPIO_PINS(149);
 
-static const unsigned int sdc2_clk_pins[] = { 150 };
-static const unsigned int sdc2_cmd_pins[] = { 151 };
-static const unsigned int sdc2_data_pins[] = { 152 };
-static const unsigned int ufs_reset_pins[] = { 153 };
+static const unsigned int ufs_reset_pins[] = { 150 };
+static const unsigned int sdc2_clk_pins[] = { 151 };
+static const unsigned int sdc2_cmd_pins[] = { 152 };
+static const unsigned int sdc2_data_pins[] = { 153 };
 
 enum sdm845_functions {
         msm_mux_gpio,
@@ -1271,10 +1272,14 @@ static const struct msm_pingroup sdm845_groups[] = {
         PINGROUP(147, NORTH, _, _, _, _, _, _, _, _, _, _),
         PINGROUP(148, NORTH, _, _, _, _, _, _, _, _, _, _),
         PINGROUP(149, NORTH, _, _, _, _, _, _, _, _, _, _),
+        UFS_RESET(ufs_reset, 0x99f000),
         SDC_QDSD_PINGROUP(sdc2_clk, 0x99a000, 14, 6),
         SDC_QDSD_PINGROUP(sdc2_cmd, 0x99a000, 11, 3),
         SDC_QDSD_PINGROUP(sdc2_data, 0x99a000, 9, 0),
-        UFS_RESET(ufs_reset, 0x99f000),
+};
+
+static const int sdm845_acpi_reserved_gpios[] = {
+        0, 1, 2, 3, 81, 82, 83, 84, -1
 };
 
 static const struct msm_pinctrl_soc_data sdm845_pinctrl = {
@@ -1284,14 +1289,42 @@ static const struct msm_pinctrl_soc_data sdm845_pinctrl = {
         .nfunctions = ARRAY_SIZE(sdm845_functions),
         .groups = sdm845_groups,
         .ngroups = ARRAY_SIZE(sdm845_groups),
+        .ngpios = 151,
+};
+
+static const struct msm_pinctrl_soc_data sdm845_acpi_pinctrl = {
+        .pins = sdm845_pins,
+        .npins = ARRAY_SIZE(sdm845_pins),
+        .groups = sdm845_groups,
+        .ngroups = ARRAY_SIZE(sdm845_groups),
+        .reserved_gpios = sdm845_acpi_reserved_gpios,
         .ngpios = 150,
 };
 
 static int sdm845_pinctrl_probe(struct platform_device *pdev)
 {
-        return msm_pinctrl_probe(pdev, &sdm845_pinctrl);
+        int ret;
+
+        if (pdev->dev.of_node) {
+                ret = msm_pinctrl_probe(pdev, &sdm845_pinctrl);
+        } else if (has_acpi_companion(&pdev->dev)) {
+                ret = msm_pinctrl_probe(pdev, &sdm845_acpi_pinctrl);
+        } else {
+                dev_err(&pdev->dev, "DT and ACPI disabled\n");
+                return -EINVAL;
+        }
+
+        return ret;
 }
 
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id sdm845_pinctrl_acpi_match[] = {
+        { "QCOM0217"},
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, sdm845_pinctrl_acpi_match);
+#endif
+
 static const struct of_device_id sdm845_pinctrl_of_match[] = {
         { .compatible = "qcom,sdm845-pinctrl", },
         { },
@@ -1302,6 +1335,7 @@ static struct platform_driver sdm845_pinctrl_driver = {
                 .name = "sdm845-pinctrl",
                 .pm = &msm_pinctrl_dev_pm_ops,
                 .of_match_table = sdm845_pinctrl_of_match,
+                .acpi_match_table = ACPI_PTR(sdm845_pinctrl_acpi_match),
         },
         .probe = sdm845_pinctrl_probe,
         .remove = msm_pinctrl_remove,
diff --git a/drivers/pinctrl/qcom/pinctrl-sm8150.c b/drivers/pinctrl/qcom/pinctrl-sm8150.c
new file mode 100644
index 000000000000..7359bae68c69
--- /dev/null
+++ b/drivers/pinctrl/qcom/pinctrl-sm8150.c
@@ -0,0 +1,1548 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
+
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pinctrl/pinctrl.h>
+
+#include "pinctrl-msm.h"
+
+static const char * const sm8150_tiles[] = {
+        "north",
+        "south",
+        "east",
+        "west"
+};
+
+enum {
+        NORTH,
+        SOUTH,
+        EAST,
+        WEST
+};
+
+#define FUNCTION(fname)                                 \
+        [msm_mux_##fname] = {                           \
+                .name = #fname,                         \
+                .groups = fname##_groups,               \
+                .ngroups = ARRAY_SIZE(fname##_groups),  \
+        }
+
+#define PINGROUP(id, _tile, f1, f2, f3, f4, f5, f6, f7, f8, f9) \
+        {                                               \
+                .name = "gpio" #id,                     \
+                .pins = gpio##id##_pins,                \
+                .npins = (unsigned int)ARRAY_SIZE(gpio##id##_pins),     \
+                .funcs = (int[]){                       \
+                        msm_mux_gpio, /* gpio mode */   \
+                        msm_mux_##f1,                   \
+                        msm_mux_##f2,                   \
+                        msm_mux_##f3,                   \
+                        msm_mux_##f4,                   \
+                        msm_mux_##f5,                   \
+                        msm_mux_##f6,                   \
+                        msm_mux_##f7,                   \
+                        msm_mux_##f8,                   \
+                        msm_mux_##f9                    \
+                },                                      \
+                .nfuncs = 10,                           \
+                .ctl_reg = 0x1000 * id,         \
+                .io_reg = 0x1000 * id + 0x4,            \
+                .intr_cfg_reg = 0x1000 * id + 0x8,      \
+                .intr_status_reg = 0x1000 * id + 0xc,   \
+                .intr_target_reg = 0x1000 * id + 0x8,   \
+                .tile = _tile,                  \
+                .mux_bit = 2,                   \
+                .pull_bit = 0,                  \
+                .drv_bit = 6,                   \
+                .oe_bit = 9,                    \
+                .in_bit = 0,                    \
+                .out_bit = 1,                   \
+                .intr_enable_bit = 0,           \
+                .intr_status_bit = 0,           \
+                .intr_target_bit = 5,           \
+                .intr_target_kpss_val = 3,      \
+                .intr_raw_status_bit = 4,       \
+                .intr_polarity_bit = 1,         \
+                .intr_detection_bit = 2,        \
+                .intr_detection_width = 2,      \
+        }
+
+#define SDC_QDSD_PINGROUP(pg_name, ctl, pull, drv)      \
+        {                                               \
+                .name = #pg_name,                       \
+                .pins = pg_name##_pins,                 \
+                .npins = (unsigned int)ARRAY_SIZE(pg_name##_pins),      \
+                .ctl_reg = ctl,                         \
+                .io_reg = 0,                            \
+                .intr_cfg_reg = 0,                      \
+                .intr_status_reg = 0,                   \
+                .intr_target_reg = 0,                   \
+                .tile = NORTH,                          \
+                .mux_bit = -1,                          \
+                .pull_bit = pull,                       \
+                .drv_bit = drv,                         \
+                .oe_bit = -1,                           \
+                .in_bit = -1,                           \
+                .out_bit = -1,                          \
+                .intr_enable_bit = -1,                  \
+                .intr_status_bit = -1,                  \
+                .intr_target_bit = -1,                  \
+                .intr_raw_status_bit = -1,              \
+                .intr_polarity_bit = -1,                \
+                .intr_detection_bit = -1,               \
+                .intr_detection_width = -1,             \
+        }
+
+#define UFS_RESET(pg_name, offset)                              \
+        {                                               \
+                .name = #pg_name,                       \
+                .pins = pg_name##_pins,                 \
+                .npins = (unsigned int)ARRAY_SIZE(pg_name##_pins),      \
+                .ctl_reg = offset,                      \
+                .io_reg = offset + 0x4,                 \
+                .intr_cfg_reg = 0,                      \
+                .intr_status_reg = 0,                   \
+                .intr_target_reg = 0,                   \
+                .tile = SOUTH,                          \
+                .mux_bit = -1,                          \
+                .pull_bit = 3,                          \
+                .drv_bit = 0,                           \
+                .oe_bit = -1,                           \
+                .in_bit = -1,                           \
+                .out_bit = 0,                           \
+                .intr_enable_bit = -1,                  \
+                .intr_status_bit = -1,                  \
+                .intr_target_bit = -1,                  \
+                .intr_raw_status_bit = -1,              \
+                .intr_polarity_bit = -1,                \
+                .intr_detection_bit = -1,               \
+                .intr_detection_width = -1,             \
+        }
+
+static const struct pinctrl_pin_desc sm8150_pins[] = {
+        PINCTRL_PIN(0, "GPIO_0"),
+        PINCTRL_PIN(1, "GPIO_1"),
+        PINCTRL_PIN(2, "GPIO_2"),
+        PINCTRL_PIN(3, "GPIO_3"),
+        PINCTRL_PIN(4, "GPIO_4"),
+        PINCTRL_PIN(5, "GPIO_5"),
+        PINCTRL_PIN(6, "GPIO_6"),
+        PINCTRL_PIN(7, "GPIO_7"),
+        PINCTRL_PIN(8, "GPIO_8"),
+        PINCTRL_PIN(9, "GPIO_9"),
+        PINCTRL_PIN(10, "GPIO_10"),
+        PINCTRL_PIN(11, "GPIO_11"),
+        PINCTRL_PIN(12, "GPIO_12"),
+        PINCTRL_PIN(13, "GPIO_13"),
+        PINCTRL_PIN(14, "GPIO_14"),
+        PINCTRL_PIN(15, "GPIO_15"),
+        PINCTRL_PIN(16, "GPIO_16"),
+        PINCTRL_PIN(17, "GPIO_17"),
+        PINCTRL_PIN(18, "GPIO_18"),
+        PINCTRL_PIN(19, "GPIO_19"),
+        PINCTRL_PIN(20, "GPIO_20"),
+        PINCTRL_PIN(21, "GPIO_21"),
+        PINCTRL_PIN(22, "GPIO_22"),
+        PINCTRL_PIN(23, "GPIO_23"),
+        PINCTRL_PIN(24, "GPIO_24"),
+        PINCTRL_PIN(25, "GPIO_25"),
+        PINCTRL_PIN(26, "GPIO_26"),
+        PINCTRL_PIN(27, "GPIO_27"),
+        PINCTRL_PIN(28, "GPIO_28"),
+        PINCTRL_PIN(29, "GPIO_29"),
+        PINCTRL_PIN(30, "GPIO_30"),
+        PINCTRL_PIN(31, "GPIO_31"),
+        PINCTRL_PIN(32, "GPIO_32"),
+        PINCTRL_PIN(33, "GPIO_33"),
+        PINCTRL_PIN(34, "GPIO_34"),
+        PINCTRL_PIN(35, "GPIO_35"),
+        PINCTRL_PIN(36, "GPIO_36"),
+        PINCTRL_PIN(37, "GPIO_37"),
+        PINCTRL_PIN(38, "GPIO_38"),
+        PINCTRL_PIN(39, "GPIO_39"),
+        PINCTRL_PIN(40, "GPIO_40"),
+        PINCTRL_PIN(41, "GPIO_41"),
+        PINCTRL_PIN(42, "GPIO_42"),
+        PINCTRL_PIN(43, "GPIO_43"),
+        PINCTRL_PIN(44, "GPIO_44"),
+        PINCTRL_PIN(45, "GPIO_45"),
+        PINCTRL_PIN(46, "GPIO_46"),
+        PINCTRL_PIN(47, "GPIO_47"),
+        PINCTRL_PIN(48, "GPIO_48"),
+        PINCTRL_PIN(49, "GPIO_49"),
+        PINCTRL_PIN(50, "GPIO_50"),
+        PINCTRL_PIN(51, "GPIO_51"),
+        PINCTRL_PIN(52, "GPIO_52"),
+        PINCTRL_PIN(53, "GPIO_53"),
+        PINCTRL_PIN(54, "GPIO_54"),
+        PINCTRL_PIN(55, "GPIO_55"),
+        PINCTRL_PIN(56, "GPIO_56"),
+        PINCTRL_PIN(57, "GPIO_57"),
+        PINCTRL_PIN(58, "GPIO_58"),
+        PINCTRL_PIN(59, "GPIO_59"),
+        PINCTRL_PIN(60, "GPIO_60"),
+        PINCTRL_PIN(61, "GPIO_61"),
+        PINCTRL_PIN(62, "GPIO_62"),
+        PINCTRL_PIN(63, "GPIO_63"),
+        PINCTRL_PIN(64, "GPIO_64"),
+        PINCTRL_PIN(65, "GPIO_65"),
+        PINCTRL_PIN(66, "GPIO_66"),
+        PINCTRL_PIN(67, "GPIO_67"),
+        PINCTRL_PIN(68, "GPIO_68"),
+        PINCTRL_PIN(69, "GPIO_69"),
+        PINCTRL_PIN(70, "GPIO_70"),
+        PINCTRL_PIN(71, "GPIO_71"),
+        PINCTRL_PIN(72, "GPIO_72"),
+        PINCTRL_PIN(73, "GPIO_73"),
+        PINCTRL_PIN(74, "GPIO_74"),
+        PINCTRL_PIN(75, "GPIO_75"),
+        PINCTRL_PIN(76, "GPIO_76"),
+        PINCTRL_PIN(77, "GPIO_77"),
+        PINCTRL_PIN(78, "GPIO_78"),
+        PINCTRL_PIN(79, "GPIO_79"),
+        PINCTRL_PIN(80, "GPIO_80"),
+        PINCTRL_PIN(81, "GPIO_81"),
+        PINCTRL_PIN(82, "GPIO_82"),
+        PINCTRL_PIN(83, "GPIO_83"),
+        PINCTRL_PIN(84, "GPIO_84"),
+        PINCTRL_PIN(85, "GPIO_85"),
+        PINCTRL_PIN(86, "GPIO_86"),
+        PINCTRL_PIN(87, "GPIO_87"),
+        PINCTRL_PIN(88, "GPIO_88"),
+        PINCTRL_PIN(89, "GPIO_89"),
+        PINCTRL_PIN(90, "GPIO_90"),
+        PINCTRL_PIN(91, "GPIO_91"),
+        PINCTRL_PIN(92, "GPIO_92"),
+        PINCTRL_PIN(93, "GPIO_93"),
+        PINCTRL_PIN(94, "GPIO_94"),
+        PINCTRL_PIN(95, "GPIO_95"),
+        PINCTRL_PIN(96, "GPIO_96"),
+        PINCTRL_PIN(97, "GPIO_97"),
+        PINCTRL_PIN(98, "GPIO_98"),
+        PINCTRL_PIN(99, "GPIO_99"),
+        PINCTRL_PIN(100, "GPIO_100"),
+        PINCTRL_PIN(101, "GPIO_101"),
+        PINCTRL_PIN(102, "GPIO_102"),
+        PINCTRL_PIN(103, "GPIO_103"),
+        PINCTRL_PIN(104, "GPIO_104"),
+        PINCTRL_PIN(105, "GPIO_105"),
+        PINCTRL_PIN(106, "GPIO_106"),
+        PINCTRL_PIN(107, "GPIO_107"),
+        PINCTRL_PIN(108, "GPIO_108"),
+        PINCTRL_PIN(109, "GPIO_109"),
+        PINCTRL_PIN(110, "GPIO_110"),
+        PINCTRL_PIN(111, "GPIO_111"),
+        PINCTRL_PIN(112, "GPIO_112"),
+        PINCTRL_PIN(113, "GPIO_113"),
+        PINCTRL_PIN(114, "GPIO_114"),
+        PINCTRL_PIN(115, "GPIO_115"),
+        PINCTRL_PIN(116, "GPIO_116"),
+        PINCTRL_PIN(117, "GPIO_117"),
+        PINCTRL_PIN(118, "GPIO_118"),
+        PINCTRL_PIN(119, "GPIO_119"),
+        PINCTRL_PIN(120, "GPIO_120"),
+        PINCTRL_PIN(121, "GPIO_121"),
+        PINCTRL_PIN(122, "GPIO_122"),
+        PINCTRL_PIN(123, "GPIO_123"),
+        PINCTRL_PIN(124, "GPIO_124"),
+        PINCTRL_PIN(125, "GPIO_125"),
+        PINCTRL_PIN(126, "GPIO_126"),
+        PINCTRL_PIN(127, "GPIO_127"),
+        PINCTRL_PIN(128, "GPIO_128"),
+        PINCTRL_PIN(129, "GPIO_129"),
+        PINCTRL_PIN(130, "GPIO_130"),
+        PINCTRL_PIN(131, "GPIO_131"),
+        PINCTRL_PIN(132, "GPIO_132"),
+        PINCTRL_PIN(133, "GPIO_133"),
+        PINCTRL_PIN(134, "GPIO_134"),
+        PINCTRL_PIN(135, "GPIO_135"),
+        PINCTRL_PIN(136, "GPIO_136"),
+        PINCTRL_PIN(137, "GPIO_137"),
+        PINCTRL_PIN(138, "GPIO_138"),
+        PINCTRL_PIN(139, "GPIO_139"),
+        PINCTRL_PIN(140, "GPIO_140"),
+        PINCTRL_PIN(141, "GPIO_141"),
+        PINCTRL_PIN(142, "GPIO_142"),
+        PINCTRL_PIN(143, "GPIO_143"),
+        PINCTRL_PIN(144, "GPIO_144"),
+        PINCTRL_PIN(145, "GPIO_145"),
+        PINCTRL_PIN(146, "GPIO_146"),
+        PINCTRL_PIN(147, "GPIO_147"),
+        PINCTRL_PIN(148, "GPIO_148"),
+        PINCTRL_PIN(149, "GPIO_149"),
+        PINCTRL_PIN(150, "GPIO_150"),
+        PINCTRL_PIN(151, "GPIO_151"),
+        PINCTRL_PIN(152, "GPIO_152"),
+        PINCTRL_PIN(153, "GPIO_153"),
+        PINCTRL_PIN(154, "GPIO_154"),
+        PINCTRL_PIN(155, "GPIO_155"),
+        PINCTRL_PIN(156, "GPIO_156"),
+        PINCTRL_PIN(157, "GPIO_157"),
+        PINCTRL_PIN(158, "GPIO_158"),
+        PINCTRL_PIN(159, "GPIO_159"),
+        PINCTRL_PIN(160, "GPIO_160"),
+        PINCTRL_PIN(161, "GPIO_161"),
+        PINCTRL_PIN(162, "GPIO_162"),
+        PINCTRL_PIN(163, "GPIO_163"),
+        PINCTRL_PIN(164, "GPIO_164"),
+        PINCTRL_PIN(165, "GPIO_165"),
+        PINCTRL_PIN(166, "GPIO_166"),
+        PINCTRL_PIN(167, "GPIO_167"),
+        PINCTRL_PIN(168, "GPIO_168"),
+        PINCTRL_PIN(169, "GPIO_169"),
+        PINCTRL_PIN(170, "GPIO_170"),
+        PINCTRL_PIN(171, "GPIO_171"),
+        PINCTRL_PIN(172, "GPIO_172"),
+        PINCTRL_PIN(173, "GPIO_173"),
+        PINCTRL_PIN(174, "GPIO_174"),
+        PINCTRL_PIN(175, "UFS_RESET"),
+        PINCTRL_PIN(176, "SDC2_CLK"),
+        PINCTRL_PIN(177, "SDC2_CMD"),
+        PINCTRL_PIN(178, "SDC2_DATA"),
+};
+
+#define DECLARE_MSM_GPIO_PINS(pin) \
+        static const unsigned int gpio##pin##_pins[] = { pin }
+DECLARE_MSM_GPIO_PINS(0);
+DECLARE_MSM_GPIO_PINS(1);
+DECLARE_MSM_GPIO_PINS(2);
+DECLARE_MSM_GPIO_PINS(3);
+DECLARE_MSM_GPIO_PINS(4);
+DECLARE_MSM_GPIO_PINS(5);
+DECLARE_MSM_GPIO_PINS(6);
+DECLARE_MSM_GPIO_PINS(7);
+DECLARE_MSM_GPIO_PINS(8);
+DECLARE_MSM_GPIO_PINS(9);
+DECLARE_MSM_GPIO_PINS(10);
+DECLARE_MSM_GPIO_PINS(11);
+DECLARE_MSM_GPIO_PINS(12);
+DECLARE_MSM_GPIO_PINS(13);
+DECLARE_MSM_GPIO_PINS(14);
+DECLARE_MSM_GPIO_PINS(15);
+DECLARE_MSM_GPIO_PINS(16);
+DECLARE_MSM_GPIO_PINS(17);
+DECLARE_MSM_GPIO_PINS(18);
+DECLARE_MSM_GPIO_PINS(19);
+DECLARE_MSM_GPIO_PINS(20);
+DECLARE_MSM_GPIO_PINS(21);
+DECLARE_MSM_GPIO_PINS(22);
+DECLARE_MSM_GPIO_PINS(23);
+DECLARE_MSM_GPIO_PINS(24);
+DECLARE_MSM_GPIO_PINS(25);
+DECLARE_MSM_GPIO_PINS(26);
+DECLARE_MSM_GPIO_PINS(27);
+DECLARE_MSM_GPIO_PINS(28);
+DECLARE_MSM_GPIO_PINS(29);
+DECLARE_MSM_GPIO_PINS(30);
+DECLARE_MSM_GPIO_PINS(31);
+DECLARE_MSM_GPIO_PINS(32);
+DECLARE_MSM_GPIO_PINS(33);
+DECLARE_MSM_GPIO_PINS(34);
+DECLARE_MSM_GPIO_PINS(35);
+DECLARE_MSM_GPIO_PINS(36);
+DECLARE_MSM_GPIO_PINS(37);
+DECLARE_MSM_GPIO_PINS(38);
+DECLARE_MSM_GPIO_PINS(39);
+DECLARE_MSM_GPIO_PINS(40);
+DECLARE_MSM_GPIO_PINS(41);
+DECLARE_MSM_GPIO_PINS(42);
+DECLARE_MSM_GPIO_PINS(43);
+DECLARE_MSM_GPIO_PINS(44);
+DECLARE_MSM_GPIO_PINS(45);
+DECLARE_MSM_GPIO_PINS(46);
+DECLARE_MSM_GPIO_PINS(47);
+DECLARE_MSM_GPIO_PINS(48);
+DECLARE_MSM_GPIO_PINS(49);
+DECLARE_MSM_GPIO_PINS(50);
+DECLARE_MSM_GPIO_PINS(51);
+DECLARE_MSM_GPIO_PINS(52);
+DECLARE_MSM_GPIO_PINS(53);
+DECLARE_MSM_GPIO_PINS(54);
+DECLARE_MSM_GPIO_PINS(55);
+DECLARE_MSM_GPIO_PINS(56);
+DECLARE_MSM_GPIO_PINS(57);
+DECLARE_MSM_GPIO_PINS(58);
+DECLARE_MSM_GPIO_PINS(59);
+DECLARE_MSM_GPIO_PINS(60);
+DECLARE_MSM_GPIO_PINS(61);
+DECLARE_MSM_GPIO_PINS(62);
+DECLARE_MSM_GPIO_PINS(63);
+DECLARE_MSM_GPIO_PINS(64);
+DECLARE_MSM_GPIO_PINS(65);
+DECLARE_MSM_GPIO_PINS(66);
+DECLARE_MSM_GPIO_PINS(67);
+DECLARE_MSM_GPIO_PINS(68);
+DECLARE_MSM_GPIO_PINS(69);
+DECLARE_MSM_GPIO_PINS(70);
+DECLARE_MSM_GPIO_PINS(71);
+DECLARE_MSM_GPIO_PINS(72);
+DECLARE_MSM_GPIO_PINS(73);
+DECLARE_MSM_GPIO_PINS(74);
+DECLARE_MSM_GPIO_PINS(75);
+DECLARE_MSM_GPIO_PINS(76);
+DECLARE_MSM_GPIO_PINS(77);
+DECLARE_MSM_GPIO_PINS(78);
+DECLARE_MSM_GPIO_PINS(79);
+DECLARE_MSM_GPIO_PINS(80);
+DECLARE_MSM_GPIO_PINS(81);
+DECLARE_MSM_GPIO_PINS(82);
+DECLARE_MSM_GPIO_PINS(83);
+DECLARE_MSM_GPIO_PINS(84);
+DECLARE_MSM_GPIO_PINS(85);
+DECLARE_MSM_GPIO_PINS(86);
+DECLARE_MSM_GPIO_PINS(87);
+DECLARE_MSM_GPIO_PINS(88);
+DECLARE_MSM_GPIO_PINS(89);
+DECLARE_MSM_GPIO_PINS(90);
+DECLARE_MSM_GPIO_PINS(91);
+DECLARE_MSM_GPIO_PINS(92);
+DECLARE_MSM_GPIO_PINS(93);
+DECLARE_MSM_GPIO_PINS(94);
+DECLARE_MSM_GPIO_PINS(95);
+DECLARE_MSM_GPIO_PINS(96);
+DECLARE_MSM_GPIO_PINS(97);
+DECLARE_MSM_GPIO_PINS(98);
+DECLARE_MSM_GPIO_PINS(99);
+DECLARE_MSM_GPIO_PINS(100);
+DECLARE_MSM_GPIO_PINS(101);
+DECLARE_MSM_GPIO_PINS(102);
+DECLARE_MSM_GPIO_PINS(103);
+DECLARE_MSM_GPIO_PINS(104);
+DECLARE_MSM_GPIO_PINS(105);
+DECLARE_MSM_GPIO_PINS(106);
+DECLARE_MSM_GPIO_PINS(107);
+DECLARE_MSM_GPIO_PINS(108);
+DECLARE_MSM_GPIO_PINS(109);
+DECLARE_MSM_GPIO_PINS(110);
+DECLARE_MSM_GPIO_PINS(111);
+DECLARE_MSM_GPIO_PINS(112);
+DECLARE_MSM_GPIO_PINS(113);
+DECLARE_MSM_GPIO_PINS(114);
+DECLARE_MSM_GPIO_PINS(115);
+DECLARE_MSM_GPIO_PINS(116);
+DECLARE_MSM_GPIO_PINS(117);
+DECLARE_MSM_GPIO_PINS(118);
+DECLARE_MSM_GPIO_PINS(119);
+DECLARE_MSM_GPIO_PINS(120);
+DECLARE_MSM_GPIO_PINS(121);
+DECLARE_MSM_GPIO_PINS(122);
+DECLARE_MSM_GPIO_PINS(123);
+DECLARE_MSM_GPIO_PINS(124);
+DECLARE_MSM_GPIO_PINS(125);
+DECLARE_MSM_GPIO_PINS(126);
+DECLARE_MSM_GPIO_PINS(127);
+DECLARE_MSM_GPIO_PINS(128);
+DECLARE_MSM_GPIO_PINS(129);
+DECLARE_MSM_GPIO_PINS(130);
+DECLARE_MSM_GPIO_PINS(131);
+DECLARE_MSM_GPIO_PINS(132);
+DECLARE_MSM_GPIO_PINS(133);
+DECLARE_MSM_GPIO_PINS(134);
+DECLARE_MSM_GPIO_PINS(135);
+DECLARE_MSM_GPIO_PINS(136);
+DECLARE_MSM_GPIO_PINS(137);
+DECLARE_MSM_GPIO_PINS(138);
+DECLARE_MSM_GPIO_PINS(139);
+DECLARE_MSM_GPIO_PINS(140);
+DECLARE_MSM_GPIO_PINS(141);
+DECLARE_MSM_GPIO_PINS(142);
+DECLARE_MSM_GPIO_PINS(143);
+DECLARE_MSM_GPIO_PINS(144);
+DECLARE_MSM_GPIO_PINS(145);
+DECLARE_MSM_GPIO_PINS(146);
+DECLARE_MSM_GPIO_PINS(147);
+DECLARE_MSM_GPIO_PINS(148);
+DECLARE_MSM_GPIO_PINS(149);
+DECLARE_MSM_GPIO_PINS(150);
+DECLARE_MSM_GPIO_PINS(151);
+DECLARE_MSM_GPIO_PINS(152);
+DECLARE_MSM_GPIO_PINS(153);
+DECLARE_MSM_GPIO_PINS(154);
+DECLARE_MSM_GPIO_PINS(155);
+DECLARE_MSM_GPIO_PINS(156);
+DECLARE_MSM_GPIO_PINS(157);
+DECLARE_MSM_GPIO_PINS(158);
+DECLARE_MSM_GPIO_PINS(159);
+DECLARE_MSM_GPIO_PINS(160);
+DECLARE_MSM_GPIO_PINS(161);
+DECLARE_MSM_GPIO_PINS(162);
+DECLARE_MSM_GPIO_PINS(163);
+DECLARE_MSM_GPIO_PINS(164);
+DECLARE_MSM_GPIO_PINS(165);
+DECLARE_MSM_GPIO_PINS(166);
+DECLARE_MSM_GPIO_PINS(167);
+DECLARE_MSM_GPIO_PINS(168);
+DECLARE_MSM_GPIO_PINS(169);
+DECLARE_MSM_GPIO_PINS(170);
+DECLARE_MSM_GPIO_PINS(171);
+DECLARE_MSM_GPIO_PINS(172);
+DECLARE_MSM_GPIO_PINS(173);
+DECLARE_MSM_GPIO_PINS(174);
+
+static const unsigned int ufs_reset_pins[] = { 175 };
+static const unsigned int sdc2_clk_pins[] = { 176 };
+static const unsigned int sdc2_cmd_pins[] = { 177 };
+static const unsigned int sdc2_data_pins[] = { 178 };
+
+enum sm8150_functions {
+        msm_mux_adsp_ext,
+        msm_mux_agera_pll,
+        msm_mux_aoss_cti,
+        msm_mux_atest_char,
+        msm_mux_atest_char0,
+        msm_mux_atest_char1,
+        msm_mux_atest_char2,
+        msm_mux_atest_char3,
+        msm_mux_atest_usb1,
+        msm_mux_atest_usb2,
+        msm_mux_atest_usb10,
+        msm_mux_atest_usb11,
+        msm_mux_atest_usb12,
+        msm_mux_atest_usb13,
+        msm_mux_atest_usb20,
+        msm_mux_atest_usb21,
+        msm_mux_atest_usb22,
+        msm_mux_atest_usb23,
+        msm_mux_audio_ref,
+        msm_mux_btfm_slimbus,
+        msm_mux_cam_mclk,
+        msm_mux_cci_async,
+        msm_mux_cci_i2c,
+        msm_mux_cci_timer0,
+        msm_mux_cci_timer1,
+        msm_mux_cci_timer2,
+        msm_mux_cci_timer3,
+        msm_mux_cci_timer4,
+        msm_mux_cri_trng,
+        msm_mux_cri_trng0,
+        msm_mux_cri_trng1,
+        msm_mux_dbg_out,
+        msm_mux_ddr_bist,
+        msm_mux_ddr_pxi0,
+        msm_mux_ddr_pxi1,
+        msm_mux_ddr_pxi2,
+        msm_mux_ddr_pxi3,
+        msm_mux_edp_hot,
+        msm_mux_edp_lcd,
+        msm_mux_emac_phy,
+        msm_mux_emac_pps,
+        msm_mux_gcc_gp1,
+        msm_mux_gcc_gp2,
+        msm_mux_gcc_gp3,
+        msm_mux_gpio,
+        msm_mux_jitter_bist,
+        msm_mux_hs1_mi2s,
+        msm_mux_hs2_mi2s,
+        msm_mux_hs3_mi2s,
+        msm_mux_lpass_slimbus,
+        msm_mux_mdp_vsync,
+        msm_mux_mdp_vsync0,
+        msm_mux_mdp_vsync1,
+        msm_mux_mdp_vsync2,
+        msm_mux_mdp_vsync3,
+        msm_mux_mss_lte,
+        msm_mux_m_voc,
+        msm_mux_nav_pps,
+        msm_mux_pa_indicator,
+        msm_mux_pci_e0,
+        msm_mux_pci_e1,
+        msm_mux_phase_flag,
+        msm_mux_pll_bist,
+        msm_mux_pll_bypassnl,
+        msm_mux_pll_reset,
+        msm_mux_pri_mi2s,
+        msm_mux_pri_mi2s_ws,
+        msm_mux_prng_rosc,
+        msm_mux_qdss,
+        msm_mux_qdss_cti,
+        msm_mux_qlink_enable,
+        msm_mux_qlink_request,
+        msm_mux_qspi0,
+        msm_mux_qspi1,
+        msm_mux_qspi2,
+        msm_mux_qspi3,
+        msm_mux_qspi_clk,
+        msm_mux_qspi_cs,
+        msm_mux_qua_mi2s,
+        msm_mux_qup0,
+        msm_mux_qup1,
+        msm_mux_qup2,
+        msm_mux_qup3,
+        msm_mux_qup4,
+        msm_mux_qup5,
+        msm_mux_qup6,
+        msm_mux_qup7,
+        msm_mux_qup8,
+        msm_mux_qup9,
+        msm_mux_qup10,
+        msm_mux_qup11,
+        msm_mux_qup12,
+        msm_mux_qup13,
+        msm_mux_qup14,
+        msm_mux_qup15,
+        msm_mux_qup16,
+        msm_mux_qup17,
+        msm_mux_qup18,
+        msm_mux_qup19,
+        msm_mux_qup_l4,
+        msm_mux_qup_l5,
+        msm_mux_qup_l6,
+        msm_mux_rgmii,
+        msm_mux_sdc4,
+        msm_mux_sd_write,
+        msm_mux_sec_mi2s,
+        msm_mux_spkr_i2s,
+        msm_mux_sp_cmu,
+        msm_mux_ter_mi2s,
+        msm_mux_tgu_ch0,
+        msm_mux_tgu_ch2,
+        msm_mux_tgu_ch1,
+        msm_mux_tgu_ch3,
+        msm_mux_tsense_pwm1,
+        msm_mux_tsense_pwm2,
+        msm_mux_tsif1,
+        msm_mux_tsif2,
+        msm_mux_uim1,
+        msm_mux_uim2,
+        msm_mux_uim_batt,
+        msm_mux_usb2phy_ac,
+        msm_mux_usb_phy,
+        msm_mux_vfr_1,
+        msm_mux_vsense_trigger,
+        msm_mux_wlan1_adc1,
+        msm_mux_wlan1_adc0,
+        msm_mux_wlan2_adc1,
+        msm_mux_wlan2_adc0,
+        msm_mux_wmss_reset,
+        msm_mux__,
+};
+
+static const char * const phase_flag_groups[] = {
+        "gpio18", "gpio19", "gpio20", "gpio55", "gpio56",
+        "gpio57", "gpio59", "gpio64", "gpio68", "gpio76",
+        "gpio79", "gpio80", "gpio90", "gpio91", "gpio92",
+        "gpio93", "gpio94", "gpio96", "gpio114", "gpio115",
+        "gpio116", "gpio117", "gpio118", "gpio119", "gpio120",
+        "gpio121", "gpio122", "gpio126", "gpio127", "gpio128",
+        "gpio144", "gpio145",
+};
+
+static const char * const emac_pps_groups[] = {
+        "gpio81",
+};
+
+static const char * const qup12_groups[] = {
+        "gpio83", "gpio84", "gpio85", "gpio86",
+};
+
+static const char * const qup16_groups[] = {
+        "gpio83", "gpio84", "gpio85", "gpio86",
+};
+
+static const char * const tsif1_groups[] = {
+        "gpio88", "gpio89", "gpio90", "gpio91", "gpio97",
+};
+
+static const char * const qup8_groups[] = {
+        "gpio88", "gpio89", "gpio90", "gpio91",
+};
+
+static const char * const qspi_cs_groups[] = {
+        "gpio88", "gpio94",
+};
+
+static const char * const tgu_ch3_groups[] = {
+        "gpio88",
+};
+
+static const char * const qspi0_groups[] = {
+        "gpio89",
+};
+
+static const char * const mdp_vsync0_groups[] = {
+        "gpio89",
+};
+
+static const char * const mdp_vsync1_groups[] = {
+        "gpio89",
+};
+
+static const char * const mdp_vsync2_groups[] = {
+        "gpio89",
+};
+
+static const char * const mdp_vsync3_groups[] = {
+        "gpio89",
+};
+
+static const char * const tgu_ch0_groups[] = {
+        "gpio89",
+};
+
+static const char * const qspi1_groups[] = {
+        "gpio90",
+};
+
+static const char * const sdc4_groups[] = {
+        "gpio90", "gpio91", "gpio92", "gpio93", "gpio94", "gpio95",
+};
+
+static const char * const tgu_ch1_groups[] = {
+        "gpio90",
+};
+
+static const char * const wlan1_adc1_groups[] = {
+        "gpio90",
+};
+
+static const char * const qspi2_groups[] = {
+        "gpio91",
+};
+
+static const char * const vfr_1_groups[] = {
+        "gpio91",
+};
+
+static const char * const tgu_ch2_groups[] = {
+        "gpio91",
+};
+
+static const char * const wlan1_adc0_groups[] = {
+        "gpio91",
+};
+
+static const char * const tsif2_groups[] = {
+        "gpio92", "gpio93", "gpio94", "gpio95", "gpio96",
+};
+
+static const char * const qup11_groups[] = {
+        "gpio92", "gpio93", "gpio94", "gpio95",
+};
+
+static const char * const qspi_clk_groups[] = {
+        "gpio92",
+};
+
+static const char * const wlan2_adc1_groups[] = {
+        "gpio92",
+};
+
+static const char * const qspi3_groups[] = {
+        "gpio93",
+};
+
+static const char * const wlan2_adc0_groups[] = {
+        "gpio93",
+};
+
+static const char * const sd_write_groups[] = {
+        "gpio97",
+};
+
+static const char * const qup7_groups[] = {
+        "gpio98", "gpio99", "gpio100", "gpio101",
+};
+
+static const char * const ddr_bist_groups[] = {
+        "gpio98", "gpio99", "gpio145", "gpio146",
+};
+
+static const char * const ddr_pxi3_groups[] = {
+        "gpio98", "gpio101",
+};
+
+static const char * const atest_usb13_groups[] = {
+        "gpio99",
+};
+
+static const char * const ddr_pxi1_groups[] = {
+        "gpio99", "gpio100",
+};
+
+static const char * const pll_bypassnl_groups[] = {
+        "gpio100",
+};
+
+static const char * const atest_usb12_groups[] = {
+        "gpio100",
+};
+
+static const char * const pll_reset_groups[] = {
+        "gpio101",
+};
+
+static const char * const pci_e1_groups[] = {
+        "gpio102", "gpio103",
+};
+
+static const char * const uim2_groups[] = {
+        "gpio105", "gpio106", "gpio107", "gpio108",
+};
+
+static const char * const uim1_groups[] = {
+        "gpio109", "gpio110", "gpio111", "gpio112",
+};
+
+static const char * const uim_batt_groups[] = {
+        "gpio113",
+};
+
+static const char * const usb2phy_ac_groups[] = {
+        "gpio113", "gpio123",
+};
+
+static const char * const aoss_cti_groups[] = {
+        "gpio113",
+};
+
+static const char * const qup1_groups[] = {
+        "gpio114", "gpio115", "gpio116", "gpio117",
+};
+
+static const char * const rgmii_groups[] = {
+        "gpio4", "gpio5", "gpio6", "gpio7", "gpio59",
+        "gpio114", "gpio115", "gpio116", "gpio117",
+        "gpio118", "gpio119", "gpio120", "gpio121", "gpio122",
+};
+
+static const char * const adsp_ext_groups[] = {
+        "gpio115",
+};
+
+static const char * const qup5_groups[] = {
+        "gpio119", "gpio120", "gpio121", "gpio122",
+};
+
+static const char * const atest_usb22_groups[] = {
+        "gpio123",
+};
+
+static const char * const emac_phy_groups[] = {
+        "gpio124",
+};
+
+static const char * const hs3_mi2s_groups[] = {
+        "gpio125", "gpio165", "gpio166", "gpio167", "gpio168",
+};
+
+static const char * const sec_mi2s_groups[] = {
+        "gpio126", "gpio127", "gpio128", "gpio129", "gpio130",
+};
+
+static const char * const qup2_groups[] = {
+        "gpio126", "gpio127", "gpio128", "gpio129",
+};
+
+static const char * const jitter_bist_groups[] = {
+        "gpio129",
+};
+
+static const char * const atest_usb21_groups[] = {
+        "gpio129",
+};
+
+static const char * const pll_bist_groups[] = {
+        "gpio130",
+};
+
+static const char * const atest_usb20_groups[] = {
+        "gpio130",
+};
+
+static const char * const atest_char0_groups[] = {
+        "gpio130",
+};
+
+static const char * const ter_mi2s_groups[] = {
+        "gpio131", "gpio132", "gpio133", "gpio134", "gpio135",
+};
+
+static const char * const gcc_gp1_groups[] = {
+        "gpio131", "gpio136",
+};
+
+static const char * const atest_char1_groups[] = {
+        "gpio133",
+};
+
+static const char * const atest_char2_groups[] = {
+        "gpio134",
+};
+
+static const char * const atest_char3_groups[] = {
+        "gpio135",
+};
+
+static const char * const qua_mi2s_groups[] = {
+        "gpio136", "gpio137", "gpio138", "gpio139", "gpio140", "gpio141",
+        "gpio142",
+};
+
+static const char * const pri_mi2s_groups[] = {
+        "gpio143", "gpio144", "gpio146", "gpio147",
+};
+
+static const char * const qup3_groups[] = {
+        "gpio144", "gpio145", "gpio146", "gpio147",
+};
+
+static const char * const ddr_pxi0_groups[] = {
+        "gpio144", "gpio145",
+};
+
+static const char * const pri_mi2s_ws_groups[] = {
+        "gpio145",
+};
+
+static const char * const vsense_trigger_groups[] = {
+        "gpio145",
+};
+
+static const char * const atest_usb1_groups[] = {
+        "gpio145",
+};
+
+static const char * const atest_usb11_groups[] = {
+        "gpio146",
+};
+
+static const char * const ddr_pxi2_groups[] = {
+        "gpio146", "gpio147",
+};
+
+static const char * const dbg_out_groups[] = {
+        "gpio147",
+};
+
+static const char * const atest_usb10_groups[] = {
+        "gpio147",
+};
+
+static const char * const spkr_i2s_groups[] = {
+        "gpio148", "gpio149", "gpio150", "gpio151", "gpio152",
+};
+
+static const char * const audio_ref_groups[] = {
+        "gpio148",
+};
+
+static const char * const lpass_slimbus_groups[] = {
+        "gpio149", "gpio150", "gpio151", "gpio152",
+};
+
+static const char * const tsense_pwm1_groups[] = {
+        "gpio150",
+};
+
+static const char * const tsense_pwm2_groups[] = {
+        "gpio150",
+};
+
+static const char * const btfm_slimbus_groups[] = {
+        "gpio153", "gpio154",
+};
+
+static const char * const hs1_mi2s_groups[] = {
+        "gpio155", "gpio156", "gpio157", "gpio158", "gpio159",
+};
+
+static const char * const cri_trng0_groups[] = {
+        "gpio159",
+};
+
+static const char * const hs2_mi2s_groups[] = {
+        "gpio160", "gpio161", "gpio162", "gpio163", "gpio164",
+};
+
+static const char * const cri_trng1_groups[] = {
+        "gpio160",
+};
+
+static const char * const cri_trng_groups[] = {
+        "gpio161",
+};
+
+static const char * const sp_cmu_groups[] = {
+        "gpio162",
+};
+
+static const char * const prng_rosc_groups[] = {
+        "gpio163",
+};
+
+static const char * const qup0_groups[] = {
+        "gpio0", "gpio1", "gpio2", "gpio3",
+};
+
+static const char * const gpio_groups[] = {
+        "gpio0", "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7",
+        "gpio8", "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14",
+        "gpio15", "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21",
+        "gpio22", "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28",
+        "gpio29", "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35",
+        "gpio36", "gpio37", "gpio38", "gpio39", "gpio40", "gpio41", "gpio42",
+        "gpio43", "gpio44", "gpio45", "gpio46", "gpio47", "gpio48", "gpio49",
+        "gpio50", "gpio51", "gpio52", "gpio53", "gpio54", "gpio55", "gpio56",
+        "gpio57", "gpio58", "gpio59", "gpio60", "gpio61", "gpio62", "gpio63",
+        "gpio64", "gpio65", "gpio66", "gpio67", "gpio68", "gpio69", "gpio70",
+        "gpio71", "gpio72", "gpio73", "gpio74", "gpio75", "gpio76", "gpio77",
+        "gpio78", "gpio79", "gpio80", "gpio81", "gpio82", "gpio83", "gpio84",
+        "gpio85", "gpio86", "gpio87", "gpio88", "gpio89", "gpio90", "gpio91",
+        "gpio92", "gpio93", "gpio94", "gpio95", "gpio96", "gpio97", "gpio98",
+        "gpio99", "gpio100", "gpio101", "gpio102", "gpio103", "gpio104",
+        "gpio105", "gpio106", "gpio107", "gpio108", "gpio109", "gpio110",
+        "gpio111", "gpio112", "gpio113", "gpio114", "gpio115", "gpio116",
+        "gpio117", "gpio118", "gpio119", "gpio120", "gpio121", "gpio122",
+        "gpio123", "gpio124", "gpio125", "gpio126", "gpio127", "gpio128",
+        "gpio129", "gpio130", "gpio131", "gpio132", "gpio133", "gpio134",
+        "gpio135", "gpio136", "gpio137", "gpio138", "gpio139", "gpio140",
+        "gpio141", "gpio142", "gpio143", "gpio144", "gpio145", "gpio146",
+        "gpio147", "gpio148", "gpio149", "gpio150", "gpio151", "gpio152",
+        "gpio153", "gpio154", "gpio155", "gpio156", "gpio157", "gpio158",
+        "gpio159", "gpio160", "gpio161", "gpio162", "gpio163", "gpio164",
+        "gpio165", "gpio166", "gpio167", "gpio168", "gpio169", "gpio170",
+        "gpio171", "gpio172", "gpio173", "gpio174",
+};
+
+static const char * const qup6_groups[] = {
+        "gpio4", "gpio5", "gpio6", "gpio7",
+};
+
+static const char * const qup_l6_groups[] = {
+        "gpio6", "gpio34", "gpio97", "gpio123",
+};
+
+static const char * const qup_l5_groups[] = {
+        "gpio7", "gpio33", "gpio82", "gpio96",
+};
+
+static const char * const mdp_vsync_groups[] = {
+        "gpio8", "gpio9", "gpio10", "gpio81", "gpio82",
+};
+
+static const char * const edp_lcd_groups[] = {
+        "gpio9",
+};
+
+static const char * const qup10_groups[] = {
+        "gpio9", "gpio10", "gpio11", "gpio12",
+};
+
+static const char * const m_voc_groups[] = {
+        "gpio10",
+};
+
+static const char * const edp_hot_groups[] = {
+        "gpio10",
+};
+
+static const char * const cam_mclk_groups[] = {
+        "gpio13", "gpio14", "gpio15", "gpio16",
+};
+
+static const char * const qdss_groups[] = {
+        "gpio13", "gpio14", "gpio15", "gpio16", "gpio17",
+        "gpio18", "gpio19", "gpio20", "gpio21", "gpio22",
+        "gpio23", "gpio24", "gpio25", "gpio26", "gpio27",
+        "gpio28", "gpio29", "gpio30", "gpio31", "gpio32",
+        "gpio33", "gpio39", "gpio40", "gpio41", "gpio42",
+        "gpio47", "gpio48", "gpio83", "gpio117", "gpio118",
+        "gpio119", "gpio120", "gpio121", "gpio132",
+        "gpio133", "gpio134",
+};
+
+static const char * const cci_i2c_groups[] = {
+        "gpio17", "gpio18", "gpio19", "gpio20", "gpio31", "gpio32", "gpio33",
+        "gpio34",
+};
+
+static const char * const cci_timer0_groups[] = {
+        "gpio21",
+};
+
+static const char * const gcc_gp2_groups[] = {
+        "gpio21", "gpio137",
+};
+
+static const char * const cci_timer1_groups[] = {
+        "gpio22",
+};
+
+static const char * const gcc_gp3_groups[] = {
+        "gpio22", "gpio138",
+};
+
+static const char * const cci_timer2_groups[] = {
+        "gpio23",
+};
+
+static const char * const qup18_groups[] = {
+        "gpio23", "gpio24", "gpio25", "gpio26",
+};
+
+static const char * const cci_timer3_groups[] = {
+        "gpio24",
+};
+
+static const char * const cci_async_groups[] = {
+        "gpio24", "gpio25", "gpio26",
+};
+
+static const char * const cci_timer4_groups[] = {
+        "gpio25",
+};
+
+static const char * const qup15_groups[] = {
+        "gpio27", "gpio28", "gpio29", "gpio30",
+};
+
+static const char * const pci_e0_groups[] = {
+        "gpio35", "gpio36",
+};
+
+static const char * const qup_l4_groups[] = {
+        "gpio37", "gpio59", "gpio81", "gpio95",
+};
+
+static const char * const agera_pll_groups[] = {
+        "gpio37",
+};
+
+static const char * const usb_phy_groups[] = {
+        "gpio38",
+};
+
+static const char * const qup9_groups[] = {
+        "gpio39", "gpio40", "gpio41", "gpio42",
+};
+
+static const char * const qup13_groups[] = {
+        "gpio43", "gpio44", "gpio45", "gpio46",
+};
+
+static const char * const qdss_cti_groups[] = {
+        "gpio45", "gpio46", "gpio49", "gpio50", "gpio56", "gpio57", "gpio58",
+        "gpio58",
+};
+
+static const char * const qup14_groups[] = {
+        "gpio47", "gpio48", "gpio49", "gpio50",
+};
+
+static const char * const qup4_groups[] = {
+        "gpio51", "gpio52", "gpio53", "gpio54",
+};
+
+static const char * const qup17_groups[] = {
+        "gpio55", "gpio56", "gpio57", "gpio58",
+};
+
+static const char * const qup19_groups[] = {
+        "gpio55", "gpio56", "gpio57", "gpio58",
+};
+
+static const char * const atest_char_groups[] = {
+        "gpio59",
+};
+
+static const char * const nav_pps_groups[] = {
+        "gpio60", "gpio60", "gpio76", "gpio76", "gpio77", "gpio77", "gpio81",
+        "gpio81", "gpio82", "gpio82",
+};
+
+static const char * const atest_usb2_groups[] = {
+        "gpio60",
+};
+
+static const char * const qlink_request_groups[] = {
+        "gpio61",
+};
+
+static const char * const qlink_enable_groups[] = {
+        "gpio62",
+};
+
+static const char * const wmss_reset_groups[] = {
+        "gpio63",
+};
+
+static const char * const atest_usb23_groups[] = {
+        "gpio63",
+};
+
+static const char * const pa_indicator_groups[] = {
+        "gpio68",
+};
+
+static const char * const mss_lte_groups[] = {
+        "gpio69", "gpio70",
+};
+
+static const struct msm_function sm8150_functions[] = {
+        FUNCTION(adsp_ext),
+        FUNCTION(agera_pll),
+        FUNCTION(aoss_cti),
+        FUNCTION(ddr_pxi2),
+        FUNCTION(atest_char),
+        FUNCTION(atest_char0),
+        FUNCTION(atest_char1),
+        FUNCTION(atest_char2),
+        FUNCTION(atest_char3),
+        FUNCTION(audio_ref),
+        FUNCTION(atest_usb1),
+        FUNCTION(atest_usb2),
+        FUNCTION(atest_usb10),
+        FUNCTION(atest_usb11),
+        FUNCTION(atest_usb12),
+        FUNCTION(atest_usb13),
+        FUNCTION(atest_usb20),
+        FUNCTION(atest_usb21),
+        FUNCTION(atest_usb22),
+        FUNCTION(atest_usb23),
+        FUNCTION(btfm_slimbus),
+        FUNCTION(cam_mclk),
+        FUNCTION(cci_async),
+        FUNCTION(cci_i2c),
+        FUNCTION(cci_timer0),
+        FUNCTION(cci_timer1),
+        FUNCTION(cci_timer2),
+        FUNCTION(cci_timer3),
+        FUNCTION(cci_timer4),
+        FUNCTION(cri_trng),
+        FUNCTION(cri_trng0),
+        FUNCTION(cri_trng1),
+        FUNCTION(dbg_out),
+        FUNCTION(ddr_bist),
+        FUNCTION(ddr_pxi0),
+        FUNCTION(ddr_pxi1),
+        FUNCTION(ddr_pxi3),
+        FUNCTION(edp_hot),
+        FUNCTION(edp_lcd),
+        FUNCTION(emac_phy),
+        FUNCTION(emac_pps),
+        FUNCTION(gcc_gp1),
+        FUNCTION(gcc_gp2),
+        FUNCTION(gcc_gp3),
+        FUNCTION(gpio),
+        FUNCTION(hs1_mi2s),
+        FUNCTION(hs2_mi2s),
+        FUNCTION(hs3_mi2s),
+        FUNCTION(jitter_bist),
+        FUNCTION(lpass_slimbus),
+        FUNCTION(mdp_vsync),
+        FUNCTION(mdp_vsync0),
+        FUNCTION(mdp_vsync1),
+        FUNCTION(mdp_vsync2),
+        FUNCTION(mdp_vsync3),
+        FUNCTION(mss_lte),
+        FUNCTION(m_voc),
+        FUNCTION(nav_pps),
+        FUNCTION(pa_indicator),
+        FUNCTION(pci_e0),
+        FUNCTION(phase_flag),
+        FUNCTION(pll_bypassnl),
+        FUNCTION(pll_bist),
+        FUNCTION(pci_e1),
+        FUNCTION(pll_reset),
+        FUNCTION(pri_mi2s),
+        FUNCTION(pri_mi2s_ws),
+        FUNCTION(prng_rosc),
+        FUNCTION(qdss),
+        FUNCTION(qdss_cti),
+        FUNCTION(qlink_request),
+        FUNCTION(qlink_enable),
+        FUNCTION(qspi0),
+        FUNCTION(qspi1),
+        FUNCTION(qspi2),
+        FUNCTION(qspi3),
+        FUNCTION(qspi_clk),
+        FUNCTION(qspi_cs),
+        FUNCTION(qua_mi2s),
+        FUNCTION(qup0),
+        FUNCTION(qup1),
+        FUNCTION(qup2),
+        FUNCTION(qup3),
+        FUNCTION(qup4),
+        FUNCTION(qup5),
+        FUNCTION(qup6),
+        FUNCTION(qup7),
+        FUNCTION(qup8),
+        FUNCTION(qup9),
+        FUNCTION(qup10),
+        FUNCTION(qup11),
+        FUNCTION(qup12),
+        FUNCTION(qup13),
+        FUNCTION(qup14),
+        FUNCTION(qup15),
+        FUNCTION(qup16),
+        FUNCTION(qup17),
+        FUNCTION(qup18),
+        FUNCTION(qup19),
+        FUNCTION(qup_l4),
+        FUNCTION(qup_l5),
+        FUNCTION(qup_l6),
+        FUNCTION(rgmii),
+        FUNCTION(sdc4),
+        FUNCTION(sd_write),
+        FUNCTION(sec_mi2s),
+        FUNCTION(spkr_i2s),
+        FUNCTION(sp_cmu),
+        FUNCTION(ter_mi2s),
+        FUNCTION(tgu_ch0),
+        FUNCTION(tgu_ch1),
+        FUNCTION(tgu_ch2),
+        FUNCTION(tgu_ch3),
+        FUNCTION(tsense_pwm1),
+        FUNCTION(tsense_pwm2),
+        FUNCTION(tsif1),
+        FUNCTION(tsif2),
+        FUNCTION(uim1),
+        FUNCTION(uim2),
+        FUNCTION(uim_batt),
+        FUNCTION(usb2phy_ac),
+        FUNCTION(usb_phy),
+        FUNCTION(vfr_1),
+        FUNCTION(vsense_trigger),
+        FUNCTION(wlan1_adc0),
+        FUNCTION(wlan1_adc1),
+        FUNCTION(wlan2_adc0),
+        FUNCTION(wlan2_adc1),
+        FUNCTION(wmss_reset),
+};
+
+/*
+ * Every pin is maintained as a single group, and missing or non-existing pin
+ * would be maintained as dummy group to synchronize pin group index with
+ * pin descriptor registered with pinctrl core.
+ * Clients would not be able to request these dummy pin groups.
+ */
+static const struct msm_pingroup sm8150_groups[] = {
+        [0] = PINGROUP(0, SOUTH, qup0, _, _, _, _, _, _, _, _),
+        [1] = PINGROUP(1, SOUTH, qup0, _, _, _, _, _, _, _, _),
+        [2] = PINGROUP(2, SOUTH, qup0, _, _, _, _, _, _, _, _),
+        [3] = PINGROUP(3, SOUTH, qup0, _, _, _, _, _, _, _, _),
+        [4] = PINGROUP(4, SOUTH, qup6, rgmii, _, _, _, _, _, _, _),
+        [5] = PINGROUP(5, SOUTH, qup6, rgmii, _, _, _, _, _, _, _),
+        [6] = PINGROUP(6, SOUTH, qup6, rgmii, qup_l6, _, _, _, _, _, _),
+        [7] = PINGROUP(7, SOUTH, qup6, rgmii, qup_l5, _, _, _, _, _, _),
+        [8] = PINGROUP(8, NORTH, mdp_vsync, _, _, _, _, _, _, _, _),
+        [9] = PINGROUP(9, NORTH, mdp_vsync, edp_lcd, qup10, _, _, _, _, _, _),
+        [10] = PINGROUP(10, NORTH, mdp_vsync, m_voc, edp_hot, qup10, _, _, _, _, _),
+        [11] = PINGROUP(11, NORTH, qup10, _, _, _, _, _, _, _, _),
+        [12] = PINGROUP(12, NORTH, qup10, _, _, _, _, _, _, _, _),
+        [13] = PINGROUP(13, NORTH, cam_mclk, qdss, _, _, _, _, _, _, _),
+        [14] = PINGROUP(14, NORTH, cam_mclk, qdss, _, _, _, _, _, _, _),
+        [15] = PINGROUP(15, NORTH, cam_mclk, qdss, _, _, _, _, _, _, _),
+        [16] = PINGROUP(16, NORTH, cam_mclk, qdss, _, _, _, _, _, _, _),
+        [17] = PINGROUP(17, NORTH, cci_i2c, qdss, _, _, _, _, _, _, _),
+        [18] = PINGROUP(18, NORTH, cci_i2c, phase_flag, _, qdss, _, _, _, _, _),
+        [19] = PINGROUP(19, NORTH, cci_i2c, phase_flag, _, qdss, _, _, _, _, _),
+        [20] = PINGROUP(20, NORTH, cci_i2c, phase_flag, _, qdss, _, _, _, _, _),
+        [21] = PINGROUP(21, EAST, cci_timer0, gcc_gp2, qdss, _, _, _, _, _, _),
+        [22] = PINGROUP(22, EAST, cci_timer1, gcc_gp3, qdss, _, _, _, _, _, _),
+        [23] = PINGROUP(23, EAST, cci_timer2, qup18, qdss, _, _, _, _, _, _),
+        [24] = PINGROUP(24, EAST, cci_timer3, cci_async, qup18, qdss, _, _, _, _, _),
+        [25] = PINGROUP(25, EAST, cci_timer4, cci_async, qup18, qdss, _, _, _, _, _),
+        [26] = PINGROUP(26, EAST, cci_async, qup18, qdss, _, _, _, _, _, _),
+        [27] = PINGROUP(27, EAST, qup15, _, qdss, _, _, _, _, _, _),
+        [28] = PINGROUP(28, EAST, qup15, qdss, _, _, _, _, _, _, _),
+        [29] = PINGROUP(29, EAST, qup15, qdss, _, _, _, _, _, _, _),
+        [30] = PINGROUP(30, EAST, qup15, qdss, _, _, _, _, _, _, _),
+        [31] = PINGROUP(31, NORTH, cci_i2c, qdss, _, _, _, _, _, _, _),
+        [32] = PINGROUP(32, NORTH, cci_i2c, qdss, _, _, _, _, _, _, _),
+        [33] = PINGROUP(33, NORTH, cci_i2c, qup_l5, qdss, _, _, _, _, _, _),
+        [34] = PINGROUP(34, NORTH, cci_i2c, qup_l6, _, _, _, _, _, _, _),
+        [35] = PINGROUP(35, NORTH, pci_e0, _, _, _, _, _, _, _, _),
+        [36] = PINGROUP(36, NORTH, pci_e0, _, _, _, _, _, _, _, _),
+        [37] = PINGROUP(37, NORTH, qup_l4, agera_pll, _, _, _, _, _, _, _),
+        [38] = PINGROUP(38, SOUTH, usb_phy, _, _, _, _, _, _, _, _),
+        [39] = PINGROUP(39, NORTH, qup9, qdss, _, _, _, _, _, _, _),
+        [40] = PINGROUP(40, NORTH, qup9, qdss, _, _, _, _, _, _, _),
+        [41] = PINGROUP(41, NORTH, qup9, qdss, _, _, _, _, _, _, _),
+        [42] = PINGROUP(42, NORTH, qup9, qdss, _, _, _, _, _, _, _),
+        [43] = PINGROUP(43, EAST, qup13, _, _, _, _, _, _, _, _),
+        [44] = PINGROUP(44, EAST, qup13, _, _, _, _, _, _, _, _),
+        [45] = PINGROUP(45, EAST, qup13, qdss_cti, _, _, _, _, _, _, _),
+        [46] = PINGROUP(46, EAST, qup13, qdss_cti, _, _, _, _, _, _, _),
+        [47] = PINGROUP(47, EAST, qup14, qdss, _, _, _, _, _, _, _),
+        [48] = PINGROUP(48, EAST, qup14, qdss, _, _, _, _, _, _, _),
+        [49] = PINGROUP(49, EAST, qup14, _, qdss_cti, _, _, _, _, _, _),
+        [50] = PINGROUP(50, EAST, qup14, qdss_cti, _, _, _, _, _, _, _),
+        [51] = PINGROUP(51, SOUTH, qup4, _, _, _, _, _, _, _, _),
+        [52] = PINGROUP(52, SOUTH, qup4, _, _, _, _, _, _, _, _),
+        [53] = PINGROUP(53, SOUTH, qup4, _, _, _, _, _, _, _, _),
+        [54] = PINGROUP(54, SOUTH, qup4, _, _, _, _, _, _, _, _),
+        [55] = PINGROUP(55, SOUTH, qup17, qup19, phase_flag, _, _, _, _, _, _),
+        [56] = PINGROUP(56, SOUTH, qup17, qup19, qdss_cti, phase_flag, _, _, _, _, _),
+        [57] = PINGROUP(57, SOUTH, qup17, qup19, qdss_cti, phase_flag, _, _, _, _, _),
+        [58] = PINGROUP(58, SOUTH, qup17, qup19, qdss_cti, phase_flag, _, _, _, _, _),
+        [59] = PINGROUP(59, SOUTH, rgmii, qup_l4, phase_flag, _, atest_char, _, _, _, _),
+        [60] = PINGROUP(60, SOUTH, _, nav_pps, nav_pps, atest_usb2, _, _, _, _, _),
+        [61] = PINGROUP(61, SOUTH, qlink_request, _, _, _, _, _, _, _, _),
+        [62] = PINGROUP(62, SOUTH, qlink_enable, _, _, _, _, _, _, _, _),
+        [63] = PINGROUP(63, SOUTH, wmss_reset, atest_usb23, _, _, _, _, _, _, _),
+        [64] = PINGROUP(64, SOUTH, _, phase_flag, _, _, _, _, _, _, _),
+        [65] = PINGROUP(65, SOUTH, _, _, _, _, _, _, _, _, _),
+        [66] = PINGROUP(66, SOUTH, _, _, _, _, _, _, _, _, _),
+        [67] = PINGROUP(67, SOUTH, _, _, _, _, _, _, _, _, _),
+        [68] = PINGROUP(68, SOUTH, _, pa_indicator, phase_flag, _, _, _, _, _, _),
+        [69] = PINGROUP(69, SOUTH, mss_lte, _, _, _, _, _, _, _, _),
+        [70] = PINGROUP(70, SOUTH, mss_lte, _, _, _, _, _, _, _, _),
+        [71] = PINGROUP(71, SOUTH, _, _, _, _, _, _, _, _, _),
+        [72] = PINGROUP(72, SOUTH, _, _, _, _, _, _, _, _, _),
+        [73] = PINGROUP(73, SOUTH, _, _, _, _, _, _, _, _, _),
+        [74] = PINGROUP(74, SOUTH, _, _, _, _, _, _, _, _, _),
+        [75] = PINGROUP(75, SOUTH, _, _, _, _, _, _, _, _, _),
+        [76] = PINGROUP(76, SOUTH, _, _, _, nav_pps, nav_pps, phase_flag, _, _, _),
+        [77] = PINGROUP(77, SOUTH, _, _, _, nav_pps, nav_pps, _, _, _, _),
+        [78] = PINGROUP(78, SOUTH, _, _, _, _, _, _, _, _, _),
+        [79] = PINGROUP(79, SOUTH, _, _, phase_flag, _, _, _, _, _, _),
+        [80] = PINGROUP(80, SOUTH, _, _, phase_flag, _, _, _, _, _, _),
+        [81] = PINGROUP(81, SOUTH, _, _, _, nav_pps, nav_pps, qup_l4, mdp_vsync, emac_pps, _),
+        [82] = PINGROUP(82, SOUTH, _, _, _, nav_pps, nav_pps, qup_l5, mdp_vsync, _, _),
+        [83] = PINGROUP(83, NORTH, qup12, qup16, _, qdss, _, _, _, _, _),
+        [84] = PINGROUP(84, NORTH, qup12, qup16, _, _, _, _, _, _, _),
+        [85] = PINGROUP(85, NORTH, qup12, qup16, _, _, _, _, _, _, _),
+        [86] = PINGROUP(86, NORTH, qup12, qup16, _, _, _, _, _, _, _),
+        [87] = PINGROUP(87, EAST, _, _, _, _, _, _, _, _, _),
+        [88] = PINGROUP(88, NORTH, tsif1, qup8, qspi_cs, tgu_ch3, _, _, _, _, _),
+        [89] = PINGROUP(89, NORTH, tsif1, qup8, qspi0, mdp_vsync0, mdp_vsync1, mdp_vsync2, mdp_vsync3, tgu_ch0, _),
+        [90] = PINGROUP(90, NORTH, tsif1, qup8, qspi1, sdc4, phase_flag, tgu_ch1, _, _, wlan1_adc1),
+        [91] = PINGROUP(91, NORTH, tsif1, qup8, qspi2, sdc4, vfr_1, phase_flag, tgu_ch2, _, _),
+        [92] = PINGROUP(92, NORTH, tsif2, qup11, qspi_clk, sdc4, phase_flag, _, wlan2_adc1, _, _),
+        [93] = PINGROUP(93, NORTH, tsif2, qup11, qspi3, sdc4, phase_flag, _, wlan2_adc0, _, _),
+        [94] = PINGROUP(94, NORTH, tsif2, qup11, qspi_cs, sdc4, phase_flag, _, _, _, _),
+        [95] = PINGROUP(95, NORTH, tsif2, qup11, sdc4, qup_l4, _, _, _, _, _),
+        [96] = PINGROUP(96, NORTH, tsif2, qup_l5, phase_flag, _, _, _, _, _, _),
+        [97] = PINGROUP(97, NORTH, sd_write, tsif1, qup_l6, _, _, _, _, _, _),
+        [98] = PINGROUP(98, SOUTH, qup7, ddr_bist, ddr_pxi3, _, _, _, _, _, _),
+        [99] = PINGROUP(99, SOUTH, qup7, ddr_bist, atest_usb13, ddr_pxi1, _, _, _, _, _),
+        [100] = PINGROUP(100, SOUTH, qup7, pll_bypassnl, atest_usb12, ddr_pxi1, _, _, _, _, _),
+        [101] = PINGROUP(101, SOUTH, qup7, pll_reset, ddr_pxi3, _, _, _, _, _, _),
+        [102] = PINGROUP(102, NORTH, pci_e1, _, _, _, _, _, _, _, _),
+        [103] = PINGROUP(103, NORTH, pci_e1, _, _, _, _, _, _, _, _),
+        [104] = PINGROUP(104, NORTH, _, _, _, _, _, _, _, _, _),
+        [105] = PINGROUP(105, WEST, uim2, _, _, _, _, _, _, _, _),
+        [106] = PINGROUP(106, WEST, uim2, _, _, _, _, _, _, _, _),
+        [107] = PINGROUP(107, WEST, uim2, _, _, _, _, _, _, _, _),
+        [108] = PINGROUP(108, WEST, uim2, _, _, _, _, _, _, _, _),
+        [109] = PINGROUP(109, WEST, uim1, _, _, _, _, _, _, _, _),
+        [110] = PINGROUP(110, WEST, uim1, _, _, _, _, _, _, _, _),
+        [111] = PINGROUP(111, WEST, uim1, _, _, _, _, _, _, _, _),
+        [112] = PINGROUP(112, WEST, uim1, _, _, _, _, _, _, _, _),
+        [113] = PINGROUP(113, WEST, uim_batt, usb2phy_ac, aoss_cti, _, _, _, _, _, _),
+        [114] = PINGROUP(114, SOUTH, qup1, rgmii, phase_flag, _, _, _, _, _, _),
+        [115] = PINGROUP(115, SOUTH, qup1, rgmii, phase_flag, adsp_ext, _, _, _, _, _),
+        [116] = PINGROUP(116, SOUTH, qup1, rgmii, phase_flag, _, _, _, _, _, _),
+        [117] = PINGROUP(117, SOUTH, qup1, rgmii, phase_flag, _, qdss, _, _, _, _),
+        [118] = PINGROUP(118, SOUTH, rgmii, phase_flag, _, qdss, _, _, _, _, _),
+        [119] = PINGROUP(119, SOUTH, qup5, rgmii, phase_flag, _, qdss, _, _, _, _),
+        [120] = PINGROUP(120, SOUTH, qup5, rgmii, phase_flag, _, qdss, _, _, _, _),
+        [121] = PINGROUP(121, SOUTH, qup5, rgmii, phase_flag, _, qdss, _, _, _, _),
+        [122] = PINGROUP(122, SOUTH, qup5, rgmii, phase_flag, _, _, _, _, _, _),
+        [123] = PINGROUP(123, SOUTH, usb2phy_ac, qup_l6, atest_usb22, _, _, _, _, _, _),
+        [124] = PINGROUP(124, SOUTH, emac_phy, _, _, _, _, _, _, _, _),
+        [125] = PINGROUP(125, WEST, hs3_mi2s, _, _, _, _, _, _, _, _),
+        [126] = PINGROUP(126, SOUTH, sec_mi2s, qup2, phase_flag, _, _, _, _, _, _),
+        [127] = PINGROUP(127, SOUTH, sec_mi2s, qup2, phase_flag, _, _, _, _, _, _),
+        [128] = PINGROUP(128, SOUTH, sec_mi2s, qup2, phase_flag, _, _, _, _, _, _),
+        [129] = PINGROUP(129, SOUTH, sec_mi2s, qup2, jitter_bist, atest_usb21, _, _, _, _, _),
+        [130] = PINGROUP(130, SOUTH, sec_mi2s, pll_bist, atest_usb20, atest_char0, _, _, _, _, _),
+        [131] = PINGROUP(131, SOUTH, ter_mi2s, gcc_gp1, _, _, _, _, _, _, _),
+        [132] = PINGROUP(132, SOUTH, ter_mi2s, _, qdss, _, _, _, _, _, _),
+        [133] = PINGROUP(133, SOUTH, ter_mi2s, qdss, atest_char1, _, _, _, _, _, _),
+        [134] = PINGROUP(134, SOUTH, ter_mi2s, qdss, atest_char2, _, _, _, _, _, _),
+        [135] = PINGROUP(135, SOUTH, ter_mi2s, atest_char3, _, _, _, _, _, _, _),
+        [136] = PINGROUP(136, SOUTH, qua_mi2s, gcc_gp1, _, _, _, _, _, _, _),
+        [137] = PINGROUP(137, SOUTH, qua_mi2s, gcc_gp2, _, _, _, _, _, _, _),
+        [138] = PINGROUP(138, SOUTH, qua_mi2s, gcc_gp3, _, _, _, _, _, _, _),
+        [139] = PINGROUP(139, SOUTH, qua_mi2s, _, _, _, _, _, _, _, _),
+        [140] = PINGROUP(140, SOUTH, qua_mi2s, _, _, _, _, _, _, _, _),
+        [141] = PINGROUP(141, SOUTH, qua_mi2s, _, _, _, _, _, _, _, _),
+        [142] = PINGROUP(142, SOUTH, qua_mi2s, _, _, _, _, _, _, _, _),
+        [143] = PINGROUP(143, SOUTH, pri_mi2s, _, _, _, _, _, _, _, _),
+        [144] = PINGROUP(144, SOUTH, pri_mi2s, qup3, phase_flag, _, ddr_pxi0, _, _, _, _),
+        [145] = PINGROUP(145, SOUTH, pri_mi2s_ws, qup3, phase_flag, ddr_bist, _, vsense_trigger, atest_usb1, ddr_pxi0, _),
+        [146] = PINGROUP(146, SOUTH, pri_mi2s, qup3, ddr_bist, atest_usb11, ddr_pxi2, _, _, _, _),
+        [147] = PINGROUP(147, SOUTH, pri_mi2s, qup3, dbg_out, atest_usb10, ddr_pxi2, _, _, _, _),
+        [148] = PINGROUP(148, SOUTH, spkr_i2s, audio_ref, _, _, _, _, _, _, _),
+        [149] = PINGROUP(149, SOUTH, lpass_slimbus, spkr_i2s, _, _, _, _, _, _, _),
+        [150] = PINGROUP(150, SOUTH, lpass_slimbus, spkr_i2s, tsense_pwm1, tsense_pwm2, _, _, _, _, _),
+        [151] = PINGROUP(151, SOUTH, lpass_slimbus, spkr_i2s, _, _, _, _, _, _, _),
+        [152] = PINGROUP(152, SOUTH, lpass_slimbus, spkr_i2s, _, _, _, _, _, _, _),
+        [153] = PINGROUP(153, SOUTH, btfm_slimbus, _, _, _, _, _, _, _, _),
+        [154] = PINGROUP(154, SOUTH, btfm_slimbus, _, _, _, _, _, _, _, _),
+        [155] = PINGROUP(155, WEST, hs1_mi2s, _, _, _, _, _, _, _, _),
+        [156] = PINGROUP(156, WEST, hs1_mi2s, _, _, _, _, _, _, _, _),
+        [157] = PINGROUP(157, WEST, hs1_mi2s, _, _, _, _, _, _, _, _),
+        [158] = PINGROUP(158, WEST, hs1_mi2s, _, _, _, _, _, _, _, _),
+        [159] = PINGROUP(159, WEST, hs1_mi2s, cri_trng0, _, _, _, _, _, _, _),
+        [160] = PINGROUP(160, WEST, hs2_mi2s, cri_trng1, _, _, _, _, _, _, _),
+        [161] = PINGROUP(161, WEST, hs2_mi2s, cri_trng, _, _, _, _, _, _, _),
+        [162] = PINGROUP(162, WEST, hs2_mi2s, sp_cmu, _, _, _, _, _, _, _),
+        [163] = PINGROUP(163, WEST, hs2_mi2s, prng_rosc, _, _, _, _, _, _, _),
+        [164] = PINGROUP(164, WEST, hs2_mi2s, _, _, _, _, _, _, _, _),
+        [165] = PINGROUP(165, WEST, hs3_mi2s, _, _, _, _, _, _, _, _),
+        [166] = PINGROUP(166, WEST, hs3_mi2s, _, _, _, _, _, _, _, _),
+        [167] = PINGROUP(167, WEST, hs3_mi2s, _, _, _, _, _, _, _, _),
+        [168] = PINGROUP(168, WEST, hs3_mi2s, _, _, _, _, _, _, _, _),
+        [169] = PINGROUP(169, NORTH, _, _, _, _, _, _, _, _, _),
+        [170] = PINGROUP(170, NORTH, _, _, _, _, _, _, _, _, _),
+        [171] = PINGROUP(171, NORTH, _, _, _, _, _, _, _, _, _),
+        [172] = PINGROUP(172, NORTH, _, _, _, _, _, _, _, _, _),
+        [173] = PINGROUP(173, NORTH, _, _, _, _, _, _, _, _, _),
+        [174] = PINGROUP(174, NORTH, _, _, _, _, _, _, _, _, _),
+        [175] = UFS_RESET(ufs_reset, 0xB6000),
+        [176] = SDC_QDSD_PINGROUP(sdc2_clk, 0xB2000, 14, 6),
+        [177] = SDC_QDSD_PINGROUP(sdc2_cmd, 0xB2000, 11, 3),
+        [178] = SDC_QDSD_PINGROUP(sdc2_data, 0xB2000, 9, 0),
+};
+
+static const struct msm_pinctrl_soc_data sm8150_pinctrl = {
+        .pins = sm8150_pins,
+        .npins = ARRAY_SIZE(sm8150_pins),
+        .functions = sm8150_functions,
+        .nfunctions = ARRAY_SIZE(sm8150_functions),
+        .groups = sm8150_groups,
+        .ngroups = ARRAY_SIZE(sm8150_groups),
+        .ngpios = 176,
+        .tiles = sm8150_tiles,
+        .ntiles = ARRAY_SIZE(sm8150_tiles),
+};
+
+static int sm8150_pinctrl_probe(struct platform_device *pdev)
+{
+        return msm_pinctrl_probe(pdev, &sm8150_pinctrl);
+}
+
+static const struct of_device_id sm8150_pinctrl_of_match[] = {
+        { .compatible = "qcom,sm8150-pinctrl", },
+        { },
+};
+
+static struct platform_driver sm8150_pinctrl_driver = {
+        .driver = {
+                .name = "sm8150-pinctrl",
+                .of_match_table = sm8150_pinctrl_of_match,
+        },
+        .probe = sm8150_pinctrl_probe,
+        .remove = msm_pinctrl_remove,
+};
+
+static int __init sm8150_pinctrl_init(void)
+{
+        return platform_driver_register(&sm8150_pinctrl_driver);
+}
+arch_initcall(sm8150_pinctrl_init);
+
+static void __exit sm8150_pinctrl_exit(void)
+{
+        platform_driver_unregister(&sm8150_pinctrl_driver);
+}
+module_exit(sm8150_pinctrl_exit);
+
+MODULE_DESCRIPTION("QTI sm8150 pinctrl driver");
+MODULE_LICENSE("GPL v2");
+MODULE_DEVICE_TABLE(of, sm8150_pinctrl_of_match);
diff --git a/drivers/pinctrl/sh-pfc/core.c b/drivers/pinctrl/sh-pfc/core.c
index 3f989f5cb021..b8640ad41bef 100644
--- a/drivers/pinctrl/sh-pfc/core.c
+++ b/drivers/pinctrl/sh-pfc/core.c
@@ -717,7 +717,7 @@ static int sh_pfc_suspend_init(struct sh_pfc *pfc) { return 0; }
 #endif /* CONFIG_PM_SLEEP && CONFIG_ARM_PSCI_FW */
 
 #ifdef DEBUG
-static bool is0s(const u16 *enum_ids, unsigned int n)
+static bool __init is0s(const u16 *enum_ids, unsigned int n)
 {
         unsigned int i;
 
@@ -728,11 +728,11 @@ static bool is0s(const u16 *enum_ids, unsigned int n)
         return true;
 }
 
-static unsigned int sh_pfc_errors;
-static unsigned int sh_pfc_warnings;
+static unsigned int sh_pfc_errors __initdata = 0;
+static unsigned int sh_pfc_warnings __initdata = 0;
 
-static void sh_pfc_check_cfg_reg(const char *drvname,
-                                 const struct pinmux_cfg_reg *cfg_reg)
+static void __init sh_pfc_check_cfg_reg(const char *drvname,
+                                        const struct pinmux_cfg_reg *cfg_reg)
 {
         unsigned int i, n, rw, fw;
 
@@ -764,7 +764,7 @@ static void sh_pfc_check_cfg_reg(const char *drvname,
         }
 }
 
-static void sh_pfc_check_info(const struct sh_pfc_soc_info *info)
+static void __init sh_pfc_check_info(const struct sh_pfc_soc_info *info)
 {
         const struct sh_pfc_function *func;
         const char *drvname = info->name;
@@ -773,6 +773,35 @@ static void sh_pfc_check_info(const struct sh_pfc_soc_info *info)
 
         pr_info("Checking %s\n", drvname);
 
+        /* Check pins */
+        for (i = 0; i < info->nr_pins; i++) {
+                for (j = 0; j < i; j++) {
+                        if (!strcmp(info->pins[i].name, info->pins[j].name)) {
+                                pr_err("%s: pin %s/%s: name conflict\n",
+                                       drvname, info->pins[i].name,
+                                       info->pins[j].name);
+                                sh_pfc_errors++;
+                        }
+
+                        if (info->pins[i].pin != (u16)-1 &&
+                            info->pins[i].pin == info->pins[j].pin) {
+                                pr_err("%s: pin %s/%s: pin %u conflict\n",
+                                       drvname, info->pins[i].name,
+                                       info->pins[j].name, info->pins[i].pin);
+                                sh_pfc_errors++;
+                        }
+
+                        if (info->pins[i].enum_id &&
+                            info->pins[i].enum_id == info->pins[j].enum_id) {
+                                pr_err("%s: pin %s/%s: enum_id %u conflict\n",
+                                       drvname, info->pins[i].name,
+                                       info->pins[j].name,
+                                       info->pins[i].enum_id);
+                                sh_pfc_errors++;
+                        }
+                }
+        }
+
         /* Check groups and functions */
         refcnts = kcalloc(info->nr_groups, sizeof(*refcnts), GFP_KERNEL);
         if (!refcnts)
@@ -780,9 +809,15 @@ static void sh_pfc_check_info(const struct sh_pfc_soc_info *info)
 
         for (i = 0; i < info->nr_functions; i++) {
                 func = &info->functions[i];
+                if (!func->name) {
+                        pr_err("%s: empty function %u\n", drvname, i);
+                        sh_pfc_errors++;
+                        continue;
+                }
                 for (j = 0; j < func->nr_groups; j++) {
                         for (k = 0; k < info->nr_groups; k++) {
-                                if (!strcmp(func->groups[j],
+                                if (info->groups[k].name &&
+                                    !strcmp(func->groups[j],
                                             info->groups[k].name)) {
                                         refcnts[k]++;
                                         break;
@@ -798,13 +833,18 @@ static void sh_pfc_check_info(const struct sh_pfc_soc_info *info)
         }
 
         for (i = 0; i < info->nr_groups; i++) {
+                if (!info->groups[i].name) {
+                        pr_err("%s: empty group %u\n", drvname, i);
+                        sh_pfc_errors++;
+                        continue;
+                }
                 if (!refcnts[i]) {
                         pr_err("%s: orphan group %s\n", drvname,
                                info->groups[i].name);
                         sh_pfc_errors++;
                 } else if (refcnts[i] > 1) {
-                        pr_err("%s: group %s referred by %u functions\n",
-                               drvname, info->groups[i].name, refcnts[i]);
+                        pr_warn("%s: group %s referenced by %u functions\n",
+                                drvname, info->groups[i].name, refcnts[i]);
                         sh_pfc_warnings++;
                 }
         }
@@ -816,7 +856,7 @@ static void sh_pfc_check_info(const struct sh_pfc_soc_info *info)
                 sh_pfc_check_cfg_reg(drvname, &info->cfg_regs[i]);
 }
 
-static void sh_pfc_check_driver(const struct platform_driver *pdrv)
+static void __init sh_pfc_check_driver(const struct platform_driver *pdrv)
 {
         unsigned int i;
 
diff --git a/drivers/pinctrl/sh-pfc/pfc-emev2.c b/drivers/pinctrl/sh-pfc/pfc-emev2.c
index 0af1ef82a1a8..6c66fc335d2f 100644
--- a/drivers/pinctrl/sh-pfc/pfc-emev2.c
+++ b/drivers/pinctrl/sh-pfc/pfc-emev2.c
@@ -19,6 +19,20 @@
         PORT_1(155, fn, pfx##155, sfx), PORT_1(156, fn, pfx##156, sfx), \
         PORT_1(157, fn, pfx##157, sfx), PORT_1(158, fn, pfx##158, sfx)
 
+#define CPU_ALL_NOGP(fn)                \
+        PIN_NOGP(LCD3_B2, "B15", fn),   \
+        PIN_NOGP(LCD3_B3, "C15", fn),   \
+        PIN_NOGP(LCD3_B4, "D15", fn),   \
+        PIN_NOGP(LCD3_B5, "B14", fn),   \
+        PIN_NOGP(LCD3_B6, "C14", fn),   \
+        PIN_NOGP(LCD3_B7, "D14", fn),   \
+        PIN_NOGP(LCD3_G2, "B17", fn),   \
+        PIN_NOGP(LCD3_G3, "C17", fn),   \
+        PIN_NOGP(LCD3_G4, "D17", fn),   \
+        PIN_NOGP(LCD3_G5, "B16", fn),   \
+        PIN_NOGP(LCD3_G6, "C16", fn),   \
+        PIN_NOGP(LCD3_G7, "D16", fn)
+
 enum {
         PINMUX_RESERVED = 0,
 
@@ -218,10 +232,13 @@ enum {
         PINMUX_MARK_END,
 };
 
-/* Pin numbers for pins without a corresponding GPIO port number are computed
- * from the row and column numbers with a 1000 offset to avoid collisions with
- * GPIO port numbers. */
-#define PIN_NUMBER(row, col)            (1000+((row)-1)*23+(col)-1)
+/*
+ * Pins not associated with a GPIO port.
+ */
+enum {
+        PORT_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 /* Expand to a list of sh_pfc_pin entries (named PORT#).
  * NOTE: No config are recorded since the driver do not handle pinconf. */
@@ -230,20 +247,7 @@ enum {
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_EMEV_GPIO_ALL(),
-
-        /* Pins not associated with a GPIO port */
-        SH_PFC_PIN_NAMED(2, 14, B14),
-        SH_PFC_PIN_NAMED(2, 15, B15),
-        SH_PFC_PIN_NAMED(2, 16, B16),
-        SH_PFC_PIN_NAMED(2, 17, B17),
-        SH_PFC_PIN_NAMED(3, 14, C14),
-        SH_PFC_PIN_NAMED(3, 15, C15),
-        SH_PFC_PIN_NAMED(3, 16, C16),
-        SH_PFC_PIN_NAMED(3, 17, C17),
-        SH_PFC_PIN_NAMED(4, 14, D14),
-        SH_PFC_PIN_NAMED(4, 15, D15),
-        SH_PFC_PIN_NAMED(4, 16, D16),
-        SH_PFC_PIN_NAMED(4, 17, D17),
+        PINMUX_NOGP_ALL(),
 };
 
 /* Expand to a list of name_DATA, name_FN marks */
@@ -829,12 +833,10 @@ static const unsigned int lcd3_rgb888_pins[] = {
         /* R[0:7], G[0:7], B[0:7] */
         32, 33, 34, 35,
         36, 37, 38, 39,
-        40, 41, PIN_NUMBER(2, 17), PIN_NUMBER(3, 17),
-        PIN_NUMBER(4, 17), PIN_NUMBER(2, 16), PIN_NUMBER(3, 16),
-        PIN_NUMBER(4, 16),
-        42, 43, PIN_NUMBER(2, 15), PIN_NUMBER(3, 15),
-        PIN_NUMBER(4, 15), PIN_NUMBER(2, 14), PIN_NUMBER(3, 14),
-        PIN_NUMBER(4, 14)
+        40, 41, PIN_LCD3_G2, PIN_LCD3_G3,
+        PIN_LCD3_G4, PIN_LCD3_G5, PIN_LCD3_G6, PIN_LCD3_G7,
+        42, 43, PIN_LCD3_B2, PIN_LCD3_B3,
+        PIN_LCD3_B4, PIN_LCD3_B5, PIN_LCD3_B6, PIN_LCD3_B7
 };
 static const unsigned int lcd3_rgb888_mux[] = {
         LCD3_R0_MARK, LCD3_R1_MARK, LCD3_R2_MARK, LCD3_R3_MARK,
@@ -850,12 +852,10 @@ static const unsigned int yuv3_pins[] = {
         /* CLK_O, HS, VS, DE */
         18, 21, 22, 23,
         /* YUV3_D[0:15] */
-        40, 41, PIN_NUMBER(2, 17), PIN_NUMBER(3, 17),
-        PIN_NUMBER(4, 17), PIN_NUMBER(2, 16), PIN_NUMBER(3, 16),
-        PIN_NUMBER(4, 16),
-        42, 43, PIN_NUMBER(2, 15), PIN_NUMBER(3, 15),
-        PIN_NUMBER(4, 15), PIN_NUMBER(2, 14), PIN_NUMBER(3, 14),
-        PIN_NUMBER(4, 14),
+        40, 41, PIN_LCD3_G2, PIN_LCD3_G3,
+        PIN_LCD3_G4, PIN_LCD3_G5, PIN_LCD3_G6, PIN_LCD3_G7,
+        42, 43, PIN_LCD3_B2, PIN_LCD3_B3,
+        PIN_LCD3_B4, PIN_LCD3_B5, PIN_LCD3_B6, PIN_LCD3_B7,
 };
 static const unsigned int yuv3_mux[] = {
         YUV3_CLK_O_MARK, YUV3_HS_MARK, YUV3_VS_MARK, YUV3_DE_MARK,
@@ -972,12 +972,10 @@ static const unsigned int tp33_pins[] = {
         /* CLK, CTRL */
         38, 39,
         /* TP33_DATA[0:15] */
-        40, 41, PIN_NUMBER(2, 17), PIN_NUMBER(3, 17),
-        PIN_NUMBER(4, 17), PIN_NUMBER(2, 16), PIN_NUMBER(3, 16),
-        PIN_NUMBER(4, 16),
-        42, 43, PIN_NUMBER(2, 15), PIN_NUMBER(3, 15),
-        PIN_NUMBER(4, 15), PIN_NUMBER(2, 14), PIN_NUMBER(3, 14),
-        PIN_NUMBER(4, 14),
+        40, 41, PIN_LCD3_G2, PIN_LCD3_G3,
+        PIN_LCD3_G4, PIN_LCD3_G5, PIN_LCD3_G6, PIN_LCD3_G7,
+        42, 43, PIN_LCD3_B2, PIN_LCD3_B3,
+        PIN_LCD3_B4, PIN_LCD3_B5, PIN_LCD3_B6, PIN_LCD3_B7,
 };
 static const unsigned int tp33_mux[] = {
         TP33_CLK_MARK, TP33_CTRL_MARK,
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a73a4.c b/drivers/pinctrl/sh-pfc/pfc-r8a73a4.c
index bf12849defdb..b21f5afe610f 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a73a4.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a73a4.c
@@ -1252,7 +1252,7 @@ static const u16 pinmux_data[] = {
 
 #define __O     (SH_PFC_PIN_CFG_OUTPUT)
 #define __IO    (SH_PFC_PIN_CFG_INPUT | SH_PFC_PIN_CFG_OUTPUT)
-#define __PUD   (SH_PFC_PIN_CFG_PULL_DOWN | SH_PFC_PIN_CFG_PULL_UP)
+#define __PUD   (SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
 #define R8A73A4_PIN_IO_PU_PD(pin)       SH_PFC_PIN_CFG(pin, __IO | __PUD)
 #define R8A73A4_PIN_O(pin)              SH_PFC_PIN_CFG(pin, __O)
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7740.c b/drivers/pinctrl/sh-pfc/pfc-r8a7740.c
index 696a0f6fc1da..fdf1b0f09f57 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7740.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7740.c
@@ -1515,7 +1515,7 @@ static const u16 pinmux_data[] = {
 #define __IO            (SH_PFC_PIN_CFG_INPUT | SH_PFC_PIN_CFG_OUTPUT)
 #define __PD            (SH_PFC_PIN_CFG_PULL_DOWN)
 #define __PU            (SH_PFC_PIN_CFG_PULL_UP)
-#define __PUD           (SH_PFC_PIN_CFG_PULL_DOWN | SH_PFC_PIN_CFG_PULL_UP)
+#define __PUD           (SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
 #define R8A7740_PIN_I_PD(pin)           SH_PFC_PIN_CFG(pin, __I | __PD)
 #define R8A7740_PIN_I_PU(pin)           SH_PFC_PIN_CFG(pin, __I | __PU)
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77470.c b/drivers/pinctrl/sh-pfc/pfc-r8a77470.c
index c05dc1490486..b3b116da1bb0 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77470.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77470.c
@@ -10,7 +10,7 @@
 
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_4(0, fn, sfx),                                          \
         PORT_GP_1(0, 4, fn, sfx),                                       \
         PORT_GP_CFG_1(0,  5, fn, sfx, SH_PFC_PIN_CFG_IO_VOLTAGE),       \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7778.c b/drivers/pinctrl/sh-pfc/pfc-r8a7778.c
index 49fe52d35f30..24866a5958ae 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7778.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7778.c
@@ -22,28 +22,17 @@
 #define PORT_GP_PUP_1(bank, pin, fn, sfx)       \
         PORT_GP_CFG_1(bank, pin, fn, sfx, SH_PFC_PIN_CFG_PULL_UP)
 
-#define PORT_GP_PUP_27(bank, fn, sfx)                                   \
-        PORT_GP_PUP_1(bank, 0,  fn, sfx), PORT_GP_PUP_1(bank, 1,  fn, sfx),     \
-        PORT_GP_PUP_1(bank, 2,  fn, sfx), PORT_GP_PUP_1(bank, 3,  fn, sfx),     \
-        PORT_GP_PUP_1(bank, 4,  fn, sfx), PORT_GP_PUP_1(bank, 5,  fn, sfx),     \
-        PORT_GP_PUP_1(bank, 6,  fn, sfx), PORT_GP_PUP_1(bank, 7,  fn, sfx),     \
-        PORT_GP_PUP_1(bank, 8,  fn, sfx), PORT_GP_PUP_1(bank, 9,  fn, sfx),     \
-        PORT_GP_PUP_1(bank, 10, fn, sfx), PORT_GP_PUP_1(bank, 11, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 12, fn, sfx), PORT_GP_PUP_1(bank, 13, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 14, fn, sfx), PORT_GP_PUP_1(bank, 15, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 16, fn, sfx), PORT_GP_PUP_1(bank, 17, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 18, fn, sfx), PORT_GP_PUP_1(bank, 19, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 20, fn, sfx), PORT_GP_PUP_1(bank, 21, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 22, fn, sfx), PORT_GP_PUP_1(bank, 23, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 24, fn, sfx), PORT_GP_PUP_1(bank, 25, fn, sfx),     \
-        PORT_GP_PUP_1(bank, 26, fn, sfx)
-
-#define CPU_ALL_PORT(fn, sfx)           \
+#define CPU_ALL_GP(fn, sfx)             \
         PORT_GP_CFG_32(0, fn, sfx, SH_PFC_PIN_CFG_PULL_UP),             \
         PORT_GP_CFG_32(1, fn, sfx, SH_PFC_PIN_CFG_PULL_UP),             \
         PORT_GP_CFG_32(2, fn, sfx, SH_PFC_PIN_CFG_PULL_UP),             \
         PORT_GP_CFG_32(3, fn, sfx, SH_PFC_PIN_CFG_PULL_UP),             \
-        PORT_GP_PUP_27(4, fn, sfx)
+        PORT_GP_CFG_27(4, fn, sfx, SH_PFC_PIN_CFG_PULL_UP)
+
+#define CPU_ALL_NOGP(fn)                \
+        PIN_NOGP(CLKOUT, "B25", fn),    \
+        PIN_NOGP(CS0, "A20", fn),       \
+        PIN_NOGP(CS1_A26, "C20", fn)
 
 enum {
         PINMUX_RESERVED = 0,
@@ -1253,19 +1242,17 @@ static const u16 pinmux_data[] = {
         PINMUX_IPSR_MSEL(IP10_24_22,    CAN_CLK_C,      SEL_CANCLK_C),
 };
 
-/* Pin numbers for pins without a corresponding GPIO port number are computed
- * from the row and column numbers with a 1000 offset to avoid collisions with
- * GPIO port numbers.
+/*
+ * Pins not associated with a GPIO port.
  */
-#define PIN_NUMBER(row, col)            (1000+((row)-1)*25+(col)-1)
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /* Pins not associated with a GPIO port */
-        SH_PFC_PIN_NAMED(3, 20, C20),
-        SH_PFC_PIN_NAMED(1, 20, A20),
-        SH_PFC_PIN_NAMED(2, 25, B25),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - macro */
@@ -1400,7 +1387,7 @@ HSPI_PFC_DAT(hspi1_a,	HSPI_CLK1_A,		HSPI_CS1_A,
                         HSPI_RX1_A,             HSPI_TX1_A);
 
 HSPI_PFC_PIN(hspi1_b,   RCAR_GP_PIN(0, 27),     RCAR_GP_PIN(0, 26),
-                        PIN_NUMBER(1, 20),      PIN_NUMBER(2, 25));
+                        PIN_CS0,                PIN_CLKOUT);
 HSPI_PFC_DAT(hspi1_b,   HSPI_CLK1_B,            HSPI_CS1_B,
                         HSPI_RX1_B,             HSPI_TX1_B);
 
@@ -1426,7 +1413,7 @@ I2C_PFC_PIN(i2c1_b,	RCAR_GP_PIN(4, 17),	RCAR_GP_PIN(4, 18));
 I2C_PFC_MUX(i2c1_b,     SDA1_B,                 SCL1_B);
 
 /* - I2C2 ------------------------------------------------------------------ */
-I2C_PFC_PIN(i2c2_a,     PIN_NUMBER(3, 20),      RCAR_GP_PIN(1, 3));
+I2C_PFC_PIN(i2c2_a,     PIN_CS1_A26,            RCAR_GP_PIN(1, 3));
 I2C_PFC_MUX(i2c2_a,     SDA2_A,                 SCL2_A);
 I2C_PFC_PIN(i2c2_b,     RCAR_GP_PIN(0, 3),      RCAR_GP_PIN(0, 4));
 I2C_PFC_MUX(i2c2_b,     SDA2_B,                 SCL2_B);
@@ -1516,7 +1503,7 @@ SCIF_PFC_PIN(scif2_data_e,	RCAR_GP_PIN(0, 3),	RCAR_GP_PIN(0, 4));
 SCIF_PFC_DAT(scif2_data_e,      TX2_E,                  RX2_E);
 SCIF_PFC_PIN(scif2_clk_a,       RCAR_GP_PIN(3, 9));
 SCIF_PFC_CLK(scif2_clk_a,       SCK2_A);
-SCIF_PFC_PIN(scif2_clk_b,       PIN_NUMBER(3, 20));
+SCIF_PFC_PIN(scif2_clk_b,       PIN_CS1_A26);
 SCIF_PFC_CLK(scif2_clk_b,       SCK2_B);
 SCIF_PFC_PIN(scif2_clk_c,       RCAR_GP_PIN(4, 12));
 SCIF_PFC_CLK(scif2_clk_c,       SCK2_C);
@@ -1631,7 +1618,7 @@ SSI_PFC_PINS(ssi0_data,		RCAR_GP_PIN(3, 10));
 SSI_PFC_DATA(ssi0_data,         SSI_SDATA0);
 SSI_PFC_PINS(ssi1_a_ctrl,       RCAR_GP_PIN(2, 20),     RCAR_GP_PIN(2, 21));
 SSI_PFC_CTRL(ssi1_a_ctrl,       SSI_SCK1_A,             SSI_WS1_A);
-SSI_PFC_PINS(ssi1_b_ctrl,       PIN_NUMBER(3, 20),      RCAR_GP_PIN(1, 3));
+SSI_PFC_PINS(ssi1_b_ctrl,       PIN_CS1_A26,            RCAR_GP_PIN(1, 3));
 SSI_PFC_CTRL(ssi1_b_ctrl,       SSI_SCK1_B,             SSI_WS1_B);
 SSI_PFC_PINS(ssi1_data,         RCAR_GP_PIN(3, 9));
 SSI_PFC_DATA(ssi1_data,         SSI_SDATA1);
@@ -2921,8 +2908,6 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = {
         { },
 };
 
-#define PIN_NONE        U16_MAX
-
 static const struct pinmux_bias_reg pinmux_bias_regs[] = {
         { PINMUX_BIAS_REG("PUPR0", 0x100, "N/A", 0) {
                 [ 0] = RCAR_GP_PIN(0,  6),      /* A0 */
@@ -2969,28 +2954,28 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 7] = RCAR_GP_PIN(1, 10),      /* DACK0        */
                 [ 8] = RCAR_GP_PIN(1, 12),      /* IRQ0         */
                 [ 9] = RCAR_GP_PIN(1, 13),      /* IRQ1         */
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { PINMUX_BIAS_REG("PUPR2", 0x108, "N/A", 0) {
                 [ 0] = RCAR_GP_PIN(1, 22),      /* DU0_DR0      */
@@ -3112,21 +3097,21 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [14] = RCAR_GP_PIN(4, 20),      /* ETH_MAGIC    */
                 [15] = RCAR_GP_PIN(4, 25),      /* AVS1         */
                 [16] = RCAR_GP_PIN(4, 26),      /* AVS2         */
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { /* sentinel */ },
 };
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7779.c b/drivers/pinctrl/sh-pfc/pfc-r8a7779.c
index 0c121b28ec3f..3e47cdc1411d 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7779.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7779.c
@@ -11,7 +11,7 @@
 
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_32(0, fn, sfx),                                         \
         PORT_GP_32(1, fn, sfx),                                         \
         PORT_GP_32(2, fn, sfx),                                         \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7790.c b/drivers/pinctrl/sh-pfc/pfc-r8a7790.c
index c41a6761cf9d..3366ed561cce 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7790.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7790.c
@@ -20,7 +20,7 @@
  * All pins assigned to GPIO bank 3 can be used for SD interfaces in
  * which case they support both 3.3V and 1.8V signalling.
  */
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_32(0, fn, sfx),                                         \
         PORT_GP_30(1, fn, sfx),                                         \
         PORT_GP_30(2, fn, sfx),                                         \
@@ -28,6 +28,12 @@
         PORT_GP_32(4, fn, sfx),                                         \
         PORT_GP_32(5, fn, sfx)
 
+#define CPU_ALL_NOGP(fn)                \
+        PIN_NOGP(IIC0_SDA, "AF15", fn), \
+        PIN_NOGP(IIC0_SCL, "AG15", fn), \
+        PIN_NOGP(IIC3_SDA, "AH15", fn), \
+        PIN_NOGP(IIC3_SCL, "AJ15", fn)
+
 enum {
         PINMUX_RESERVED = 0,
 
@@ -1727,19 +1733,17 @@ static const u16 pinmux_data[] = {
         PINMUX_DATA(I2C3_SDA_MARK, FN_SEL_IICDVFS_1),
 };
 
-/* R8A7790 has 6 banks with 32 GPIOs in each = 192 GPIOs */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 31 + (c) + 200)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
+/*
+ * Pins not associated with a GPIO port.
+ */
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /* Pins not associated with a GPIO port */
-        SH_PFC_PIN_NAMED(ROW_GROUP_A('F'), 15, AF15),
-        SH_PFC_PIN_NAMED(ROW_GROUP_A('G'), 15, AG15),
-        SH_PFC_PIN_NAMED(ROW_GROUP_A('H'), 15, AH15),
-        SH_PFC_PIN_NAMED(ROW_GROUP_A('J'), 15, AJ15),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -2135,7 +2139,7 @@ static const unsigned int hscif1_ctrl_b_mux[] = {
 /* - I2C0 ------------------------------------------------------------------- */
 static const unsigned int i2c0_pins[] = {
         /* SCL, SDA */
-        PIN_A_NUMBER('G', 15), PIN_A_NUMBER('F', 15),
+        PIN_IIC0_SCL, PIN_IIC0_SDA,
 };
 static const unsigned int i2c0_mux[] = {
         I2C0_SCL_MARK, I2C0_SDA_MARK,
@@ -2201,7 +2205,7 @@ static const unsigned int i2c2_e_mux[] = {
 /* - I2C3 ------------------------------------------------------------------- */
 static const unsigned int i2c3_pins[] = {
         /* SCL, SDA */
-        PIN_A_NUMBER('J', 15), PIN_A_NUMBER('H', 15),
+        PIN_IIC3_SCL, PIN_IIC3_SDA,
 };
 static const unsigned int i2c3_mux[] = {
         I2C3_SCL_MARK, I2C3_SDA_MARK,
@@ -2209,7 +2213,7 @@ static const unsigned int i2c3_mux[] = {
 /* - IIC0 (I2C4) ------------------------------------------------------------ */
 static const unsigned int iic0_pins[] = {
         /* SCL, SDA */
-        PIN_A_NUMBER('G', 15), PIN_A_NUMBER('F', 15),
+        PIN_IIC0_SCL, PIN_IIC0_SDA,
 };
 static const unsigned int iic0_mux[] = {
         IIC0_SCL_MARK, IIC0_SDA_MARK,
@@ -2274,8 +2278,8 @@ static const unsigned int iic2_e_mux[] = {
 };
 /* - IIC3 (I2C7) ------------------------------------------------------------ */
 static const unsigned int iic3_pins[] = {
-/* SCL, SDA */
-        PIN_A_NUMBER('J', 15), PIN_A_NUMBER('H', 15),
+        /* SCL, SDA */
+        PIN_IIC3_SCL, PIN_IIC3_SDA,
 };
 static const unsigned int iic3_mux[] = {
         IIC3_SCL_MARK, IIC3_SDA_MARK,
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7791.c b/drivers/pinctrl/sh-pfc/pfc-r8a7791.c
index 1292ec8d268f..bc9caf812fc1 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7791.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7791.c
@@ -15,7 +15,7 @@
  * Pins 0-23 assigned to GPIO bank 6 can be used for SD interfaces in
  * which case they support both 3.3V and 1.8V signalling.
  */
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_32(0, fn, sfx),                                         \
         PORT_GP_26(1, fn, sfx),                                         \
         PORT_GP_32(2, fn, sfx),                                         \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7792.c b/drivers/pinctrl/sh-pfc/pfc-r8a7792.c
index bbace1478613..258f82fb31c0 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7792.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7792.c
@@ -11,7 +11,7 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_29(0, fn, sfx),                                         \
         PORT_GP_23(1, fn, sfx),                                         \
         PORT_GP_32(2, fn, sfx),                                         \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7794.c b/drivers/pinctrl/sh-pfc/pfc-r8a7794.c
index 1ff4969d8381..34481b6c4328 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7794.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7794.c
@@ -14,7 +14,7 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_32(0, fn, sfx),                                         \
         PORT_GP_26(1, fn, sfx),                                         \
         PORT_GP_32(2, fn, sfx),                                         \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7795-es1.c b/drivers/pinctrl/sh-pfc/pfc-r8a7795-es1.c
index f16dfbad3f17..95f9aae3bfba 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7795-es1.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7795-es1.c
@@ -11,11 +11,9 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | \
-                   SH_PFC_PIN_CFG_PULL_UP | \
-                   SH_PFC_PIN_CFG_PULL_DOWN)
+#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_CFG_16(0, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_28(1, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_15(2, fn, sfx, CFG_FLAGS),  \
@@ -28,6 +26,53 @@
         PORT_GP_CFG_26(5, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_32(6, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_4(7, fn, sfx, CFG_FLAGS)
+
+#define CPU_ALL_NOGP(fn)                                                \
+        PIN_NOGP_CFG(ASEBRK, "ASEBRK", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(AVB_MDIO, "AVB_MDIO", fn, CFG_FLAGS),              \
+        PIN_NOGP_CFG(AVB_RD0, "AVB_RD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD1, "AVB_RD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD2, "AVB_RD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD3, "AVB_RD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RXC, "AVB_RXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RX_CTL, "AVB_RX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(AVB_TD0, "AVB_TD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD1, "AVB_TD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD2, "AVB_TD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD3, "AVB_TD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXC, "AVB_TXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXCREFCLK, "AVB_TXCREFCLK", fn, CFG_FLAGS),    \
+        PIN_NOGP_CFG(AVB_TX_CTL, "AVB_TX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(CLKOUT, "CLKOUT", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(DU_DOTCLKIN0, "DU_DOTCLKIN0", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN1, "DU_DOTCLKIN1", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN2, "DU_DOTCLKIN2", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN3, "DU_DOTCLKIN3", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(EXTALR, "EXTALR", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),\
+        PIN_NOGP_CFG(FSCLKST_N, "FSCLKST#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(MLB_REF, "MLB_REF", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(PRESETOUT_N, "PRESETOUT#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(QSPI0_IO2, "QSPI0_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_IO3, "QSPI0_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_MISO_IO1, "QSPI0_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_MOSI_IO0, "QSPI0_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_SPCLK, "QSPI0_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI0_SSL, "QSPI0_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO2, "QSPI1_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO3, "QSPI1_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_MISO_IO1, "QSPI1_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_MOSI_IO0, "QSPI1_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_SPCLK, "QSPI1_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI1_SSL, "QSPI1_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(RPC_INT_N, "RPC_INT#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(RPC_RESET_N, "RPC_RESET#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(RPC_WP_N, "RPC_WP#", fn, CFG_FLAGS),               \
+        PIN_NOGP_CFG(TCK, "TCK", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDI, "TDI", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDO, "TDO", fn, SH_PFC_PIN_CFG_DRIVE_STRENGTH),    \
+        PIN_NOGP_CFG(TMS, "TMS", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TRST_N, "TRST#", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN)
+
 /*
  * F_() : just information
  * FM() : macro for FN_xxx / xxx_MARK
@@ -1447,69 +1492,16 @@ static const u16 pinmux_data[] = {
 };
 
 /*
- * R8A7795 has 8 banks with 32 GPIOs in each => 256 GPIOs.
- * Physical layout rows: A - AW, cols: 1 - 39.
+ * Pins not associated with a GPIO port.
  */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 39 + (c) + 300)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
-#define PIN_NONE U16_MAX
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /*
-         * Pins not associated with a GPIO port.
-         *
-         * The pin positions are different between different r8a7795
-         * packages, all that is needed for the pfc driver is a unique
-         * number for each pin. To this end use the pin layout from
-         * R-Car H3SiP to calculate a unique number for each pin.
-         */
-        SH_PFC_PIN_NAMED_CFG('A',  8, AVB_TX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A',  9, AVB_MDIO, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 12, AVB_TXCREFCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 13, AVB_RD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 14, AVB_RD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 16, AVB_RX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 17, AVB_TD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 18, AVB_TD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 19, AVB_TXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 13, AVB_RD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 14, AVB_RD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 17, AVB_TD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 18, AVB_TD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 19, AVB_RXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('C',  1, PRESETOUT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('F',  1, CLKOUT, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('H', 37, MLB_REF, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  3, QSPI1_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  5, QSPI1_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  6, RPC_WP#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  7, RPC_RESET#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('W',  3, QSPI0_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  3, QSPI0_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  6, QSPI0_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  7, RPC_INT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  4, QSPI0_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  6, QSPI0_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  3, QSPI1_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  5, QSPI0_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  7, QSPI1_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 38, FSCLKST#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 39, EXTALR, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  4, QSPI1_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  5, QSPI1_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  7, DU_DOTCLKIN0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  8, DU_DOTCLKIN1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  7, DU_DOTCLKIN2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  8, DU_DOTCLKIN3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 26, TRST#, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 29, TDI, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 30, TMS, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 27, TCK, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 28, TDO, SH_PFC_PIN_CFG_DRIVE_STRENGTH),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 30, ASEBRK, CFG_FLAGS),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -1658,7 +1650,7 @@ static const unsigned int avb_phy_int_mux[] = {
 };
 static const unsigned int avb_mdio_pins[] = {
         /* AVB_MDC, AVB_MDIO */
-        RCAR_GP_PIN(2, 9), PIN_NUMBER('A', 9),
+        RCAR_GP_PIN(2, 9), PIN_AVB_MDIO,
 };
 static const unsigned int avb_mdio_mux[] = {
         AVB_MDC_MARK, AVB_MDIO_MARK,
@@ -1671,11 +1663,11 @@ static const unsigned int avb_mii_pins[] = {
          * AVB_RD1, AVB_RD2, AVB_RD3,
          * AVB_TXCREFCLK
          */
-        PIN_NUMBER('A', 8), PIN_NUMBER('A', 19), PIN_NUMBER('A', 18),
-        PIN_NUMBER('B', 18), PIN_NUMBER('A', 17), PIN_NUMBER('B', 17),
-        PIN_NUMBER('A', 16), PIN_NUMBER('B', 19), PIN_NUMBER('A', 13),
-        PIN_NUMBER('B', 13), PIN_NUMBER('A', 14), PIN_NUMBER('B', 14),
-        PIN_NUMBER('A', 12),
+        PIN_AVB_TX_CTL, PIN_AVB_TXC, PIN_AVB_TD0,
+        PIN_AVB_TD1, PIN_AVB_TD2, PIN_AVB_TD3,
+        PIN_AVB_RX_CTL, PIN_AVB_RXC, PIN_AVB_RD0,
+        PIN_AVB_RD1, PIN_AVB_RD2, PIN_AVB_RD3,
+        PIN_AVB_TXCREFCLK,
 
 };
 static const unsigned int avb_mii_mux[] = {
@@ -3137,22 +3129,21 @@ static const unsigned int pwm6_b_mux[] = {
 /* - QSPI0 ------------------------------------------------------------------ */
 static const unsigned int qspi0_ctrl_pins[] = {
         /* QSPI0_SPCLK, QSPI0_SSL */
-        PIN_NUMBER('W', 3), PIN_NUMBER('Y', 3),
+        PIN_QSPI0_SPCLK, PIN_QSPI0_SSL,
 };
 static const unsigned int qspi0_ctrl_mux[] = {
         QSPI0_SPCLK_MARK, QSPI0_SSL_MARK,
 };
 static const unsigned int qspi0_data2_pins[] = {
         /* QSPI0_MOSI_IO0, QSPI0_MISO_IO1 */
-        PIN_A_NUMBER('C', 5), PIN_A_NUMBER('B', 4),
+        PIN_QSPI0_MOSI_IO0, PIN_QSPI0_MISO_IO1,
 };
 static const unsigned int qspi0_data2_mux[] = {
         QSPI0_MOSI_IO0_MARK, QSPI0_MISO_IO1_MARK,
 };
 static const unsigned int qspi0_data4_pins[] = {
         /* QSPI0_MOSI_IO0, QSPI0_MISO_IO1, QSPI0_IO2, QSPI0_IO3 */
-        PIN_A_NUMBER('C', 5), PIN_A_NUMBER('B', 4),
-        PIN_NUMBER('Y', 6), PIN_A_NUMBER('B', 6),
+        PIN_QSPI0_MOSI_IO0, PIN_QSPI0_MISO_IO1, PIN_QSPI0_IO2, PIN_QSPI0_IO3,
 };
 static const unsigned int qspi0_data4_mux[] = {
         QSPI0_MOSI_IO0_MARK, QSPI0_MISO_IO1_MARK,
@@ -3161,22 +3152,21 @@ static const unsigned int qspi0_data4_mux[] = {
 /* - QSPI1 ------------------------------------------------------------------ */
 static const unsigned int qspi1_ctrl_pins[] = {
         /* QSPI1_SPCLK, QSPI1_SSL */
-        PIN_NUMBER('V', 3), PIN_NUMBER('V', 5),
+        PIN_QSPI1_SPCLK, PIN_QSPI1_SSL,
 };
 static const unsigned int qspi1_ctrl_mux[] = {
         QSPI1_SPCLK_MARK, QSPI1_SSL_MARK,
 };
 static const unsigned int qspi1_data2_pins[] = {
         /* QSPI1_MOSI_IO0, QSPI1_MISO_IO1 */
-        PIN_A_NUMBER('C', 7), PIN_A_NUMBER('E', 5),
+        PIN_QSPI1_MOSI_IO0, PIN_QSPI1_MISO_IO1,
 };
 static const unsigned int qspi1_data2_mux[] = {
         QSPI1_MOSI_IO0_MARK, QSPI1_MISO_IO1_MARK,
 };
 static const unsigned int qspi1_data4_pins[] = {
         /* QSPI1_MOSI_IO0, QSPI1_MISO_IO1, QSPI1_IO2, QSPI1_IO3 */
-        PIN_A_NUMBER('C', 7), PIN_A_NUMBER('E', 5),
-        PIN_A_NUMBER('E', 4), PIN_A_NUMBER('C', 3),
+        PIN_QSPI1_MOSI_IO0, PIN_QSPI1_MISO_IO1, PIN_QSPI1_IO2, PIN_QSPI1_IO3,
 };
 static const unsigned int qspi1_data4_mux[] = {
         QSPI1_MOSI_IO0_MARK, QSPI1_MISO_IO1_MARK,
@@ -3812,6 +3802,36 @@ static const unsigned int tmu_tclk2_b_mux[] = {
         TCLK2_B_MARK,
 };
 
+/* - TPU ------------------------------------------------------------------- */
+static const unsigned int tpu_to0_pins[] = {
+        /* TPU0TO0 */
+        RCAR_GP_PIN(6, 28),
+};
+static const unsigned int tpu_to0_mux[] = {
+        TPU0TO0_MARK,
+};
+static const unsigned int tpu_to1_pins[] = {
+        /* TPU0TO1 */
+        RCAR_GP_PIN(6, 29),
+};
+static const unsigned int tpu_to1_mux[] = {
+        TPU0TO1_MARK,
+};
+static const unsigned int tpu_to2_pins[] = {
+        /* TPU0TO2 */
+        RCAR_GP_PIN(6, 30),
+};
+static const unsigned int tpu_to2_mux[] = {
+        TPU0TO2_MARK,
+};
+static const unsigned int tpu_to3_pins[] = {
+        /* TPU0TO3 */
+        RCAR_GP_PIN(6, 31),
+};
+static const unsigned int tpu_to3_mux[] = {
+        TPU0TO3_MARK,
+};
+
 /* - USB0 ------------------------------------------------------------------- */
 static const unsigned int usb0_pins[] = {
         /* PWEN, OVC */
@@ -4165,6 +4185,10 @@ static const struct sh_pfc_pin_group pinmux_groups[] = {
         SH_PFC_PIN_GROUP(tmu_tclk1_b),
         SH_PFC_PIN_GROUP(tmu_tclk2_a),
         SH_PFC_PIN_GROUP(tmu_tclk2_b),
+        SH_PFC_PIN_GROUP(tpu_to0),
+        SH_PFC_PIN_GROUP(tpu_to1),
+        SH_PFC_PIN_GROUP(tpu_to2),
+        SH_PFC_PIN_GROUP(tpu_to3),
         SH_PFC_PIN_GROUP(usb0),
         SH_PFC_PIN_GROUP(usb1),
         SH_PFC_PIN_GROUP(usb2),
@@ -4635,6 +4659,13 @@ static const char * const tmu_groups[] = {
         "tmu_tclk2_b",
 };
 
+static const char * const tpu_groups[] = {
+        "tpu_to0",
+        "tpu_to1",
+        "tpu_to2",
+        "tpu_to3",
+};
+
 static const char * const usb0_groups[] = {
         "usb0",
 };
@@ -4707,6 +4738,7 @@ static const struct sh_pfc_function pinmux_functions[] = {
         SH_PFC_FUNCTION(sdhi3),
         SH_PFC_FUNCTION(ssi),
         SH_PFC_FUNCTION(tmu),
+        SH_PFC_FUNCTION(tpu),
         SH_PFC_FUNCTION(usb0),
         SH_PFC_FUNCTION(usb1),
         SH_PFC_FUNCTION(usb2),
@@ -5272,44 +5304,44 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = {
 
 static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         { PINMUX_DRIVE_REG("DRVCTRL0", 0xe6060300) {
-                { PIN_NUMBER('W', 3),   28, 2 },        /* QSPI0_SPCLK */
-                { PIN_A_NUMBER('C', 5), 24, 2 },        /* QSPI0_MOSI_IO0 */
-                { PIN_A_NUMBER('B', 4), 20, 2 },        /* QSPI0_MISO_IO1 */
-                { PIN_NUMBER('Y', 6),   16, 2 },        /* QSPI0_IO2 */
-                { PIN_A_NUMBER('B', 6), 12, 2 },        /* QSPI0_IO3 */
-                { PIN_NUMBER('Y', 3),    8, 2 },        /* QSPI0_SSL */
-                { PIN_NUMBER('V', 3),    4, 2 },        /* QSPI1_SPCLK */
-                { PIN_A_NUMBER('C', 7),  0, 2 },        /* QSPI1_MOSI_IO0 */
+                { PIN_QSPI0_SPCLK,    28, 2 },  /* QSPI0_SPCLK */
+                { PIN_QSPI0_MOSI_IO0, 24, 2 },  /* QSPI0_MOSI_IO0 */
+                { PIN_QSPI0_MISO_IO1, 20, 2 },  /* QSPI0_MISO_IO1 */
+                { PIN_QSPI0_IO2,      16, 2 },  /* QSPI0_IO2 */
+                { PIN_QSPI0_IO3,      12, 2 },  /* QSPI0_IO3 */
+                { PIN_QSPI0_SSL,       8, 2 },  /* QSPI0_SSL */
+                { PIN_QSPI1_SPCLK,     4, 2 },  /* QSPI1_SPCLK */
+                { PIN_QSPI1_MOSI_IO0,  0, 2 },  /* QSPI1_MOSI_IO0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL1", 0xe6060304) {
-                { PIN_A_NUMBER('E', 5), 28, 2 },        /* QSPI1_MISO_IO1 */
-                { PIN_A_NUMBER('E', 4), 24, 2 },        /* QSPI1_IO2 */
-                { PIN_A_NUMBER('C', 3), 20, 2 },        /* QSPI1_IO3 */
-                { PIN_NUMBER('V', 5),   16, 2 },        /* QSPI1_SSL */
-                { PIN_NUMBER('Y', 7),   12, 2 },        /* RPC_INT# */
-                { PIN_NUMBER('V', 6),    8, 2 },        /* RPC_WP# */
-                { PIN_NUMBER('V', 7),    4, 2 },        /* RPC_RESET# */
-                { PIN_NUMBER('A', 16),   0, 3 },        /* AVB_RX_CTL */
+                { PIN_QSPI1_MISO_IO1, 28, 2 },  /* QSPI1_MISO_IO1 */
+                { PIN_QSPI1_IO2,      24, 2 },  /* QSPI1_IO2 */
+                { PIN_QSPI1_IO3,      20, 2 },  /* QSPI1_IO3 */
+                { PIN_QSPI1_SSL,      16, 2 },  /* QSPI1_SSL */
+                { PIN_RPC_INT_N,      12, 2 },  /* RPC_INT# */
+                { PIN_RPC_WP_N,        8, 2 },  /* RPC_WP# */
+                { PIN_RPC_RESET_N,     4, 2 },  /* RPC_RESET# */
+                { PIN_AVB_RX_CTL,      0, 3 },  /* AVB_RX_CTL */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL2", 0xe6060308) {
-                { PIN_NUMBER('B', 19),  28, 3 },        /* AVB_RXC */
-                { PIN_NUMBER('A', 13),  24, 3 },        /* AVB_RD0 */
-                { PIN_NUMBER('B', 13),  20, 3 },        /* AVB_RD1 */
-                { PIN_NUMBER('A', 14),  16, 3 },        /* AVB_RD2 */
-                { PIN_NUMBER('B', 14),  12, 3 },        /* AVB_RD3 */
-                { PIN_NUMBER('A', 8),    8, 3 },        /* AVB_TX_CTL */
-                { PIN_NUMBER('A', 19),   4, 3 },        /* AVB_TXC */
-                { PIN_NUMBER('A', 18),   0, 3 },        /* AVB_TD0 */
+                { PIN_AVB_RXC,        28, 3 },  /* AVB_RXC */
+                { PIN_AVB_RD0,        24, 3 },  /* AVB_RD0 */
+                { PIN_AVB_RD1,        20, 3 },  /* AVB_RD1 */
+                { PIN_AVB_RD2,        16, 3 },  /* AVB_RD2 */
+                { PIN_AVB_RD3,        12, 3 },  /* AVB_RD3 */
+                { PIN_AVB_TX_CTL,      8, 3 },  /* AVB_TX_CTL */
+                { PIN_AVB_TXC,         4, 3 },  /* AVB_TXC */
+                { PIN_AVB_TD0,         0, 3 },  /* AVB_TD0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL3", 0xe606030c) {
-                { PIN_NUMBER('B', 18),  28, 3 },        /* AVB_TD1 */
-                { PIN_NUMBER('A', 17),  24, 3 },        /* AVB_TD2 */
-                { PIN_NUMBER('B', 17),  20, 3 },        /* AVB_TD3 */
-                { PIN_NUMBER('A', 12),  16, 3 },        /* AVB_TXCREFCLK */
-                { PIN_NUMBER('A', 9),   12, 3 },        /* AVB_MDIO */
-                { RCAR_GP_PIN(2,  9),    8, 3 },        /* AVB_MDC */
-                { RCAR_GP_PIN(2, 10),    4, 3 },        /* AVB_MAGIC */
-                { RCAR_GP_PIN(2, 11),    0, 3 },        /* AVB_PHY_INT */
+                { PIN_AVB_TD1,        28, 3 },  /* AVB_TD1 */
+                { PIN_AVB_TD2,        24, 3 },  /* AVB_TD2 */
+                { PIN_AVB_TD3,        20, 3 },  /* AVB_TD3 */
+                { PIN_AVB_TXCREFCLK,  16, 3 },  /* AVB_TXCREFCLK */
+                { PIN_AVB_MDIO,       12, 3 },  /* AVB_MDIO */
+                { RCAR_GP_PIN(2,  9),  8, 3 },  /* AVB_MDC */
+                { RCAR_GP_PIN(2, 10),  4, 3 },  /* AVB_MAGIC */
+                { RCAR_GP_PIN(2, 11),  0, 3 },  /* AVB_PHY_INT */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL4", 0xe6060310) {
                 { RCAR_GP_PIN(2, 12), 28, 3 },  /* AVB_LINK */
@@ -5352,7 +5384,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(1, 19),  0, 3 },  /* A19 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL8", 0xe6060320) {
-                { PIN_NUMBER('F', 1), 28, 3 },  /* CLKOUT */
+                { PIN_CLKOUT,         28, 3 },  /* CLKOUT */
                 { RCAR_GP_PIN(1, 20), 24, 3 },  /* CS0 */
                 { RCAR_GP_PIN(1, 21), 20, 3 },  /* CS1_A26 */
                 { RCAR_GP_PIN(1, 22), 16, 3 },  /* BS */
@@ -5363,7 +5395,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         } },
         { PINMUX_DRIVE_REG("DRVCTRL9", 0xe6060324) {
                 { RCAR_GP_PIN(1, 27), 28, 3 },  /* EX_WAIT0 */
-                { PIN_NUMBER('C', 1), 24, 3 },  /* PRESETOUT# */
+                { PIN_PRESETOUT_N,    24, 3 },  /* PRESETOUT# */
                 { RCAR_GP_PIN(0,  0), 20, 3 },  /* D0 */
                 { RCAR_GP_PIN(0,  1), 16, 3 },  /* D1 */
                 { RCAR_GP_PIN(0,  2), 12, 3 },  /* D2 */
@@ -5382,30 +5414,30 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(0, 13),  0, 3 },  /* D13 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL11", 0xe606032c) {
-                { RCAR_GP_PIN(0, 14),   28, 3 },        /* D14 */
-                { RCAR_GP_PIN(0, 15),   24, 3 },        /* D15 */
-                { RCAR_GP_PIN(7,  0),   20, 3 },        /* AVS1 */
-                { RCAR_GP_PIN(7,  1),   16, 3 },        /* AVS2 */
-                { RCAR_GP_PIN(7,  2),   12, 3 },        /* GP7_02 */
-                { RCAR_GP_PIN(7,  3),    8, 3 },        /* GP7_03 */
-                { PIN_A_NUMBER('P', 7),  4, 2 },        /* DU_DOTCLKIN0 */
-                { PIN_A_NUMBER('P', 8),  0, 2 },        /* DU_DOTCLKIN1 */
+                { RCAR_GP_PIN(0, 14), 28, 3 },  /* D14 */
+                { RCAR_GP_PIN(0, 15), 24, 3 },  /* D15 */
+                { RCAR_GP_PIN(7,  0), 20, 3 },  /* AVS1 */
+                { RCAR_GP_PIN(7,  1), 16, 3 },  /* AVS2 */
+                { RCAR_GP_PIN(7,  2), 12, 3 },  /* GP7_02 */
+                { RCAR_GP_PIN(7,  3),  8, 3 },  /* GP7_03 */
+                { PIN_DU_DOTCLKIN0,    4, 2 },  /* DU_DOTCLKIN0 */
+                { PIN_DU_DOTCLKIN1,    0, 2 },  /* DU_DOTCLKIN1 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL12", 0xe6060330) {
-                { PIN_A_NUMBER('R', 7),  28, 2 },       /* DU_DOTCLKIN2 */
-                { PIN_A_NUMBER('R', 8),  24, 2 },       /* DU_DOTCLKIN3 */
-                { PIN_A_NUMBER('D', 38), 20, 2 },       /* FSCLKST# */
-                { PIN_A_NUMBER('R', 30),  4, 2 },       /* TMS */
+                { PIN_DU_DOTCLKIN2,   28, 2 },  /* DU_DOTCLKIN2 */
+                { PIN_DU_DOTCLKIN3,   24, 2 },  /* DU_DOTCLKIN3 */
+                { PIN_FSCLKST_N,      20, 2 },  /* FSCLKST# */
+                { PIN_TMS,             4, 2 },  /* TMS */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL13", 0xe6060334) {
-                { PIN_A_NUMBER('T', 28), 28, 2 },       /* TDO */
-                { PIN_A_NUMBER('T', 30), 24, 2 },       /* ASEBRK */
-                { RCAR_GP_PIN(3,  0),    20, 3 },       /* SD0_CLK */
-                { RCAR_GP_PIN(3,  1),    16, 3 },       /* SD0_CMD */
-                { RCAR_GP_PIN(3,  2),    12, 3 },       /* SD0_DAT0 */
-                { RCAR_GP_PIN(3,  3),     8, 3 },       /* SD0_DAT1 */
-                { RCAR_GP_PIN(3,  4),     4, 3 },       /* SD0_DAT2 */
-                { RCAR_GP_PIN(3,  5),     0, 3 },       /* SD0_DAT3 */
+                { PIN_TDO,            28, 2 },  /* TDO */
+                { PIN_ASEBRK,         24, 2 },  /* ASEBRK */
+                { RCAR_GP_PIN(3,  0), 20, 3 },  /* SD0_CLK */
+                { RCAR_GP_PIN(3,  1), 16, 3 },  /* SD0_CMD */
+                { RCAR_GP_PIN(3,  2), 12, 3 },  /* SD0_DAT0 */
+                { RCAR_GP_PIN(3,  3),  8, 3 },  /* SD0_DAT1 */
+                { RCAR_GP_PIN(3,  4),  4, 3 },  /* SD0_DAT2 */
+                { RCAR_GP_PIN(3,  5),  0, 3 },  /* SD0_DAT3 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL14", 0xe6060338) {
                 { RCAR_GP_PIN(3,  6), 28, 3 },  /* SD1_CLK */
@@ -5474,7 +5506,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(5, 23), 16, 3 },  /* MLB_CLK */
                 { RCAR_GP_PIN(5, 24), 12, 3 },  /* MLB_SIG */
                 { RCAR_GP_PIN(5, 25),  8, 3 },  /* MLB_DAT */
-                { PIN_NUMBER('H', 37),  4, 3 }, /* MLB_REF */
+                { PIN_MLB_REF,         4, 3 },  /* MLB_REF */
                 { RCAR_GP_PIN(6,  0),  0, 3 },  /* SSI_SCK01239 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL21", 0xe6060354) {
@@ -5548,35 +5580,35 @@ static int r8a7795es1_pin_to_pocctrl(struct sh_pfc *pfc, unsigned int pin,
 
 static const struct pinmux_bias_reg pinmux_bias_regs[] = {
         { PINMUX_BIAS_REG("PUEN0", 0xe6060400, "PUD0", 0xe6060440) {
-                [ 0] = PIN_NUMBER('W', 3),      /* QSPI0_SPCLK */
-                [ 1] = PIN_A_NUMBER('C', 5),    /* QSPI0_MOSI_IO0 */
-                [ 2] = PIN_A_NUMBER('B', 4),    /* QSPI0_MISO_IO1 */
-                [ 3] = PIN_NUMBER('Y', 6),      /* QSPI0_IO2 */
-                [ 4] = PIN_A_NUMBER('B', 6),    /* QSPI0_IO3 */
-                [ 5] = PIN_NUMBER('Y', 3),      /* QSPI0_SSL */
-                [ 6] = PIN_NUMBER('V', 3),      /* QSPI1_SPCLK */
-                [ 7] = PIN_A_NUMBER('C', 7),    /* QSPI1_MOSI_IO0 */
-                [ 8] = PIN_A_NUMBER('E', 5),    /* QSPI1_MISO_IO1 */
-                [ 9] = PIN_A_NUMBER('E', 4),    /* QSPI1_IO2 */
-                [10] = PIN_A_NUMBER('C', 3),    /* QSPI1_IO3 */
-                [11] = PIN_NUMBER('V', 5),      /* QSPI1_SSL */
-                [12] = PIN_NUMBER('Y', 7),      /* RPC_INT# */
-                [13] = PIN_NUMBER('V', 6),      /* RPC_WP# */
-                [14] = PIN_NUMBER('V', 7),      /* RPC_RESET# */
-                [15] = PIN_NUMBER('A', 16),     /* AVB_RX_CTL */
-                [16] = PIN_NUMBER('B', 19),     /* AVB_RXC */
-                [17] = PIN_NUMBER('A', 13),     /* AVB_RD0 */
-                [18] = PIN_NUMBER('B', 13),     /* AVB_RD1 */
-                [19] = PIN_NUMBER('A', 14),     /* AVB_RD2 */
-                [20] = PIN_NUMBER('B', 14),     /* AVB_RD3 */
-                [21] = PIN_NUMBER('A', 8),      /* AVB_TX_CTL */
-                [22] = PIN_NUMBER('A', 19),     /* AVB_TXC */
-                [23] = PIN_NUMBER('A', 18),     /* AVB_TD0 */
-                [24] = PIN_NUMBER('B', 18),     /* AVB_TD1 */
-                [25] = PIN_NUMBER('A', 17),     /* AVB_TD2 */
-                [26] = PIN_NUMBER('B', 17),     /* AVB_TD3 */
-                [27] = PIN_NUMBER('A', 12),     /* AVB_TXCREFCLK */
-                [28] = PIN_NUMBER('A', 9),      /* AVB_MDIO */
+                [ 0] = PIN_QSPI0_SPCLK,         /* QSPI0_SPCLK */
+                [ 1] = PIN_QSPI0_MOSI_IO0,      /* QSPI0_MOSI_IO0 */
+                [ 2] = PIN_QSPI0_MISO_IO1,      /* QSPI0_MISO_IO1 */
+                [ 3] = PIN_QSPI0_IO2,           /* QSPI0_IO2 */
+                [ 4] = PIN_QSPI0_IO3,           /* QSPI0_IO3 */
+                [ 5] = PIN_QSPI0_SSL,           /* QSPI0_SSL */
+                [ 6] = PIN_QSPI1_SPCLK,         /* QSPI1_SPCLK */
+                [ 7] = PIN_QSPI1_MOSI_IO0,      /* QSPI1_MOSI_IO0 */
+                [ 8] = PIN_QSPI1_MISO_IO1,      /* QSPI1_MISO_IO1 */
+                [ 9] = PIN_QSPI1_IO2,           /* QSPI1_IO2 */
+                [10] = PIN_QSPI1_IO3,           /* QSPI1_IO3 */
+                [11] = PIN_QSPI1_SSL,           /* QSPI1_SSL */
+                [12] = PIN_RPC_INT_N,           /* RPC_INT# */
+                [13] = PIN_RPC_WP_N,            /* RPC_WP# */
+                [14] = PIN_RPC_RESET_N,         /* RPC_RESET# */
+                [15] = PIN_AVB_RX_CTL,          /* AVB_RX_CTL */
+                [16] = PIN_AVB_RXC,             /* AVB_RXC */
+                [17] = PIN_AVB_RD0,             /* AVB_RD0 */
+                [18] = PIN_AVB_RD1,             /* AVB_RD1 */
+                [19] = PIN_AVB_RD2,             /* AVB_RD2 */
+                [20] = PIN_AVB_RD3,             /* AVB_RD3 */
+                [21] = PIN_AVB_TX_CTL,          /* AVB_TX_CTL */
+                [22] = PIN_AVB_TXC,             /* AVB_TXC */
+                [23] = PIN_AVB_TD0,             /* AVB_TD0 */
+                [24] = PIN_AVB_TD1,             /* AVB_TD1 */
+                [25] = PIN_AVB_TD2,             /* AVB_TD2 */
+                [26] = PIN_AVB_TD3,             /* AVB_TD3 */
+                [27] = PIN_AVB_TXCREFCLK,       /* AVB_TXCREFCLK */
+                [28] = PIN_AVB_MDIO,            /* AVB_MDIO */
                 [29] = RCAR_GP_PIN(2,  9),      /* AVB_MDC */
                 [30] = RCAR_GP_PIN(2, 10),      /* AVB_MAGIC */
                 [31] = RCAR_GP_PIN(2, 11),      /* AVB_PHY_INT */
@@ -5616,7 +5648,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [31] = RCAR_GP_PIN(1, 19),      /* A19 */
         } },
         { PINMUX_BIAS_REG("PUEN2", 0xe6060408, "PUD2", 0xe6060448) {
-                [ 0] = PIN_NUMBER('F', 1),      /* CLKOUT */
+                [ 0] = PIN_CLKOUT,              /* CLKOUT */
                 [ 1] = RCAR_GP_PIN(1, 20),      /* CS0_N */
                 [ 2] = RCAR_GP_PIN(1, 21),      /* CS1_N_A26 */
                 [ 3] = RCAR_GP_PIN(1, 22),      /* BS_N */
@@ -5625,7 +5657,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 6] = RCAR_GP_PIN(1, 25),      /* WE0_N */
                 [ 7] = RCAR_GP_PIN(1, 26),      /* WE1_N */
                 [ 8] = RCAR_GP_PIN(1, 27),      /* EX_WAIT0_A */
-                [ 9] = PIN_NUMBER('C', 1),      /* PRESETOUT# */
+                [ 9] = PIN_PRESETOUT_N,         /* PRESETOUT# */
                 [10] = RCAR_GP_PIN(0,  0),      /* D0 */
                 [11] = RCAR_GP_PIN(0,  1),      /* D1 */
                 [12] = RCAR_GP_PIN(0,  2),      /* D2 */
@@ -5646,20 +5678,20 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [27] = RCAR_GP_PIN(7,  1),      /* AVS2 */
                 [28] = RCAR_GP_PIN(7,  2),      /* GP7_02 */
                 [29] = RCAR_GP_PIN(7,  3),      /* GP7_03 */
-                [30] = PIN_A_NUMBER('P', 7),    /* DU_DOTCLKIN0 */
-                [31] = PIN_A_NUMBER('P', 8),    /* DU_DOTCLKIN1 */
+                [30] = PIN_DU_DOTCLKIN0,        /* DU_DOTCLKIN0 */
+                [31] = PIN_DU_DOTCLKIN1,        /* DU_DOTCLKIN1 */
         } },
         { PINMUX_BIAS_REG("PUEN3", 0xe606040c, "PUD3", 0xe606044c) {
-                [ 0] = PIN_A_NUMBER('R', 7),    /* DU_DOTCLKIN2 */
-                [ 1] = PIN_A_NUMBER('R', 8),    /* DU_DOTCLKIN3 */
-                [ 2] = PIN_A_NUMBER('D', 38),   /* FSCLKST# */
-                [ 3] = PIN_A_NUMBER('D', 39),   /* EXTALR*/
-                [ 4] = PIN_A_NUMBER('R', 26),   /* TRST# */
-                [ 5] = PIN_A_NUMBER('T', 27),   /* TCK */
-                [ 6] = PIN_A_NUMBER('R', 30),   /* TMS */
-                [ 7] = PIN_A_NUMBER('R', 29),   /* TDI */
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_A_NUMBER('T', 30),   /* ASEBRK */
+                [ 0] = PIN_DU_DOTCLKIN2,        /* DU_DOTCLKIN2 */
+                [ 1] = PIN_DU_DOTCLKIN3,        /* DU_DOTCLKIN3 */
+                [ 2] = PIN_FSCLKST_N,           /* FSCLKST# */
+                [ 3] = PIN_EXTALR,              /* EXTALR*/
+                [ 4] = PIN_TRST_N,              /* TRST# */
+                [ 5] = PIN_TCK,                 /* TCK */
+                [ 6] = PIN_TMS,                 /* TMS */
+                [ 7] = PIN_TDI,                 /* TDI */
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = PIN_ASEBRK,              /* ASEBRK */
                 [10] = RCAR_GP_PIN(3,  0),      /* SD0_CLK */
                 [11] = RCAR_GP_PIN(3,  1),      /* SD0_CMD */
                 [12] = RCAR_GP_PIN(3,  2),      /* SD0_DAT0 */
@@ -5724,7 +5756,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 3] = RCAR_GP_PIN(5, 23),      /* MLB_CLK */
                 [ 4] = RCAR_GP_PIN(5, 24),      /* MLB_SIG */
                 [ 5] = RCAR_GP_PIN(5, 25),      /* MLB_DAT */
-                [ 6] = PIN_NUMBER('H', 37),     /* MLB_REF */
+                [ 6] = PIN_MLB_REF,             /* MLB_REF */
                 [ 7] = RCAR_GP_PIN(6,  0),      /* SSI_SCK01239 */
                 [ 8] = RCAR_GP_PIN(6,  1),      /* SSI_WS01239 */
                 [ 9] = RCAR_GP_PIN(6,  2),      /* SSI_SDATA0 */
@@ -5759,31 +5791,31 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 4] = RCAR_GP_PIN(6, 29),      /* USB30_OVC */
                 [ 5] = RCAR_GP_PIN(6, 30),      /* USB31_PWEN */
                 [ 6] = RCAR_GP_PIN(6, 31),      /* USB31_OVC */
-                [ 7] = PIN_NONE,
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [ 7] = SH_PFC_PIN_NONE,
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { /* sentinel */ },
 };
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7795.c b/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
index 68bcb8980b16..7df010f757b1 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7795.c
@@ -12,11 +12,9 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | \
-                   SH_PFC_PIN_CFG_PULL_UP | \
-                   SH_PFC_PIN_CFG_PULL_DOWN)
+#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_CFG_16(0, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_29(1, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_15(2, fn, sfx, CFG_FLAGS),  \
@@ -29,6 +27,52 @@
         PORT_GP_CFG_26(5, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_32(6, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_4(7, fn, sfx, CFG_FLAGS)
+
+#define CPU_ALL_NOGP(fn)                                                \
+        PIN_NOGP_CFG(ASEBRK, "ASEBRK", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(AVB_MDIO, "AVB_MDIO", fn, CFG_FLAGS),              \
+        PIN_NOGP_CFG(AVB_RD0, "AVB_RD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD1, "AVB_RD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD2, "AVB_RD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD3, "AVB_RD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RXC, "AVB_RXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RX_CTL, "AVB_RX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(AVB_TD0, "AVB_TD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD1, "AVB_TD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD2, "AVB_TD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD3, "AVB_TD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXC, "AVB_TXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXCREFCLK, "AVB_TXCREFCLK", fn, CFG_FLAGS),    \
+        PIN_NOGP_CFG(AVB_TX_CTL, "AVB_TX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(DU_DOTCLKIN0, "DU_DOTCLKIN0", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN1, "DU_DOTCLKIN1", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN2, "DU_DOTCLKIN2", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN3, "DU_DOTCLKIN3", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(EXTALR, "EXTALR", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),\
+        PIN_NOGP_CFG(FSCLKST_N, "FSCLKST#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(MLB_REF, "MLB_REF", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(PRESETOUT_N, "PRESETOUT#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(QSPI0_IO2, "QSPI0_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_IO3, "QSPI0_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_MISO_IO1, "QSPI0_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_MOSI_IO0, "QSPI0_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_SPCLK, "QSPI0_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI0_SSL, "QSPI0_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO2, "QSPI1_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO3, "QSPI1_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_MISO_IO1, "QSPI1_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_MOSI_IO0, "QSPI1_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_SPCLK, "QSPI1_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI1_SSL, "QSPI1_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(RPC_INT_N, "RPC_INT#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(RPC_RESET_N, "RPC_RESET#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(RPC_WP_N, "RPC_WP#", fn, CFG_FLAGS),               \
+        PIN_NOGP_CFG(TCK, "TCK", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDI, "TDI", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDO, "TDO", fn, SH_PFC_PIN_CFG_DRIVE_STRENGTH),    \
+        PIN_NOGP_CFG(TMS, "TMS", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TRST_N, "TRST#", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN)
+
 /*
  * F_() : just information
  * FM() : macro for FN_xxx / xxx_MARK
@@ -1508,68 +1552,16 @@ static const u16 pinmux_data[] = {
 };
 
 /*
- * R8A7795 has 8 banks with 32 GPIOs in each => 256 GPIOs.
- * Physical layout rows: A - AW, cols: 1 - 39.
+ * Pins not associated with a GPIO port.
  */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 39 + (c) + 300)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
-#define PIN_NONE U16_MAX
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /*
-         * Pins not associated with a GPIO port.
-         *
-         * The pin positions are different between different r8a7795
-         * packages, all that is needed for the pfc driver is a unique
-         * number for each pin. To this end use the pin layout from
-         * R-Car H3SiP to calculate a unique number for each pin.
-         */
-        SH_PFC_PIN_NAMED_CFG('A',  8, AVB_TX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A',  9, AVB_MDIO, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 12, AVB_TXCREFCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 13, AVB_RD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 14, AVB_RD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 16, AVB_RX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 17, AVB_TD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 18, AVB_TD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 19, AVB_TXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 13, AVB_RD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 14, AVB_RD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 17, AVB_TD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 18, AVB_TD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 19, AVB_RXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('C',  1, PRESETOUT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('H', 37, MLB_REF, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  3, QSPI1_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  5, QSPI1_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  6, RPC_WP#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  7, RPC_RESET#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('W',  3, QSPI0_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  3, QSPI0_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  6, QSPI0_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  7, RPC_INT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  4, QSPI0_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  6, QSPI0_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  3, QSPI1_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  5, QSPI0_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  7, QSPI1_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 38, FSCLKST#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 39, EXTALR, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  4, QSPI1_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  5, QSPI1_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  7, DU_DOTCLKIN0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  8, DU_DOTCLKIN1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  7, DU_DOTCLKIN2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  8, DU_DOTCLKIN3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 26, TRST#, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 29, TDI, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 30, TMS, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 27, TCK, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 28, TDO, SH_PFC_PIN_CFG_DRIVE_STRENGTH),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 30, ASEBRK, CFG_FLAGS),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -1717,7 +1709,7 @@ static const unsigned int avb_phy_int_mux[] = {
 };
 static const unsigned int avb_mdio_pins[] = {
         /* AVB_MDC, AVB_MDIO */
-        RCAR_GP_PIN(2, 9), PIN_NUMBER('A', 9),
+        RCAR_GP_PIN(2, 9), PIN_AVB_MDIO,
 };
 static const unsigned int avb_mdio_mux[] = {
         AVB_MDC_MARK, AVB_MDIO_MARK,
@@ -1730,11 +1722,11 @@ static const unsigned int avb_mii_pins[] = {
          * AVB_RD1, AVB_RD2, AVB_RD3,
          * AVB_TXCREFCLK
          */
-        PIN_NUMBER('A', 8), PIN_NUMBER('A', 19), PIN_NUMBER('A', 18),
-        PIN_NUMBER('B', 18), PIN_NUMBER('A', 17), PIN_NUMBER('B', 17),
-        PIN_NUMBER('A', 16), PIN_NUMBER('B', 19), PIN_NUMBER('A', 13),
-        PIN_NUMBER('B', 13), PIN_NUMBER('A', 14), PIN_NUMBER('B', 14),
-        PIN_NUMBER('A', 12),
+        PIN_AVB_TX_CTL, PIN_AVB_TXC, PIN_AVB_TD0,
+        PIN_AVB_TD1, PIN_AVB_TD2, PIN_AVB_TD3,
+        PIN_AVB_RX_CTL, PIN_AVB_RXC, PIN_AVB_RD0,
+        PIN_AVB_RD1, PIN_AVB_RD2, PIN_AVB_RD3,
+        PIN_AVB_TXCREFCLK,
 
 };
 static const unsigned int avb_mii_mux[] = {
@@ -3901,6 +3893,36 @@ static const unsigned int tmu_tclk2_b_mux[] = {
         TCLK2_B_MARK,
 };
 
+/* - TPU ------------------------------------------------------------------- */
+static const unsigned int tpu_to0_pins[] = {
+        /* TPU0TO0 */
+        RCAR_GP_PIN(6, 28),
+};
+static const unsigned int tpu_to0_mux[] = {
+        TPU0TO0_MARK,
+};
+static const unsigned int tpu_to1_pins[] = {
+        /* TPU0TO1 */
+        RCAR_GP_PIN(6, 29),
+};
+static const unsigned int tpu_to1_mux[] = {
+        TPU0TO1_MARK,
+};
+static const unsigned int tpu_to2_pins[] = {
+        /* TPU0TO2 */
+        RCAR_GP_PIN(6, 30),
+};
+static const unsigned int tpu_to2_mux[] = {
+        TPU0TO2_MARK,
+};
+static const unsigned int tpu_to3_pins[] = {
+        /* TPU0TO3 */
+        RCAR_GP_PIN(6, 31),
+};
+static const unsigned int tpu_to3_mux[] = {
+        TPU0TO3_MARK,
+};
+
 /* - USB0 ------------------------------------------------------------------- */
 static const unsigned int usb0_pins[] = {
         /* PWEN, OVC */
@@ -4451,6 +4473,10 @@ static const struct sh_pfc_pin_group pinmux_groups[] = {
         SH_PFC_PIN_GROUP(tmu_tclk1_b),
         SH_PFC_PIN_GROUP(tmu_tclk2_a),
         SH_PFC_PIN_GROUP(tmu_tclk2_b),
+        SH_PFC_PIN_GROUP(tpu_to0),
+        SH_PFC_PIN_GROUP(tpu_to1),
+        SH_PFC_PIN_GROUP(tpu_to2),
+        SH_PFC_PIN_GROUP(tpu_to3),
         SH_PFC_PIN_GROUP(usb0),
         SH_PFC_PIN_GROUP(usb1),
         SH_PFC_PIN_GROUP(usb2),
@@ -4946,6 +4972,13 @@ static const char * const tmu_groups[] = {
         "tmu_tclk2_b",
 };
 
+static const char * const tpu_groups[] = {
+        "tpu_to0",
+        "tpu_to1",
+        "tpu_to2",
+        "tpu_to3",
+};
+
 static const char * const usb0_groups[] = {
         "usb0",
 };
@@ -5048,6 +5081,7 @@ static const struct sh_pfc_function pinmux_functions[] = {
         SH_PFC_FUNCTION(sdhi3),
         SH_PFC_FUNCTION(ssi),
         SH_PFC_FUNCTION(tmu),
+        SH_PFC_FUNCTION(tpu),
         SH_PFC_FUNCTION(usb0),
         SH_PFC_FUNCTION(usb1),
         SH_PFC_FUNCTION(usb2),
@@ -5623,44 +5657,44 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = {
 
 static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         { PINMUX_DRIVE_REG("DRVCTRL0", 0xe6060300) {
-                { PIN_NUMBER('W', 3),   28, 2 },        /* QSPI0_SPCLK */
-                { PIN_A_NUMBER('C', 5), 24, 2 },        /* QSPI0_MOSI_IO0 */
-                { PIN_A_NUMBER('B', 4), 20, 2 },        /* QSPI0_MISO_IO1 */
-                { PIN_NUMBER('Y', 6),   16, 2 },        /* QSPI0_IO2 */
-                { PIN_A_NUMBER('B', 6), 12, 2 },        /* QSPI0_IO3 */
-                { PIN_NUMBER('Y', 3),    8, 2 },        /* QSPI0_SSL */
-                { PIN_NUMBER('V', 3),    4, 2 },        /* QSPI1_SPCLK */
-                { PIN_A_NUMBER('C', 7),  0, 2 },        /* QSPI1_MOSI_IO0 */
+                { PIN_QSPI0_SPCLK,    28, 2 },  /* QSPI0_SPCLK */
+                { PIN_QSPI0_MOSI_IO0, 24, 2 },  /* QSPI0_MOSI_IO0 */
+                { PIN_QSPI0_MISO_IO1, 20, 2 },  /* QSPI0_MISO_IO1 */
+                { PIN_QSPI0_IO2,      16, 2 },  /* QSPI0_IO2 */
+                { PIN_QSPI0_IO3,      12, 2 },  /* QSPI0_IO3 */
+                { PIN_QSPI0_SSL,       8, 2 },  /* QSPI0_SSL */
+                { PIN_QSPI1_SPCLK,     4, 2 },  /* QSPI1_SPCLK */
+                { PIN_QSPI1_MOSI_IO0,  0, 2 },  /* QSPI1_MOSI_IO0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL1", 0xe6060304) {
-                { PIN_A_NUMBER('E', 5), 28, 2 },        /* QSPI1_MISO_IO1 */
-                { PIN_A_NUMBER('E', 4), 24, 2 },        /* QSPI1_IO2 */
-                { PIN_A_NUMBER('C', 3), 20, 2 },        /* QSPI1_IO3 */
-                { PIN_NUMBER('V', 5),   16, 2 },        /* QSPI1_SSL */
-                { PIN_NUMBER('Y', 7),   12, 2 },        /* RPC_INT# */
-                { PIN_NUMBER('V', 6),    8, 2 },        /* RPC_WP# */
-                { PIN_NUMBER('V', 7),    4, 2 },        /* RPC_RESET# */
-                { PIN_NUMBER('A', 16),   0, 3 },        /* AVB_RX_CTL */
+                { PIN_QSPI1_MISO_IO1, 28, 2 },  /* QSPI1_MISO_IO1 */
+                { PIN_QSPI1_IO2,      24, 2 },  /* QSPI1_IO2 */
+                { PIN_QSPI1_IO3,      20, 2 },  /* QSPI1_IO3 */
+                { PIN_QSPI1_SSL,      16, 2 },  /* QSPI1_SSL */
+                { PIN_RPC_INT_N,      12, 2 },  /* RPC_INT# */
+                { PIN_RPC_WP_N,        8, 2 },  /* RPC_WP# */
+                { PIN_RPC_RESET_N,     4, 2 },  /* RPC_RESET# */
+                { PIN_AVB_RX_CTL,      0, 3 },  /* AVB_RX_CTL */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL2", 0xe6060308) {
-                { PIN_NUMBER('B', 19),  28, 3 },        /* AVB_RXC */
-                { PIN_NUMBER('A', 13),  24, 3 },        /* AVB_RD0 */
-                { PIN_NUMBER('B', 13),  20, 3 },        /* AVB_RD1 */
-                { PIN_NUMBER('A', 14),  16, 3 },        /* AVB_RD2 */
-                { PIN_NUMBER('B', 14),  12, 3 },        /* AVB_RD3 */
-                { PIN_NUMBER('A', 8),    8, 3 },        /* AVB_TX_CTL */
-                { PIN_NUMBER('A', 19),   4, 3 },        /* AVB_TXC */
-                { PIN_NUMBER('A', 18),   0, 3 },        /* AVB_TD0 */
+                { PIN_AVB_RXC,        28, 3 },  /* AVB_RXC */
+                { PIN_AVB_RD0,        24, 3 },  /* AVB_RD0 */
+                { PIN_AVB_RD1,        20, 3 },  /* AVB_RD1 */
+                { PIN_AVB_RD2,        16, 3 },  /* AVB_RD2 */
+                { PIN_AVB_RD3,        12, 3 },  /* AVB_RD3 */
+                { PIN_AVB_TX_CTL,      8, 3 },  /* AVB_TX_CTL */
+                { PIN_AVB_TXC,         4, 3 },  /* AVB_TXC */
+                { PIN_AVB_TD0,         0, 3 },  /* AVB_TD0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL3", 0xe606030c) {
-                { PIN_NUMBER('B', 18),  28, 3 },        /* AVB_TD1 */
-                { PIN_NUMBER('A', 17),  24, 3 },        /* AVB_TD2 */
-                { PIN_NUMBER('B', 17),  20, 3 },        /* AVB_TD3 */
-                { PIN_NUMBER('A', 12),  16, 3 },        /* AVB_TXCREFCLK */
-                { PIN_NUMBER('A', 9),   12, 3 },        /* AVB_MDIO */
-                { RCAR_GP_PIN(2,  9),    8, 3 },        /* AVB_MDC */
-                { RCAR_GP_PIN(2, 10),    4, 3 },        /* AVB_MAGIC */
-                { RCAR_GP_PIN(2, 11),    0, 3 },        /* AVB_PHY_INT */
+                { PIN_AVB_TD1,        28, 3 },  /* AVB_TD1 */
+                { PIN_AVB_TD2,        24, 3 },  /* AVB_TD2 */
+                { PIN_AVB_TD3,        20, 3 },  /* AVB_TD3 */
+                { PIN_AVB_TXCREFCLK,  16, 3 },  /* AVB_TXCREFCLK */
+                { PIN_AVB_MDIO,       12, 3 },  /* AVB_MDIO */
+                { RCAR_GP_PIN(2,  9),  8, 3 },  /* AVB_MDC */
+                { RCAR_GP_PIN(2, 10),  4, 3 },  /* AVB_MAGIC */
+                { RCAR_GP_PIN(2, 11),  0, 3 },  /* AVB_PHY_INT */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL4", 0xe6060310) {
                 { RCAR_GP_PIN(2, 12), 28, 3 },  /* AVB_LINK */
@@ -5714,7 +5748,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         } },
         { PINMUX_DRIVE_REG("DRVCTRL9", 0xe6060324) {
                 { RCAR_GP_PIN(1, 27), 28, 3 },  /* EX_WAIT0 */
-                { PIN_NUMBER('C', 1), 24, 3 },  /* PRESETOUT# */
+                { PIN_PRESETOUT_N,    24, 3 },  /* PRESETOUT# */
                 { RCAR_GP_PIN(0,  0), 20, 3 },  /* D0 */
                 { RCAR_GP_PIN(0,  1), 16, 3 },  /* D1 */
                 { RCAR_GP_PIN(0,  2), 12, 3 },  /* D2 */
@@ -5733,30 +5767,30 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(0, 13),  0, 3 },  /* D13 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL11", 0xe606032c) {
-                { RCAR_GP_PIN(0, 14),   28, 3 },        /* D14 */
-                { RCAR_GP_PIN(0, 15),   24, 3 },        /* D15 */
-                { RCAR_GP_PIN(7,  0),   20, 3 },        /* AVS1 */
-                { RCAR_GP_PIN(7,  1),   16, 3 },        /* AVS2 */
-                { RCAR_GP_PIN(7,  2),   12, 3 },        /* GP7_02 */
-                { RCAR_GP_PIN(7,  3),    8, 3 },        /* GP7_03 */
-                { PIN_A_NUMBER('P', 7),  4, 2 },        /* DU_DOTCLKIN0 */
-                { PIN_A_NUMBER('P', 8),  0, 2 },        /* DU_DOTCLKIN1 */
+                { RCAR_GP_PIN(0, 14), 28, 3 },  /* D14 */
+                { RCAR_GP_PIN(0, 15), 24, 3 },  /* D15 */
+                { RCAR_GP_PIN(7,  0), 20, 3 },  /* AVS1 */
+                { RCAR_GP_PIN(7,  1), 16, 3 },  /* AVS2 */
+                { RCAR_GP_PIN(7,  2), 12, 3 },  /* GP7_02 */
+                { RCAR_GP_PIN(7,  3),  8, 3 },  /* GP7_03 */
+                { PIN_DU_DOTCLKIN0,    4, 2 },  /* DU_DOTCLKIN0 */
+                { PIN_DU_DOTCLKIN1,    0, 2 },  /* DU_DOTCLKIN1 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL12", 0xe6060330) {
-                { PIN_A_NUMBER('R', 7),  28, 2 },       /* DU_DOTCLKIN2 */
-                { PIN_A_NUMBER('R', 8),  24, 2 },       /* DU_DOTCLKIN3 */
-                { PIN_A_NUMBER('D', 38), 20, 2 },       /* FSCLKST# */
-                { PIN_A_NUMBER('R', 30),  4, 2 },       /* TMS */
+                { PIN_DU_DOTCLKIN2,   28, 2 },  /* DU_DOTCLKIN2 */
+                { PIN_DU_DOTCLKIN3,   24, 2 },  /* DU_DOTCLKIN3 */
+                { PIN_FSCLKST_N,      20, 2 },  /* FSCLKST# */
+                { PIN_TMS,             4, 2 },  /* TMS */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL13", 0xe6060334) {
-                { PIN_A_NUMBER('T', 28), 28, 2 },       /* TDO */
-                { PIN_A_NUMBER('T', 30), 24, 2 },       /* ASEBRK */
-                { RCAR_GP_PIN(3,  0),    20, 3 },       /* SD0_CLK */
-                { RCAR_GP_PIN(3,  1),    16, 3 },       /* SD0_CMD */
-                { RCAR_GP_PIN(3,  2),    12, 3 },       /* SD0_DAT0 */
-                { RCAR_GP_PIN(3,  3),     8, 3 },       /* SD0_DAT1 */
-                { RCAR_GP_PIN(3,  4),     4, 3 },       /* SD0_DAT2 */
-                { RCAR_GP_PIN(3,  5),     0, 3 },       /* SD0_DAT3 */
+                { PIN_TDO,            28, 2 },  /* TDO */
+                { PIN_ASEBRK,         24, 2 },  /* ASEBRK */
+                { RCAR_GP_PIN(3,  0), 20, 3 },  /* SD0_CLK */
+                { RCAR_GP_PIN(3,  1), 16, 3 },  /* SD0_CMD */
+                { RCAR_GP_PIN(3,  2), 12, 3 },  /* SD0_DAT0 */
+                { RCAR_GP_PIN(3,  3),  8, 3 },  /* SD0_DAT1 */
+                { RCAR_GP_PIN(3,  4),  4, 3 },  /* SD0_DAT2 */
+                { RCAR_GP_PIN(3,  5),  0, 3 },  /* SD0_DAT3 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL14", 0xe6060338) {
                 { RCAR_GP_PIN(3,  6), 28, 3 },  /* SD1_CLK */
@@ -5825,7 +5859,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(5, 23), 16, 3 },  /* MLB_CLK */
                 { RCAR_GP_PIN(5, 24), 12, 3 },  /* MLB_SIG */
                 { RCAR_GP_PIN(5, 25),  8, 3 },  /* MLB_DAT */
-                { PIN_NUMBER('H', 37),  4, 3 }, /* MLB_REF */
+                { PIN_MLB_REF,         4, 3 },  /* MLB_REF */
                 { RCAR_GP_PIN(6,  0),  0, 3 },  /* SSI_SCK01239 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL21", 0xe6060354) {
@@ -5898,35 +5932,35 @@ static int r8a7795_pin_to_pocctrl(struct sh_pfc *pfc, unsigned int pin, u32 *poc
 
 static const struct pinmux_bias_reg pinmux_bias_regs[] = {
         { PINMUX_BIAS_REG("PUEN0", 0xe6060400, "PUD0", 0xe6060440) {
-                [ 0] = PIN_NUMBER('W', 3),      /* QSPI0_SPCLK */
-                [ 1] = PIN_A_NUMBER('C', 5),    /* QSPI0_MOSI_IO0 */
-                [ 2] = PIN_A_NUMBER('B', 4),    /* QSPI0_MISO_IO1 */
-                [ 3] = PIN_NUMBER('Y', 6),      /* QSPI0_IO2 */
-                [ 4] = PIN_A_NUMBER('B', 6),    /* QSPI0_IO3 */
-                [ 5] = PIN_NUMBER('Y', 3),      /* QSPI0_SSL */
-                [ 6] = PIN_NUMBER('V', 3),      /* QSPI1_SPCLK */
-                [ 7] = PIN_A_NUMBER('C', 7),    /* QSPI1_MOSI_IO0 */
-                [ 8] = PIN_A_NUMBER('E', 5),    /* QSPI1_MISO_IO1 */
-                [ 9] = PIN_A_NUMBER('E', 4),    /* QSPI1_IO2 */
-                [10] = PIN_A_NUMBER('C', 3),    /* QSPI1_IO3 */
-                [11] = PIN_NUMBER('V', 5),      /* QSPI1_SSL */
-                [12] = PIN_NUMBER('Y', 7),      /* RPC_INT# */
-                [13] = PIN_NUMBER('V', 6),      /* RPC_WP# */
-                [14] = PIN_NUMBER('V', 7),      /* RPC_RESET# */
-                [15] = PIN_NUMBER('A', 16),     /* AVB_RX_CTL */
-                [16] = PIN_NUMBER('B', 19),     /* AVB_RXC */
-                [17] = PIN_NUMBER('A', 13),     /* AVB_RD0 */
-                [18] = PIN_NUMBER('B', 13),     /* AVB_RD1 */
-                [19] = PIN_NUMBER('A', 14),     /* AVB_RD2 */
-                [20] = PIN_NUMBER('B', 14),     /* AVB_RD3 */
-                [21] = PIN_NUMBER('A', 8),      /* AVB_TX_CTL */
-                [22] = PIN_NUMBER('A', 19),     /* AVB_TXC */
-                [23] = PIN_NUMBER('A', 18),     /* AVB_TD0 */
-                [24] = PIN_NUMBER('B', 18),     /* AVB_TD1 */
-                [25] = PIN_NUMBER('A', 17),     /* AVB_TD2 */
-                [26] = PIN_NUMBER('B', 17),     /* AVB_TD3 */
-                [27] = PIN_NUMBER('A', 12),     /* AVB_TXCREFCLK */
-                [28] = PIN_NUMBER('A', 9),      /* AVB_MDIO */
+                [ 0] = PIN_QSPI0_SPCLK,         /* QSPI0_SPCLK */
+                [ 1] = PIN_QSPI0_MOSI_IO0,      /* QSPI0_MOSI_IO0 */
+                [ 2] = PIN_QSPI0_MISO_IO1,      /* QSPI0_MISO_IO1 */
+                [ 3] = PIN_QSPI0_IO2,           /* QSPI0_IO2 */
+                [ 4] = PIN_QSPI0_IO3,           /* QSPI0_IO3 */
+                [ 5] = PIN_QSPI0_SSL,           /* QSPI0_SSL */
+                [ 6] = PIN_QSPI1_SPCLK,         /* QSPI1_SPCLK */
+                [ 7] = PIN_QSPI1_MOSI_IO0,      /* QSPI1_MOSI_IO0 */
+                [ 8] = PIN_QSPI1_MISO_IO1,      /* QSPI1_MISO_IO1 */
+                [ 9] = PIN_QSPI1_IO2,           /* QSPI1_IO2 */
+                [10] = PIN_QSPI1_IO3,           /* QSPI1_IO3 */
+                [11] = PIN_QSPI1_SSL,           /* QSPI1_SSL */
+                [12] = PIN_RPC_INT_N,           /* RPC_INT# */
+                [13] = PIN_RPC_WP_N,            /* RPC_WP# */
+                [14] = PIN_RPC_RESET_N,         /* RPC_RESET# */
+                [15] = PIN_AVB_RX_CTL,          /* AVB_RX_CTL */
+                [16] = PIN_AVB_RXC,             /* AVB_RXC */
+                [17] = PIN_AVB_RD0,             /* AVB_RD0 */
+                [18] = PIN_AVB_RD1,             /* AVB_RD1 */
+                [19] = PIN_AVB_RD2,             /* AVB_RD2 */
+                [20] = PIN_AVB_RD3,             /* AVB_RD3 */
+                [21] = PIN_AVB_TX_CTL,          /* AVB_TX_CTL */
+                [22] = PIN_AVB_TXC,             /* AVB_TXC */
+                [23] = PIN_AVB_TD0,             /* AVB_TD0 */
+                [24] = PIN_AVB_TD1,             /* AVB_TD1 */
+                [25] = PIN_AVB_TD2,             /* AVB_TD2 */
+                [26] = PIN_AVB_TD3,             /* AVB_TD3 */
+                [27] = PIN_AVB_TXCREFCLK,       /* AVB_TXCREFCLK */
+                [28] = PIN_AVB_MDIO,            /* AVB_MDIO */
                 [29] = RCAR_GP_PIN(2,  9),      /* AVB_MDC */
                 [30] = RCAR_GP_PIN(2, 10),      /* AVB_MAGIC */
                 [31] = RCAR_GP_PIN(2, 11),      /* AVB_PHY_INT */
@@ -5975,7 +6009,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 6] = RCAR_GP_PIN(1, 25),      /* WE0_N */
                 [ 7] = RCAR_GP_PIN(1, 26),      /* WE1_N */
                 [ 8] = RCAR_GP_PIN(1, 27),      /* EX_WAIT0_A */
-                [ 9] = PIN_NUMBER('C', 1),      /* PRESETOUT# */
+                [ 9] = PIN_PRESETOUT_N,         /* PRESETOUT# */
                 [10] = RCAR_GP_PIN(0,  0),      /* D0 */
                 [11] = RCAR_GP_PIN(0,  1),      /* D1 */
                 [12] = RCAR_GP_PIN(0,  2),      /* D2 */
@@ -5996,20 +6030,20 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [27] = RCAR_GP_PIN(7,  1),      /* AVS2 */
                 [28] = RCAR_GP_PIN(7,  2),      /* GP7_02 */
                 [29] = RCAR_GP_PIN(7,  3),      /* GP7_03 */
-                [30] = PIN_A_NUMBER('P', 7),    /* DU_DOTCLKIN0 */
-                [31] = PIN_A_NUMBER('P', 8),    /* DU_DOTCLKIN1 */
+                [30] = PIN_DU_DOTCLKIN0,        /* DU_DOTCLKIN0 */
+                [31] = PIN_DU_DOTCLKIN1,        /* DU_DOTCLKIN1 */
         } },
         { PINMUX_BIAS_REG("PUEN3", 0xe606040c, "PUD3", 0xe606044c) {
-                [ 0] = PIN_A_NUMBER('R', 7),    /* DU_DOTCLKIN2 */
-                [ 1] = PIN_A_NUMBER('R', 8),    /* DU_DOTCLKIN3 */
-                [ 2] = PIN_A_NUMBER('D', 38),   /* FSCLKST# */
-                [ 3] = PIN_A_NUMBER('D', 39),   /* EXTALR*/
-                [ 4] = PIN_A_NUMBER('R', 26),   /* TRST# */
-                [ 5] = PIN_A_NUMBER('T', 27),   /* TCK */
-                [ 6] = PIN_A_NUMBER('R', 30),   /* TMS */
-                [ 7] = PIN_A_NUMBER('R', 29),   /* TDI */
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_A_NUMBER('T', 30),   /* ASEBRK */
+                [ 0] = PIN_DU_DOTCLKIN2,        /* DU_DOTCLKIN2 */
+                [ 1] = PIN_DU_DOTCLKIN3,        /* DU_DOTCLKIN3 */
+                [ 2] = PIN_FSCLKST_N,           /* FSCLKST# */
+                [ 3] = PIN_EXTALR,              /* EXTALR*/
+                [ 4] = PIN_TRST_N,              /* TRST# */
+                [ 5] = PIN_TCK,                 /* TCK */
+                [ 6] = PIN_TMS,                 /* TMS */
+                [ 7] = PIN_TDI,                 /* TDI */
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = PIN_ASEBRK,              /* ASEBRK */
                 [10] = RCAR_GP_PIN(3,  0),      /* SD0_CLK */
                 [11] = RCAR_GP_PIN(3,  1),      /* SD0_CMD */
                 [12] = RCAR_GP_PIN(3,  2),      /* SD0_DAT0 */
@@ -6074,7 +6108,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 3] = RCAR_GP_PIN(5, 23),      /* MLB_CLK */
                 [ 4] = RCAR_GP_PIN(5, 24),      /* MLB_SIG */
                 [ 5] = RCAR_GP_PIN(5, 25),      /* MLB_DAT */
-                [ 6] = PIN_NUMBER('H', 37),     /* MLB_REF */
+                [ 6] = PIN_MLB_REF,             /* MLB_REF */
                 [ 7] = RCAR_GP_PIN(6,  0),      /* SSI_SCK01239 */
                 [ 8] = RCAR_GP_PIN(6,  1),      /* SSI_WS01239 */
                 [ 9] = RCAR_GP_PIN(6,  2),      /* SSI_SDATA0 */
@@ -6109,31 +6143,31 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 4] = RCAR_GP_PIN(6, 29),      /* USB30_OVC */
                 [ 5] = RCAR_GP_PIN(6, 30),      /* USB2_CH3_PWEN */
                 [ 6] = RCAR_GP_PIN(6, 31),      /* USB2_CH3_OVC */
-                [ 7] = PIN_NONE,
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [ 7] = SH_PFC_PIN_NONE,
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { /* sentinel */ },
 };
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a7796.c b/drivers/pinctrl/sh-pfc/pfc-r8a7796.c
index 38cce690db70..61db7c7a35ec 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a7796.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a7796.c
@@ -17,11 +17,9 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | \
-                   SH_PFC_PIN_CFG_PULL_UP | \
-                   SH_PFC_PIN_CFG_PULL_DOWN)
+#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_CFG_16(0, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_29(1, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_15(2, fn, sfx, CFG_FLAGS),  \
@@ -34,6 +32,51 @@
         PORT_GP_CFG_26(5, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_32(6, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_4(7, fn, sfx, CFG_FLAGS)
+
+#define CPU_ALL_NOGP(fn)                                                \
+        PIN_NOGP_CFG(ASEBRK, "ASEBRK", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(AVB_MDIO, "AVB_MDIO", fn, CFG_FLAGS),              \
+        PIN_NOGP_CFG(AVB_RD0, "AVB_RD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD1, "AVB_RD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD2, "AVB_RD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD3, "AVB_RD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RXC, "AVB_RXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RX_CTL, "AVB_RX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(AVB_TD0, "AVB_TD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD1, "AVB_TD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD2, "AVB_TD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD3, "AVB_TD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXC, "AVB_TXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXCREFCLK, "AVB_TXCREFCLK", fn, CFG_FLAGS),    \
+        PIN_NOGP_CFG(AVB_TX_CTL, "AVB_TX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(DU_DOTCLKIN0, "DU_DOTCLKIN0", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN1, "DU_DOTCLKIN1", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN2, "DU_DOTCLKIN2", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(EXTALR, "EXTALR", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),\
+        PIN_NOGP_CFG(FSCLKST, "FSCLKST", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(MLB_REF, "MLB_REF", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(PRESETOUT_N, "PRESETOUT#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(QSPI0_IO2, "QSPI0_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_IO3, "QSPI0_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_MISO_IO1, "QSPI0_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_MOSI_IO0, "QSPI0_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_SPCLK, "QSPI0_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI0_SSL, "QSPI0_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO2, "QSPI1_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO3, "QSPI1_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_MISO_IO1, "QSPI1_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_MOSI_IO0, "QSPI1_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_SPCLK, "QSPI1_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI1_SSL, "QSPI1_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(RPC_INT_N, "RPC_INT#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(RPC_RESET_N, "RPC_RESET#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(RPC_WP_N, "RPC_WP#", fn, CFG_FLAGS),               \
+        PIN_NOGP_CFG(TCK, "TCK", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDI, "TDI", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDO, "TDO", fn, SH_PFC_PIN_CFG_DRIVE_STRENGTH),    \
+        PIN_NOGP_CFG(TMS, "TMS", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TRST_N, "TRST#", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN)
+
 /*
  * F_() : just information
  * FM() : macro for FN_xxx / xxx_MARK
@@ -1512,67 +1555,16 @@ static const u16 pinmux_data[] = {
 };
 
 /*
- * R8A7796 has 8 banks with 32 GPIOs in each => 256 GPIOs.
- * Physical layout rows: A - AW, cols: 1 - 39.
+ * Pins not associated with a GPIO port.
  */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 39 + (c) + 300)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
-#define PIN_NONE U16_MAX
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /*
-         * Pins not associated with a GPIO port.
-         *
-         * The pin positions are different between different r8a7796
-         * packages, all that is needed for the pfc driver is a unique
-         * number for each pin. To this end use the pin layout from
-         * R-Car M3SiP to calculate a unique number for each pin.
-         */
-        SH_PFC_PIN_NAMED_CFG('A',  8, AVB_TX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A',  9, AVB_MDIO, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 12, AVB_TXCREFCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 13, AVB_RD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 14, AVB_RD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 16, AVB_RX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 17, AVB_TD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 18, AVB_TD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 19, AVB_TXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 13, AVB_RD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 14, AVB_RD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 17, AVB_TD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 18, AVB_TD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 19, AVB_RXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('C',  1, PRESETOUT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('H', 37, MLB_REF, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  3, QSPI1_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  5, QSPI1_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  6, RPC_WP#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  7, RPC_RESET#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('W',  3, QSPI0_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  3, QSPI0_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  6, QSPI0_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  7, RPC_INT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  4, QSPI0_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  6, QSPI0_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  3, QSPI1_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  5, QSPI0_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  7, QSPI1_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 38, FSCLKST, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 39, EXTALR, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  4, QSPI1_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  5, QSPI1_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  7, DU_DOTCLKIN0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  8, DU_DOTCLKIN1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  8, DU_DOTCLKIN2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 26, TRST#, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 29, TDI, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 30, TMS, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 27, TCK, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 28, TDO, SH_PFC_PIN_CFG_DRIVE_STRENGTH),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 30, ASEBRK, CFG_FLAGS),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -1721,7 +1713,7 @@ static const unsigned int avb_phy_int_mux[] = {
 };
 static const unsigned int avb_mdio_pins[] = {
         /* AVB_MDC, AVB_MDIO */
-        RCAR_GP_PIN(2, 9), PIN_NUMBER('A', 9),
+        RCAR_GP_PIN(2, 9), PIN_AVB_MDIO,
 };
 static const unsigned int avb_mdio_mux[] = {
         AVB_MDC_MARK, AVB_MDIO_MARK,
@@ -1734,11 +1726,11 @@ static const unsigned int avb_mii_pins[] = {
          * AVB_RD1, AVB_RD2, AVB_RD3,
          * AVB_TXCREFCLK
          */
-        PIN_NUMBER('A', 8), PIN_NUMBER('A', 19), PIN_NUMBER('A', 18),
-        PIN_NUMBER('B', 18), PIN_NUMBER('A', 17), PIN_NUMBER('B', 17),
-        PIN_NUMBER('A', 16), PIN_NUMBER('B', 19), PIN_NUMBER('A', 13),
-        PIN_NUMBER('B', 13), PIN_NUMBER('A', 14), PIN_NUMBER('B', 14),
-        PIN_NUMBER('A', 12),
+        PIN_AVB_TX_CTL, PIN_AVB_TXC, PIN_AVB_TD0,
+        PIN_AVB_TD1, PIN_AVB_TD2, PIN_AVB_TD3,
+        PIN_AVB_RX_CTL, PIN_AVB_RXC, PIN_AVB_RD0,
+        PIN_AVB_RD1, PIN_AVB_RD2, PIN_AVB_RD3,
+        PIN_AVB_TXCREFCLK,
 
 };
 static const unsigned int avb_mii_mux[] = {
@@ -3891,6 +3883,36 @@ static const unsigned int tmu_tclk2_b_mux[] = {
         TCLK2_B_MARK,
 };
 
+/* - TPU ------------------------------------------------------------------- */
+static const unsigned int tpu_to0_pins[] = {
+        /* TPU0TO0 */
+        RCAR_GP_PIN(6, 28),
+};
+static const unsigned int tpu_to0_mux[] = {
+        TPU0TO0_MARK,
+};
+static const unsigned int tpu_to1_pins[] = {
+        /* TPU0TO1 */
+        RCAR_GP_PIN(6, 29),
+};
+static const unsigned int tpu_to1_mux[] = {
+        TPU0TO1_MARK,
+};
+static const unsigned int tpu_to2_pins[] = {
+        /* TPU0TO2 */
+        RCAR_GP_PIN(6, 30),
+};
+static const unsigned int tpu_to2_mux[] = {
+        TPU0TO2_MARK,
+};
+static const unsigned int tpu_to3_pins[] = {
+        /* TPU0TO3 */
+        RCAR_GP_PIN(6, 31),
+};
+static const unsigned int tpu_to3_mux[] = {
+        TPU0TO3_MARK,
+};
+
 /* - USB0 ------------------------------------------------------------------- */
 static const unsigned int usb0_pins[] = {
         /* PWEN, OVC */
@@ -4110,7 +4132,7 @@ static const unsigned int vin5_clk_mux[] = {
 };
 
 static const struct {
-        struct sh_pfc_pin_group common[312];
+        struct sh_pfc_pin_group common[316];
         struct sh_pfc_pin_group automotive[30];
 } pinmux_groups = {
         .common = {
@@ -4397,6 +4419,10 @@ static const struct {
                 SH_PFC_PIN_GROUP(tmu_tclk1_b),
                 SH_PFC_PIN_GROUP(tmu_tclk2_a),
                 SH_PFC_PIN_GROUP(tmu_tclk2_b),
+                SH_PFC_PIN_GROUP(tpu_to0),
+                SH_PFC_PIN_GROUP(tpu_to1),
+                SH_PFC_PIN_GROUP(tpu_to2),
+                SH_PFC_PIN_GROUP(tpu_to3),
                 SH_PFC_PIN_GROUP(usb0),
                 SH_PFC_PIN_GROUP(usb1),
                 SH_PFC_PIN_GROUP(usb30),
@@ -4918,6 +4944,13 @@ static const char * const tmu_groups[] = {
         "tmu_tclk2_b",
 };
 
+static const char * const tpu_groups[] = {
+        "tpu_to0",
+        "tpu_to1",
+        "tpu_to2",
+        "tpu_to3",
+};
+
 static const char * const usb0_groups[] = {
         "usb0",
 };
@@ -4963,7 +4996,7 @@ static const char * const vin5_groups[] = {
 };
 
 static const struct {
-        struct sh_pfc_function common[49];
+        struct sh_pfc_function common[50];
         struct sh_pfc_function automotive[4];
 } pinmux_functions = {
         .common = {
@@ -5011,6 +5044,7 @@ static const struct {
                 SH_PFC_FUNCTION(sdhi3),
                 SH_PFC_FUNCTION(ssi),
                 SH_PFC_FUNCTION(tmu),
+                SH_PFC_FUNCTION(tpu),
                 SH_PFC_FUNCTION(usb0),
                 SH_PFC_FUNCTION(usb1),
                 SH_PFC_FUNCTION(usb30),
@@ -5590,44 +5624,44 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = {
 
 static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         { PINMUX_DRIVE_REG("DRVCTRL0", 0xe6060300) {
-                { PIN_NUMBER('W', 3),   28, 2 },        /* QSPI0_SPCLK */
-                { PIN_A_NUMBER('C', 5), 24, 2 },        /* QSPI0_MOSI_IO0 */
-                { PIN_A_NUMBER('B', 4), 20, 2 },        /* QSPI0_MISO_IO1 */
-                { PIN_NUMBER('Y', 6),   16, 2 },        /* QSPI0_IO2 */
-                { PIN_A_NUMBER('B', 6), 12, 2 },        /* QSPI0_IO3 */
-                { PIN_NUMBER('Y', 3),    8, 2 },        /* QSPI0_SSL */
-                { PIN_NUMBER('V', 3),    4, 2 },        /* QSPI1_SPCLK */
-                { PIN_A_NUMBER('C', 7),  0, 2 },        /* QSPI1_MOSI_IO0 */
+                { PIN_QSPI0_SPCLK,    28, 2 },  /* QSPI0_SPCLK */
+                { PIN_QSPI0_MOSI_IO0, 24, 2 },  /* QSPI0_MOSI_IO0 */
+                { PIN_QSPI0_MISO_IO1, 20, 2 },  /* QSPI0_MISO_IO1 */
+                { PIN_QSPI0_IO2,      16, 2 },  /* QSPI0_IO2 */
+                { PIN_QSPI0_IO3,      12, 2 },  /* QSPI0_IO3 */
+                { PIN_QSPI0_SSL,       8, 2 },  /* QSPI0_SSL */
+                { PIN_QSPI1_SPCLK,     4, 2 },  /* QSPI1_SPCLK */
+                { PIN_QSPI1_MOSI_IO0,  0, 2 },  /* QSPI1_MOSI_IO0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL1", 0xe6060304) {
-                { PIN_A_NUMBER('E', 5), 28, 2 },        /* QSPI1_MISO_IO1 */
-                { PIN_A_NUMBER('E', 4), 24, 2 },        /* QSPI1_IO2 */
-                { PIN_A_NUMBER('C', 3), 20, 2 },        /* QSPI1_IO3 */
-                { PIN_NUMBER('V', 5),   16, 2 },        /* QSPI1_SSL */
-                { PIN_NUMBER('Y', 7),   12, 2 },        /* RPC_INT# */
-                { PIN_NUMBER('V', 6),    8, 2 },        /* RPC_WP# */
-                { PIN_NUMBER('V', 7),    4, 2 },        /* RPC_RESET# */
-                { PIN_NUMBER('A', 16),   0, 3 },        /* AVB_RX_CTL */
+                { PIN_QSPI1_MISO_IO1, 28, 2 },  /* QSPI1_MISO_IO1 */
+                { PIN_QSPI1_IO2,      24, 2 },  /* QSPI1_IO2 */
+                { PIN_QSPI1_IO3,      20, 2 },  /* QSPI1_IO3 */
+                { PIN_QSPI1_SSL,      16, 2 },  /* QSPI1_SSL */
+                { PIN_RPC_INT_N,      12, 2 },  /* RPC_INT# */
+                { PIN_RPC_WP_N,        8, 2 },  /* RPC_WP# */
+                { PIN_RPC_RESET_N,     4, 2 },  /* RPC_RESET# */
+                { PIN_AVB_RX_CTL,      0, 3 },  /* AVB_RX_CTL */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL2", 0xe6060308) {
-                { PIN_NUMBER('B', 19),  28, 3 },        /* AVB_RXC */
-                { PIN_NUMBER('A', 13),  24, 3 },        /* AVB_RD0 */
-                { PIN_NUMBER('B', 13),  20, 3 },        /* AVB_RD1 */
-                { PIN_NUMBER('A', 14),  16, 3 },        /* AVB_RD2 */
-                { PIN_NUMBER('B', 14),  12, 3 },        /* AVB_RD3 */
-                { PIN_NUMBER('A', 8),    8, 3 },        /* AVB_TX_CTL */
-                { PIN_NUMBER('A', 19),   4, 3 },        /* AVB_TXC */
-                { PIN_NUMBER('A', 18),   0, 3 },        /* AVB_TD0 */
+                { PIN_AVB_RXC,        28, 3 },  /* AVB_RXC */
+                { PIN_AVB_RD0,        24, 3 },  /* AVB_RD0 */
+                { PIN_AVB_RD1,        20, 3 },  /* AVB_RD1 */
+                { PIN_AVB_RD2,        16, 3 },  /* AVB_RD2 */
+                { PIN_AVB_RD3,        12, 3 },  /* AVB_RD3 */
+                { PIN_AVB_TX_CTL,      8, 3 },  /* AVB_TX_CTL */
+                { PIN_AVB_TXC,         4, 3 },  /* AVB_TXC */
+                { PIN_AVB_TD0,         0, 3 },  /* AVB_TD0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL3", 0xe606030c) {
-                { PIN_NUMBER('B', 18),  28, 3 },        /* AVB_TD1 */
-                { PIN_NUMBER('A', 17),  24, 3 },        /* AVB_TD2 */
-                { PIN_NUMBER('B', 17),  20, 3 },        /* AVB_TD3 */
-                { PIN_NUMBER('A', 12),  16, 3 },        /* AVB_TXCREFCLK */
-                { PIN_NUMBER('A', 9),   12, 3 },        /* AVB_MDIO */
-                { RCAR_GP_PIN(2,  9),    8, 3 },        /* AVB_MDC */
-                { RCAR_GP_PIN(2, 10),    4, 3 },        /* AVB_MAGIC */
-                { RCAR_GP_PIN(2, 11),    0, 3 },        /* AVB_PHY_INT */
+                { PIN_AVB_TD1,        28, 3 },  /* AVB_TD1 */
+                { PIN_AVB_TD2,        24, 3 },  /* AVB_TD2 */
+                { PIN_AVB_TD3,        20, 3 },  /* AVB_TD3 */
+                { PIN_AVB_TXCREFCLK,  16, 3 },  /* AVB_TXCREFCLK */
+                { PIN_AVB_MDIO,       12, 3 },  /* AVB_MDIO */
+                { RCAR_GP_PIN(2,  9),  8, 3 },  /* AVB_MDC */
+                { RCAR_GP_PIN(2, 10),  4, 3 },  /* AVB_MAGIC */
+                { RCAR_GP_PIN(2, 11),  0, 3 },  /* AVB_PHY_INT */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL4", 0xe6060310) {
                 { RCAR_GP_PIN(2, 12), 28, 3 },  /* AVB_LINK */
@@ -5681,7 +5715,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         } },
         { PINMUX_DRIVE_REG("DRVCTRL9", 0xe6060324) {
                 { RCAR_GP_PIN(1, 27), 28, 3 },  /* EX_WAIT0 */
-                { PIN_NUMBER('C', 1), 24, 3 },  /* PRESETOUT# */
+                { PIN_PRESETOUT_N,    24, 3 },  /* PRESETOUT# */
                 { RCAR_GP_PIN(0,  0), 20, 3 },  /* D0 */
                 { RCAR_GP_PIN(0,  1), 16, 3 },  /* D1 */
                 { RCAR_GP_PIN(0,  2), 12, 3 },  /* D2 */
@@ -5700,29 +5734,29 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(0, 13),  0, 3 },  /* D13 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL11", 0xe606032c) {
-                { RCAR_GP_PIN(0, 14),   28, 3 },        /* D14 */
-                { RCAR_GP_PIN(0, 15),   24, 3 },        /* D15 */
-                { RCAR_GP_PIN(7,  0),   20, 3 },        /* AVS1 */
-                { RCAR_GP_PIN(7,  1),   16, 3 },        /* AVS2 */
-                { RCAR_GP_PIN(7,  2),   12, 3 },        /* GP7_02 */
-                { RCAR_GP_PIN(7,  3),    8, 3 },        /* GP7_03 */
-                { PIN_A_NUMBER('P', 7),  4, 2 },        /* DU_DOTCLKIN0 */
-                { PIN_A_NUMBER('P', 8),  0, 2 },        /* DU_DOTCLKIN1 */
+                { RCAR_GP_PIN(0, 14), 28, 3 },  /* D14 */
+                { RCAR_GP_PIN(0, 15), 24, 3 },  /* D15 */
+                { RCAR_GP_PIN(7,  0), 20, 3 },  /* AVS1 */
+                { RCAR_GP_PIN(7,  1), 16, 3 },  /* AVS2 */
+                { RCAR_GP_PIN(7,  2), 12, 3 },  /* GP7_02 */
+                { RCAR_GP_PIN(7,  3),  8, 3 },  /* GP7_03 */
+                { PIN_DU_DOTCLKIN0,    4, 2 },  /* DU_DOTCLKIN0 */
+                { PIN_DU_DOTCLKIN1,    0, 2 },  /* DU_DOTCLKIN1 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL12", 0xe6060330) {
-                { PIN_A_NUMBER('R', 8),  28, 2 },       /* DU_DOTCLKIN2 */
-                { PIN_A_NUMBER('D', 38), 20, 2 },       /* FSCLKST */
-                { PIN_A_NUMBER('R', 30),  4, 2 },       /* TMS */
+                { PIN_DU_DOTCLKIN2,   28, 2 },  /* DU_DOTCLKIN2 */
+                { PIN_FSCLKST,        20, 2 },  /* FSCLKST */
+                { PIN_TMS,             4, 2 },  /* TMS */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL13", 0xe6060334) {
-                { PIN_A_NUMBER('T', 28), 28, 2 },       /* TDO */
-                { PIN_A_NUMBER('T', 30), 24, 2 },       /* ASEBRK */
-                { RCAR_GP_PIN(3,  0),    20, 3 },       /* SD0_CLK */
-                { RCAR_GP_PIN(3,  1),    16, 3 },       /* SD0_CMD */
-                { RCAR_GP_PIN(3,  2),    12, 3 },       /* SD0_DAT0 */
-                { RCAR_GP_PIN(3,  3),     8, 3 },       /* SD0_DAT1 */
-                { RCAR_GP_PIN(3,  4),     4, 3 },       /* SD0_DAT2 */
-                { RCAR_GP_PIN(3,  5),     0, 3 },       /* SD0_DAT3 */
+                { PIN_TDO,            28, 2 },  /* TDO */
+                { PIN_ASEBRK,         24, 2 },  /* ASEBRK */
+                { RCAR_GP_PIN(3,  0), 20, 3 },  /* SD0_CLK */
+                { RCAR_GP_PIN(3,  1), 16, 3 },  /* SD0_CMD */
+                { RCAR_GP_PIN(3,  2), 12, 3 },  /* SD0_DAT0 */
+                { RCAR_GP_PIN(3,  3),  8, 3 },  /* SD0_DAT1 */
+                { RCAR_GP_PIN(3,  4),  4, 3 },  /* SD0_DAT2 */
+                { RCAR_GP_PIN(3,  5),  0, 3 },  /* SD0_DAT3 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL14", 0xe6060338) {
                 { RCAR_GP_PIN(3,  6), 28, 3 },  /* SD1_CLK */
@@ -5791,7 +5825,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(5, 23), 16, 3 },  /* MLB_CLK */
                 { RCAR_GP_PIN(5, 24), 12, 3 },  /* MLB_SIG */
                 { RCAR_GP_PIN(5, 25),  8, 3 },  /* MLB_DAT */
-                { PIN_NUMBER('H', 37),  4, 3 }, /* MLB_REF */
+                { PIN_MLB_REF,         4, 3 },  /* MLB_REF */
                 { RCAR_GP_PIN(6,  0),  0, 3 },  /* SSI_SCK01239 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL21", 0xe6060354) {
@@ -5864,35 +5898,35 @@ static int r8a7796_pin_to_pocctrl(struct sh_pfc *pfc, unsigned int pin, u32 *poc
 
 static const struct pinmux_bias_reg pinmux_bias_regs[] = {
         { PINMUX_BIAS_REG("PUEN0", 0xe6060400, "PUD0", 0xe6060440) {
-                [ 0] = PIN_NUMBER('W', 3),      /* QSPI0_SPCLK */
-                [ 1] = PIN_A_NUMBER('C', 5),    /* QSPI0_MOSI_IO0 */
-                [ 2] = PIN_A_NUMBER('B', 4),    /* QSPI0_MISO_IO1 */
-                [ 3] = PIN_NUMBER('Y', 6),      /* QSPI0_IO2 */
-                [ 4] = PIN_A_NUMBER('B', 6),    /* QSPI0_IO3 */
-                [ 5] = PIN_NUMBER('Y', 3),      /* QSPI0_SSL */
-                [ 6] = PIN_NUMBER('V', 3),      /* QSPI1_SPCLK */
-                [ 7] = PIN_A_NUMBER('C', 7),    /* QSPI1_MOSI_IO0 */
-                [ 8] = PIN_A_NUMBER('E', 5),    /* QSPI1_MISO_IO1 */
-                [ 9] = PIN_A_NUMBER('E', 4),    /* QSPI1_IO2 */
-                [10] = PIN_A_NUMBER('C', 3),    /* QSPI1_IO3 */
-                [11] = PIN_NUMBER('V', 5),      /* QSPI1_SSL */
-                [12] = PIN_NUMBER('Y', 7),      /* RPC_INT# */
-                [13] = PIN_NUMBER('V', 6),      /* RPC_WP# */
-                [14] = PIN_NUMBER('V', 7),      /* RPC_RESET# */
-                [15] = PIN_NUMBER('A', 16),     /* AVB_RX_CTL */
-                [16] = PIN_NUMBER('B', 19),     /* AVB_RXC */
-                [17] = PIN_NUMBER('A', 13),     /* AVB_RD0 */
-                [18] = PIN_NUMBER('B', 13),     /* AVB_RD1 */
-                [19] = PIN_NUMBER('A', 14),     /* AVB_RD2 */
-                [20] = PIN_NUMBER('B', 14),     /* AVB_RD3 */
-                [21] = PIN_NUMBER('A', 8),      /* AVB_TX_CTL */
-                [22] = PIN_NUMBER('A', 19),     /* AVB_TXC */
-                [23] = PIN_NUMBER('A', 18),     /* AVB_TD0 */
-                [24] = PIN_NUMBER('B', 18),     /* AVB_TD1 */
-                [25] = PIN_NUMBER('A', 17),     /* AVB_TD2 */
-                [26] = PIN_NUMBER('B', 17),     /* AVB_TD3 */
-                [27] = PIN_NUMBER('A', 12),     /* AVB_TXCREFCLK */
-                [28] = PIN_NUMBER('A', 9),      /* AVB_MDIO */
+                [ 0] = PIN_QSPI0_SPCLK,         /* QSPI0_SPCLK */
+                [ 1] = PIN_QSPI0_MOSI_IO0,      /* QSPI0_MOSI_IO0 */
+                [ 2] = PIN_QSPI0_MISO_IO1,      /* QSPI0_MISO_IO1 */
+                [ 3] = PIN_QSPI0_IO2,           /* QSPI0_IO2 */
+                [ 4] = PIN_QSPI0_IO3,           /* QSPI0_IO3 */
+                [ 5] = PIN_QSPI0_SSL,           /* QSPI0_SSL */
+                [ 6] = PIN_QSPI1_SPCLK,         /* QSPI1_SPCLK */
+                [ 7] = PIN_QSPI1_MOSI_IO0,      /* QSPI1_MOSI_IO0 */
+                [ 8] = PIN_QSPI1_MISO_IO1,      /* QSPI1_MISO_IO1 */
+                [ 9] = PIN_QSPI1_IO2,           /* QSPI1_IO2 */
+                [10] = PIN_QSPI1_IO3,           /* QSPI1_IO3 */
+                [11] = PIN_QSPI1_SSL,           /* QSPI1_SSL */
+                [12] = PIN_RPC_INT_N,           /* RPC_INT# */
+                [13] = PIN_RPC_WP_N,            /* RPC_WP# */
+                [14] = PIN_RPC_RESET_N,         /* RPC_RESET# */
+                [15] = PIN_AVB_RX_CTL,          /* AVB_RX_CTL */
+                [16] = PIN_AVB_RXC,             /* AVB_RXC */
+                [17] = PIN_AVB_RD0,             /* AVB_RD0 */
+                [18] = PIN_AVB_RD1,             /* AVB_RD1 */
+                [19] = PIN_AVB_RD2,             /* AVB_RD2 */
+                [20] = PIN_AVB_RD3,             /* AVB_RD3 */
+                [21] = PIN_AVB_TX_CTL,          /* AVB_TX_CTL */
+                [22] = PIN_AVB_TXC,             /* AVB_TXC */
+                [23] = PIN_AVB_TD0,             /* AVB_TD0 */
+                [24] = PIN_AVB_TD1,             /* AVB_TD1 */
+                [25] = PIN_AVB_TD2,             /* AVB_TD2 */
+                [26] = PIN_AVB_TD3,             /* AVB_TD3 */
+                [27] = PIN_AVB_TXCREFCLK,       /* AVB_TXCREFCLK */
+                [28] = PIN_AVB_MDIO,            /* AVB_MDIO */
                 [29] = RCAR_GP_PIN(2,  9),      /* AVB_MDC */
                 [30] = RCAR_GP_PIN(2, 10),      /* AVB_MAGIC */
                 [31] = RCAR_GP_PIN(2, 11),      /* AVB_PHY_INT */
@@ -5941,7 +5975,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 6] = RCAR_GP_PIN(1, 25),      /* WE0_N */
                 [ 7] = RCAR_GP_PIN(1, 26),      /* WE1_N */
                 [ 8] = RCAR_GP_PIN(1, 27),      /* EX_WAIT0_A */
-                [ 9] = PIN_NUMBER('C', 1),      /* PRESETOUT# */
+                [ 9] = PIN_PRESETOUT_N,         /* PRESETOUT# */
                 [10] = RCAR_GP_PIN(0,  0),      /* D0 */
                 [11] = RCAR_GP_PIN(0,  1),      /* D1 */
                 [12] = RCAR_GP_PIN(0,  2),      /* D2 */
@@ -5962,20 +5996,20 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [27] = RCAR_GP_PIN(7,  1),      /* AVS2 */
                 [28] = RCAR_GP_PIN(7,  2),      /* GP7_02 */
                 [29] = RCAR_GP_PIN(7,  3),      /* GP7_03 */
-                [30] = PIN_A_NUMBER('P', 7),    /* DU_DOTCLKIN0 */
-                [31] = PIN_A_NUMBER('P', 8),    /* DU_DOTCLKIN1 */
+                [30] = PIN_DU_DOTCLKIN0,        /* DU_DOTCLKIN0 */
+                [31] = PIN_DU_DOTCLKIN1,        /* DU_DOTCLKIN1 */
         } },
         { PINMUX_BIAS_REG("PUEN3", 0xe606040c, "PUD3", 0xe606044c) {
-                [ 0] = PIN_A_NUMBER('R', 8),    /* DU_DOTCLKIN2 */
-                [ 1] = PIN_NONE,
-                [ 2] = PIN_A_NUMBER('D', 38),   /* FSCLKST */
-                [ 3] = PIN_A_NUMBER('D', 39),   /* EXTALR*/
-                [ 4] = PIN_A_NUMBER('R', 26),   /* TRST# */
-                [ 5] = PIN_A_NUMBER('T', 27),   /* TCK */
-                [ 6] = PIN_A_NUMBER('R', 30),   /* TMS */
-                [ 7] = PIN_A_NUMBER('R', 29),   /* TDI */
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_A_NUMBER('T', 30),   /* ASEBRK */
+                [ 0] = PIN_DU_DOTCLKIN2,        /* DU_DOTCLKIN2 */
+                [ 1] = SH_PFC_PIN_NONE,
+                [ 2] = PIN_FSCLKST,             /* FSCLKST */
+                [ 3] = PIN_EXTALR,              /* EXTALR*/
+                [ 4] = PIN_TRST_N,              /* TRST# */
+                [ 5] = PIN_TCK,                 /* TCK */
+                [ 6] = PIN_TMS,                 /* TMS */
+                [ 7] = PIN_TDI,                 /* TDI */
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = PIN_ASEBRK,              /* ASEBRK */
                 [10] = RCAR_GP_PIN(3,  0),      /* SD0_CLK */
                 [11] = RCAR_GP_PIN(3,  1),      /* SD0_CMD */
                 [12] = RCAR_GP_PIN(3,  2),      /* SD0_DAT0 */
@@ -6040,7 +6074,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 3] = RCAR_GP_PIN(5, 23),      /* MLB_CLK */
                 [ 4] = RCAR_GP_PIN(5, 24),      /* MLB_SIG */
                 [ 5] = RCAR_GP_PIN(5, 25),      /* MLB_DAT */
-                [ 6] = PIN_NUMBER('H', 37),     /* MLB_REF */
+                [ 6] = PIN_MLB_REF,             /* MLB_REF */
                 [ 7] = RCAR_GP_PIN(6,  0),      /* SSI_SCK01239 */
                 [ 8] = RCAR_GP_PIN(6,  1),      /* SSI_WS01239 */
                 [ 9] = RCAR_GP_PIN(6,  2),      /* SSI_SDATA0 */
@@ -6075,31 +6109,31 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 4] = RCAR_GP_PIN(6, 29),      /* USB30_OVC */
                 [ 5] = RCAR_GP_PIN(6, 30),      /* GP6_30 */
                 [ 6] = RCAR_GP_PIN(6, 31),      /* GP6_31 */
-                [ 7] = PIN_NONE,
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [ 7] = SH_PFC_PIN_NONE,
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { /* sentinel */ },
 };
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77965.c b/drivers/pinctrl/sh-pfc/pfc-r8a77965.c
index 090024355eba..697c77a4ea95 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77965.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77965.c
@@ -18,11 +18,9 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | \
-                   SH_PFC_PIN_CFG_PULL_UP | \
-                   SH_PFC_PIN_CFG_PULL_DOWN)
+#define CFG_FLAGS (SH_PFC_PIN_CFG_DRIVE_STRENGTH | SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_CFG_16(0, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_29(1, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_15(2, fn, sfx, CFG_FLAGS),  \
@@ -35,6 +33,51 @@
         PORT_GP_CFG_26(5, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_32(6, fn, sfx, CFG_FLAGS),  \
         PORT_GP_CFG_4(7, fn, sfx, CFG_FLAGS)
+
+#define CPU_ALL_NOGP(fn)                                                \
+        PIN_NOGP_CFG(ASEBRK, "ASEBRK", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(AVB_MDIO, "AVB_MDIO", fn, CFG_FLAGS),              \
+        PIN_NOGP_CFG(AVB_RD0, "AVB_RD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD1, "AVB_RD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD2, "AVB_RD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RD3, "AVB_RD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RXC, "AVB_RXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_RX_CTL, "AVB_RX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(AVB_TD0, "AVB_TD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD1, "AVB_TD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD2, "AVB_TD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD3, "AVB_TD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXC, "AVB_TXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXCREFCLK, "AVB_TXCREFCLK", fn, CFG_FLAGS),    \
+        PIN_NOGP_CFG(AVB_TX_CTL, "AVB_TX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(DU_DOTCLKIN0, "DU_DOTCLKIN0", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN1, "DU_DOTCLKIN1", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(DU_DOTCLKIN3, "DU_DOTCLKIN3", fn, CFG_FLAGS),      \
+        PIN_NOGP_CFG(EXTALR, "EXTALR", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),\
+        PIN_NOGP_CFG(FSCLKST, "FSCLKST", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(MLB_REF, "MLB_REF", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(PRESETOUT_N, "PRESETOUT#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(QSPI0_IO2, "QSPI0_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_IO3, "QSPI0_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI0_MISO_IO1, "QSPI0_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_MOSI_IO0, "QSPI0_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI0_SPCLK, "QSPI0_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI0_SSL, "QSPI0_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO2, "QSPI1_IO2", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_IO3, "QSPI1_IO3", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(QSPI1_MISO_IO1, "QSPI1_MISO_IO1", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_MOSI_IO0, "QSPI1_MOSI_IO0", fn, CFG_FLAGS),  \
+        PIN_NOGP_CFG(QSPI1_SPCLK, "QSPI1_SPCLK", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(QSPI1_SSL, "QSPI1_SSL", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(RPC_INT_N, "RPC_INT#", fn, CFG_FLAGS),             \
+        PIN_NOGP_CFG(RPC_RESET_N, "RPC_RESET#", fn, CFG_FLAGS),         \
+        PIN_NOGP_CFG(RPC_WP_N, "RPC_WP#", fn, CFG_FLAGS),               \
+        PIN_NOGP_CFG(TCK, "TCK", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDI, "TDI", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN),      \
+        PIN_NOGP_CFG(TDO, "TDO", fn, SH_PFC_PIN_CFG_DRIVE_STRENGTH),    \
+        PIN_NOGP_CFG(TMS, "TMS", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TRST_N, "TRST#", fn, SH_PFC_PIN_CFG_PULL_UP_DOWN)
+
 /*
  * F_() : just information
  * FM() : macro for FN_xxx / xxx_MARK
@@ -1517,67 +1560,16 @@ static const u16 pinmux_data[] = {
 };
 
 /*
- * R8A77965 has 8 banks with 32 GPIOs in each => 256 GPIOs.
- * Physical layout rows: A - AW, cols: 1 - 39.
+ * Pins not associated with a GPIO port.
  */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 39 + (c) + 300)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
-#define PIN_NONE U16_MAX
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /*
-         * Pins not associated with a GPIO port.
-         *
-         * The pin positions are different between different r8a77965
-         * packages, all that is needed for the pfc driver is a unique
-         * number for each pin. To this end use the pin layout from
-         * R-Car M3SiP to calculate a unique number for each pin.
-         */
-        SH_PFC_PIN_NAMED_CFG('A',  8, AVB_TX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A',  9, AVB_MDIO, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 12, AVB_TXCREFCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 13, AVB_RD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 14, AVB_RD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 16, AVB_RX_CTL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 17, AVB_TD2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 18, AVB_TD0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('A', 19, AVB_TXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 13, AVB_RD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 14, AVB_RD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 17, AVB_TD3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 18, AVB_TD1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('B', 19, AVB_RXC, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('C',  1, PRESETOUT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('H', 37, MLB_REF, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  3, QSPI1_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  5, QSPI1_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  6, RPC_WP#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('V',  7, RPC_RESET#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('W',  3, QSPI0_SPCLK, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  3, QSPI0_SSL, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  6, QSPI0_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('Y',  7, RPC_INT#, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  4, QSPI0_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('B'),  6, QSPI0_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  3, QSPI1_IO3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  5, QSPI0_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('C'),  7, QSPI1_MOSI_IO0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 38, FSCLKST, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 39, EXTALR, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  4, QSPI1_IO2, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('E'),  5, QSPI1_MISO_IO1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  7, DU_DOTCLKIN0, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('P'),  8, DU_DOTCLKIN1, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'),  8, DU_DOTCLKIN3, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 26, TRST#, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 29, TDI, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('R'), 30, TMS, CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 27, TCK, SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 28, TDO, SH_PFC_PIN_CFG_DRIVE_STRENGTH),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('T'), 30, ASEBRK, CFG_FLAGS),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -1726,7 +1718,7 @@ static const unsigned int avb_phy_int_mux[] = {
 };
 static const unsigned int avb_mdio_pins[] = {
         /* AVB_MDC, AVB_MDIO */
-        RCAR_GP_PIN(2, 9), PIN_NUMBER('A', 9),
+        RCAR_GP_PIN(2, 9), PIN_AVB_MDIO,
 };
 static const unsigned int avb_mdio_mux[] = {
         AVB_MDC_MARK, AVB_MDIO_MARK,
@@ -1739,11 +1731,11 @@ static const unsigned int avb_mii_pins[] = {
          * AVB_RD1, AVB_RD2, AVB_RD3,
          * AVB_TXCREFCLK
          */
-        PIN_NUMBER('A', 8), PIN_NUMBER('A', 19), PIN_NUMBER('A', 18),
-        PIN_NUMBER('B', 18), PIN_NUMBER('A', 17), PIN_NUMBER('B', 17),
-        PIN_NUMBER('A', 16), PIN_NUMBER('B', 19), PIN_NUMBER('A', 13),
-        PIN_NUMBER('B', 13), PIN_NUMBER('A', 14), PIN_NUMBER('B', 14),
-        PIN_NUMBER('A', 12),
+        PIN_AVB_TX_CTL, PIN_AVB_TXC, PIN_AVB_TD0,
+        PIN_AVB_TD1, PIN_AVB_TD2, PIN_AVB_TD3,
+        PIN_AVB_RX_CTL, PIN_AVB_RXC, PIN_AVB_RD0,
+        PIN_AVB_RD1, PIN_AVB_RD2, PIN_AVB_RD3,
+        PIN_AVB_TXCREFCLK,
 
 };
 static const unsigned int avb_mii_mux[] = {
@@ -4116,6 +4108,36 @@ static const unsigned int tmu_tclk2_b_mux[] = {
         TCLK2_B_MARK,
 };
 
+/* - TPU ------------------------------------------------------------------- */
+static const unsigned int tpu_to0_pins[] = {
+        /* TPU0TO0 */
+        RCAR_GP_PIN(6, 28),
+};
+static const unsigned int tpu_to0_mux[] = {
+        TPU0TO0_MARK,
+};
+static const unsigned int tpu_to1_pins[] = {
+        /* TPU0TO1 */
+        RCAR_GP_PIN(6, 29),
+};
+static const unsigned int tpu_to1_mux[] = {
+        TPU0TO1_MARK,
+};
+static const unsigned int tpu_to2_pins[] = {
+        /* TPU0TO2 */
+        RCAR_GP_PIN(6, 30),
+};
+static const unsigned int tpu_to2_mux[] = {
+        TPU0TO2_MARK,
+};
+static const unsigned int tpu_to3_pins[] = {
+        /* TPU0TO3 */
+        RCAR_GP_PIN(6, 31),
+};
+static const unsigned int tpu_to3_mux[] = {
+        TPU0TO3_MARK,
+};
+
 /* - USB0 ------------------------------------------------------------------- */
 static const unsigned int usb0_pins[] = {
         /* PWEN, OVC */
@@ -4672,6 +4694,10 @@ static const struct sh_pfc_pin_group pinmux_groups[] = {
         SH_PFC_PIN_GROUP(tmu_tclk1_b),
         SH_PFC_PIN_GROUP(tmu_tclk2_a),
         SH_PFC_PIN_GROUP(tmu_tclk2_b),
+        SH_PFC_PIN_GROUP(tpu_to0),
+        SH_PFC_PIN_GROUP(tpu_to1),
+        SH_PFC_PIN_GROUP(tpu_to2),
+        SH_PFC_PIN_GROUP(tpu_to3),
         SH_PFC_PIN_GROUP(usb0),
         SH_PFC_PIN_GROUP(usb1),
         SH_PFC_PIN_GROUP(usb30),
@@ -5164,6 +5190,13 @@ static const char * const tmu_groups[] = {
         "tmu_tclk2_b",
 };
 
+static const char * const tpu_groups[] = {
+        "tpu_to0",
+        "tpu_to1",
+        "tpu_to2",
+        "tpu_to3",
+};
+
 static const char * const usb0_groups[] = {
         "usb0",
 };
@@ -5258,6 +5291,7 @@ static const struct sh_pfc_function pinmux_functions[] = {
         SH_PFC_FUNCTION(sdhi3),
         SH_PFC_FUNCTION(ssi),
         SH_PFC_FUNCTION(tmu),
+        SH_PFC_FUNCTION(tpu),
         SH_PFC_FUNCTION(usb0),
         SH_PFC_FUNCTION(usb1),
         SH_PFC_FUNCTION(usb30),
@@ -5830,44 +5864,44 @@ static const struct pinmux_cfg_reg pinmux_config_regs[] = {
 
 static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         { PINMUX_DRIVE_REG("DRVCTRL0", 0xe6060300) {
-                { PIN_NUMBER('W', 3),   28, 2 },        /* QSPI0_SPCLK */
-                { PIN_A_NUMBER('C', 5), 24, 2 },        /* QSPI0_MOSI_IO0 */
-                { PIN_A_NUMBER('B', 4), 20, 2 },        /* QSPI0_MISO_IO1 */
-                { PIN_NUMBER('Y', 6),   16, 2 },        /* QSPI0_IO2 */
-                { PIN_A_NUMBER('B', 6), 12, 2 },        /* QSPI0_IO3 */
-                { PIN_NUMBER('Y', 3),    8, 2 },        /* QSPI0_SSL */
-                { PIN_NUMBER('V', 3),    4, 2 },        /* QSPI1_SPCLK */
-                { PIN_A_NUMBER('C', 7),  0, 2 },        /* QSPI1_MOSI_IO0 */
+                { PIN_QSPI0_SPCLK,    28, 2 },  /* QSPI0_SPCLK */
+                { PIN_QSPI0_MOSI_IO0, 24, 2 },  /* QSPI0_MOSI_IO0 */
+                { PIN_QSPI0_MISO_IO1, 20, 2 },  /* QSPI0_MISO_IO1 */
+                { PIN_QSPI0_IO2,      16, 2 },  /* QSPI0_IO2 */
+                { PIN_QSPI0_IO3,      12, 2 },  /* QSPI0_IO3 */
+                { PIN_QSPI0_SSL,       8, 2 },  /* QSPI0_SSL */
+                { PIN_QSPI1_SPCLK,     4, 2 },  /* QSPI1_SPCLK */
+                { PIN_QSPI1_MOSI_IO0,  0, 2 },  /* QSPI1_MOSI_IO0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL1", 0xe6060304) {
-                { PIN_A_NUMBER('E', 5), 28, 2 },        /* QSPI1_MISO_IO1 */
-                { PIN_A_NUMBER('E', 4), 24, 2 },        /* QSPI1_IO2 */
-                { PIN_A_NUMBER('C', 3), 20, 2 },        /* QSPI1_IO3 */
-                { PIN_NUMBER('V', 5),   16, 2 },        /* QSPI1_SSL */
-                { PIN_NUMBER('Y', 7),   12, 2 },        /* RPC_INT# */
-                { PIN_NUMBER('V', 6),    8, 2 },        /* RPC_WP# */
-                { PIN_NUMBER('V', 7),    4, 2 },        /* RPC_RESET# */
-                { PIN_NUMBER('A', 16),   0, 3 },        /* AVB_RX_CTL */
+                { PIN_QSPI1_MISO_IO1, 28, 2 },  /* QSPI1_MISO_IO1 */
+                { PIN_QSPI1_IO2,      24, 2 },  /* QSPI1_IO2 */
+                { PIN_QSPI1_IO3,      20, 2 },  /* QSPI1_IO3 */
+                { PIN_QSPI1_SSL,      16, 2 },  /* QSPI1_SSL */
+                { PIN_RPC_INT_N,      12, 2 },  /* RPC_INT# */
+                { PIN_RPC_WP_N,        8, 2 },  /* RPC_WP# */
+                { PIN_RPC_RESET_N,     4, 2 },  /* RPC_RESET# */
+                { PIN_AVB_RX_CTL,      0, 3 },  /* AVB_RX_CTL */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL2", 0xe6060308) {
-                { PIN_NUMBER('B', 19),  28, 3 },        /* AVB_RXC */
-                { PIN_NUMBER('A', 13),  24, 3 },        /* AVB_RD0 */
-                { PIN_NUMBER('B', 13),  20, 3 },        /* AVB_RD1 */
-                { PIN_NUMBER('A', 14),  16, 3 },        /* AVB_RD2 */
-                { PIN_NUMBER('B', 14),  12, 3 },        /* AVB_RD3 */
-                { PIN_NUMBER('A', 8),    8, 3 },        /* AVB_TX_CTL */
-                { PIN_NUMBER('A', 19),   4, 3 },        /* AVB_TXC */
-                { PIN_NUMBER('A', 18),   0, 3 },        /* AVB_TD0 */
+                { PIN_AVB_RXC,        28, 3 },  /* AVB_RXC */
+                { PIN_AVB_RD0,        24, 3 },  /* AVB_RD0 */
+                { PIN_AVB_RD1,        20, 3 },  /* AVB_RD1 */
+                { PIN_AVB_RD2,        16, 3 },  /* AVB_RD2 */
+                { PIN_AVB_RD3,        12, 3 },  /* AVB_RD3 */
+                { PIN_AVB_TX_CTL,      8, 3 },  /* AVB_TX_CTL */
+                { PIN_AVB_TXC,         4, 3 },  /* AVB_TXC */
+                { PIN_AVB_TD0,         0, 3 },  /* AVB_TD0 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL3", 0xe606030c) {
-                { PIN_NUMBER('B', 18),  28, 3 },        /* AVB_TD1 */
-                { PIN_NUMBER('A', 17),  24, 3 },        /* AVB_TD2 */
-                { PIN_NUMBER('B', 17),  20, 3 },        /* AVB_TD3 */
-                { PIN_NUMBER('A', 12),  16, 3 },        /* AVB_TXCREFCLK */
-                { PIN_NUMBER('A', 9),   12, 3 },        /* AVB_MDIO */
-                { RCAR_GP_PIN(2,  9),    8, 3 },        /* AVB_MDC */
-                { RCAR_GP_PIN(2, 10),    4, 3 },        /* AVB_MAGIC */
-                { RCAR_GP_PIN(2, 11),    0, 3 },        /* AVB_PHY_INT */
+                { PIN_AVB_TD1,        28, 3 },  /* AVB_TD1 */
+                { PIN_AVB_TD2,        24, 3 },  /* AVB_TD2 */
+                { PIN_AVB_TD3,        20, 3 },  /* AVB_TD3 */
+                { PIN_AVB_TXCREFCLK,  16, 3 },  /* AVB_TXCREFCLK */
+                { PIN_AVB_MDIO,       12, 3 },  /* AVB_MDIO */
+                { RCAR_GP_PIN(2,  9),  8, 3 },  /* AVB_MDC */
+                { RCAR_GP_PIN(2, 10),  4, 3 },  /* AVB_MAGIC */
+                { RCAR_GP_PIN(2, 11),  0, 3 },  /* AVB_PHY_INT */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL4", 0xe6060310) {
                 { RCAR_GP_PIN(2, 12), 28, 3 },  /* AVB_LINK */
@@ -5921,7 +5955,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
         } },
         { PINMUX_DRIVE_REG("DRVCTRL9", 0xe6060324) {
                 { RCAR_GP_PIN(1, 27), 28, 3 },  /* EX_WAIT0 */
-                { PIN_NUMBER('C', 1), 24, 3 },  /* PRESETOUT# */
+                { PIN_PRESETOUT_N,    24, 3 },  /* PRESETOUT# */
                 { RCAR_GP_PIN(0,  0), 20, 3 },  /* D0 */
                 { RCAR_GP_PIN(0,  1), 16, 3 },  /* D1 */
                 { RCAR_GP_PIN(0,  2), 12, 3 },  /* D2 */
@@ -5940,29 +5974,29 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(0, 13),  0, 3 },  /* D13 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL11", 0xe606032c) {
-                { RCAR_GP_PIN(0, 14),   28, 3 },        /* D14 */
-                { RCAR_GP_PIN(0, 15),   24, 3 },        /* D15 */
-                { RCAR_GP_PIN(7,  0),   20, 3 },        /* AVS1 */
-                { RCAR_GP_PIN(7,  1),   16, 3 },        /* AVS2 */
-                { RCAR_GP_PIN(7,  2),   12, 3 },        /* GP7_02 */
-                { RCAR_GP_PIN(7,  3),    8, 3 },        /* GP7_03 */
-                { PIN_A_NUMBER('P', 7),  4, 2 },        /* DU_DOTCLKIN0 */
-                { PIN_A_NUMBER('P', 8),  0, 2 },        /* DU_DOTCLKIN1 */
+                { RCAR_GP_PIN(0, 14), 28, 3 },  /* D14 */
+                { RCAR_GP_PIN(0, 15), 24, 3 },  /* D15 */
+                { RCAR_GP_PIN(7,  0), 20, 3 },  /* AVS1 */
+                { RCAR_GP_PIN(7,  1), 16, 3 },  /* AVS2 */
+                { RCAR_GP_PIN(7,  2), 12, 3 },  /* GP7_02 */
+                { RCAR_GP_PIN(7,  3),  8, 3 },  /* GP7_03 */
+                { PIN_DU_DOTCLKIN0,    4, 2 },  /* DU_DOTCLKIN0 */
+                { PIN_DU_DOTCLKIN1,    0, 2 },  /* DU_DOTCLKIN1 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL12", 0xe6060330) {
-                { PIN_A_NUMBER('R', 8),  28, 2 },       /* DU_DOTCLKIN3 */
-                { PIN_A_NUMBER('D', 38), 20, 2 },       /* FSCLKST */
-                { PIN_A_NUMBER('R', 30),  4, 2 },       /* TMS */
+                { PIN_DU_DOTCLKIN3,   28, 2 },  /* DU_DOTCLKIN3 */
+                { PIN_FSCLKST,        20, 2 },  /* FSCLKST */
+                { PIN_TMS,             4, 2 },  /* TMS */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL13", 0xe6060334) {
-                { PIN_A_NUMBER('T', 28), 28, 2 },       /* TDO */
-                { PIN_A_NUMBER('T', 30), 24, 2 },       /* ASEBRK */
-                { RCAR_GP_PIN(3,  0),    20, 3 },       /* SD0_CLK */
-                { RCAR_GP_PIN(3,  1),    16, 3 },       /* SD0_CMD */
-                { RCAR_GP_PIN(3,  2),    12, 3 },       /* SD0_DAT0 */
-                { RCAR_GP_PIN(3,  3),     8, 3 },       /* SD0_DAT1 */
-                { RCAR_GP_PIN(3,  4),     4, 3 },       /* SD0_DAT2 */
-                { RCAR_GP_PIN(3,  5),     0, 3 },       /* SD0_DAT3 */
+                { PIN_TDO,            28, 2 },  /* TDO */
+                { PIN_ASEBRK,         24, 2 },  /* ASEBRK */
+                { RCAR_GP_PIN(3,  0), 20, 3 },  /* SD0_CLK */
+                { RCAR_GP_PIN(3,  1), 16, 3 },  /* SD0_CMD */
+                { RCAR_GP_PIN(3,  2), 12, 3 },  /* SD0_DAT0 */
+                { RCAR_GP_PIN(3,  3),  8, 3 },  /* SD0_DAT1 */
+                { RCAR_GP_PIN(3,  4),  4, 3 },  /* SD0_DAT2 */
+                { RCAR_GP_PIN(3,  5),  0, 3 },  /* SD0_DAT3 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL14", 0xe6060338) {
                 { RCAR_GP_PIN(3,  6), 28, 3 },  /* SD1_CLK */
@@ -6031,7 +6065,7 @@ static const struct pinmux_drive_reg pinmux_drive_regs[] = {
                 { RCAR_GP_PIN(5, 23), 16, 3 },  /* MLB_CLK */
                 { RCAR_GP_PIN(5, 24), 12, 3 },  /* MLB_SIG */
                 { RCAR_GP_PIN(5, 25),  8, 3 },  /* MLB_DAT */
-                { PIN_NUMBER('H', 37),  4, 3 }, /* MLB_REF */
+                { PIN_MLB_REF,         4, 3 },  /* MLB_REF */
                 { RCAR_GP_PIN(6,  0),  0, 3 },  /* SSI_SCK01239 */
         } },
         { PINMUX_DRIVE_REG("DRVCTRL21", 0xe6060354) {
@@ -6104,35 +6138,35 @@ static int r8a77965_pin_to_pocctrl(struct sh_pfc *pfc, unsigned int pin, u32 *po
 
 static const struct pinmux_bias_reg pinmux_bias_regs[] = {
         { PINMUX_BIAS_REG("PUEN0", 0xe6060400, "PUD0", 0xe6060440) {
-                [ 0] = PIN_NUMBER('W', 3),      /* QSPI0_SPCLK */
-                [ 1] = PIN_A_NUMBER('C', 5),    /* QSPI0_MOSI_IO0 */
-                [ 2] = PIN_A_NUMBER('B', 4),    /* QSPI0_MISO_IO1 */
-                [ 3] = PIN_NUMBER('Y', 6),      /* QSPI0_IO2 */
-                [ 4] = PIN_A_NUMBER('B', 6),    /* QSPI0_IO3 */
-                [ 5] = PIN_NUMBER('Y', 3),      /* QSPI0_SSL */
-                [ 6] = PIN_NUMBER('V', 3),      /* QSPI1_SPCLK */
-                [ 7] = PIN_A_NUMBER('C', 7),    /* QSPI1_MOSI_IO0 */
-                [ 8] = PIN_A_NUMBER('E', 5),    /* QSPI1_MISO_IO1 */
-                [ 9] = PIN_A_NUMBER('E', 4),    /* QSPI1_IO2 */
-                [10] = PIN_A_NUMBER('C', 3),    /* QSPI1_IO3 */
-                [11] = PIN_NUMBER('V', 5),      /* QSPI1_SSL */
-                [12] = PIN_NUMBER('Y', 7),      /* RPC_INT# */
-                [13] = PIN_NUMBER('V', 6),      /* RPC_WP# */
-                [14] = PIN_NUMBER('V', 7),      /* RPC_RESET# */
-                [15] = PIN_NUMBER('A', 16),     /* AVB_RX_CTL */
-                [16] = PIN_NUMBER('B', 19),     /* AVB_RXC */
-                [17] = PIN_NUMBER('A', 13),     /* AVB_RD0 */
-                [18] = PIN_NUMBER('B', 13),     /* AVB_RD1 */
-                [19] = PIN_NUMBER('A', 14),     /* AVB_RD2 */
-                [20] = PIN_NUMBER('B', 14),     /* AVB_RD3 */
-                [21] = PIN_NUMBER('A', 8),      /* AVB_TX_CTL */
-                [22] = PIN_NUMBER('A', 19),     /* AVB_TXC */
-                [23] = PIN_NUMBER('A', 18),     /* AVB_TD0 */
-                [24] = PIN_NUMBER('B', 18),     /* AVB_TD1 */
-                [25] = PIN_NUMBER('A', 17),     /* AVB_TD2 */
-                [26] = PIN_NUMBER('B', 17),     /* AVB_TD3 */
-                [27] = PIN_NUMBER('A', 12),     /* AVB_TXCREFCLK */
-                [28] = PIN_NUMBER('A', 9),      /* AVB_MDIO */
+                [ 0] = PIN_QSPI0_SPCLK,         /* QSPI0_SPCLK */
+                [ 1] = PIN_QSPI0_MOSI_IO0,      /* QSPI0_MOSI_IO0 */
+                [ 2] = PIN_QSPI0_MISO_IO1,      /* QSPI0_MISO_IO1 */
+                [ 3] = PIN_QSPI0_IO2,           /* QSPI0_IO2 */
+                [ 4] = PIN_QSPI0_IO3,           /* QSPI0_IO3 */
+                [ 5] = PIN_QSPI0_SSL,           /* QSPI0_SSL */
+                [ 6] = PIN_QSPI1_SPCLK,         /* QSPI1_SPCLK */
+                [ 7] = PIN_QSPI1_MOSI_IO0,      /* QSPI1_MOSI_IO0 */
+                [ 8] = PIN_QSPI1_MISO_IO1,      /* QSPI1_MISO_IO1 */
+                [ 9] = PIN_QSPI1_IO2,           /* QSPI1_IO2 */
+                [10] = PIN_QSPI1_IO3,           /* QSPI1_IO3 */
+                [11] = PIN_QSPI1_SSL,           /* QSPI1_SSL */
+                [12] = PIN_RPC_INT_N,           /* RPC_INT# */
+                [13] = PIN_RPC_WP_N,            /* RPC_WP# */
+                [14] = PIN_RPC_RESET_N,         /* RPC_RESET# */
+                [15] = PIN_AVB_RX_CTL,          /* AVB_RX_CTL */
+                [16] = PIN_AVB_RXC,             /* AVB_RXC */
+                [17] = PIN_AVB_RD0,             /* AVB_RD0 */
+                [18] = PIN_AVB_RD1,             /* AVB_RD1 */
+                [19] = PIN_AVB_RD2,             /* AVB_RD2 */
+                [20] = PIN_AVB_RD3,             /* AVB_RD3 */
+                [21] = PIN_AVB_TX_CTL,          /* AVB_TX_CTL */
+                [22] = PIN_AVB_TXC,             /* AVB_TXC */
+                [23] = PIN_AVB_TD0,             /* AVB_TD0 */
+                [24] = PIN_AVB_TD1,             /* AVB_TD1 */
+                [25] = PIN_AVB_TD2,             /* AVB_TD2 */
+                [26] = PIN_AVB_TD3,             /* AVB_TD3 */
+                [27] = PIN_AVB_TXCREFCLK,       /* AVB_TXCREFCLK */
+                [28] = PIN_AVB_MDIO,            /* AVB_MDIO */
                 [29] = RCAR_GP_PIN(2,  9),      /* AVB_MDC */
                 [30] = RCAR_GP_PIN(2, 10),      /* AVB_MAGIC */
                 [31] = RCAR_GP_PIN(2, 11),      /* AVB_PHY_INT */
@@ -6181,7 +6215,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 6] = RCAR_GP_PIN(1, 25),      /* WE0_N */
                 [ 7] = RCAR_GP_PIN(1, 26),      /* WE1_N */
                 [ 8] = RCAR_GP_PIN(1, 27),      /* EX_WAIT0_A */
-                [ 9] = PIN_NUMBER('C', 1),      /* PRESETOUT# */
+                [ 9] = PIN_PRESETOUT_N,         /* PRESETOUT# */
                 [10] = RCAR_GP_PIN(0,  0),      /* D0 */
                 [11] = RCAR_GP_PIN(0,  1),      /* D1 */
                 [12] = RCAR_GP_PIN(0,  2),      /* D2 */
@@ -6202,20 +6236,20 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [27] = RCAR_GP_PIN(7,  1),      /* AVS2 */
                 [28] = RCAR_GP_PIN(7,  2),      /* GP7_02 */
                 [29] = RCAR_GP_PIN(7,  3),      /* GP7_03 */
-                [30] = PIN_A_NUMBER('P', 7),    /* DU_DOTCLKIN0 */
-                [31] = PIN_A_NUMBER('P', 8),    /* DU_DOTCLKIN1 */
+                [30] = PIN_DU_DOTCLKIN0,        /* DU_DOTCLKIN0 */
+                [31] = PIN_DU_DOTCLKIN1,        /* DU_DOTCLKIN1 */
         } },
         { PINMUX_BIAS_REG("PUEN3", 0xe606040c, "PUD3", 0xe606044c) {
-                [ 0] = PIN_A_NUMBER('R', 8),    /* DU_DOTCLKIN3 */
-                [ 1] = PIN_NONE,
-                [ 2] = PIN_A_NUMBER('D', 38),   /* FSCLKST */
-                [ 3] = PIN_A_NUMBER('D', 39),   /* EXTALR*/
-                [ 4] = PIN_A_NUMBER('R', 26),   /* TRST# */
-                [ 5] = PIN_A_NUMBER('T', 27),   /* TCK */
-                [ 6] = PIN_A_NUMBER('R', 30),   /* TMS */
-                [ 7] = PIN_A_NUMBER('R', 29),   /* TDI */
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_A_NUMBER('T', 30),   /* ASEBRK */
+                [ 0] = PIN_DU_DOTCLKIN3,        /* DU_DOTCLKIN3 */
+                [ 1] = SH_PFC_PIN_NONE,
+                [ 2] = PIN_FSCLKST,             /* FSCLKST */
+                [ 3] = PIN_EXTALR,              /* EXTALR*/
+                [ 4] = PIN_TRST_N,              /* TRST# */
+                [ 5] = PIN_TCK,                 /* TCK */
+                [ 6] = PIN_TMS,                 /* TMS */
+                [ 7] = PIN_TDI,                 /* TDI */
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = PIN_ASEBRK,              /* ASEBRK */
                 [10] = RCAR_GP_PIN(3,  0),      /* SD0_CLK */
                 [11] = RCAR_GP_PIN(3,  1),      /* SD0_CMD */
                 [12] = RCAR_GP_PIN(3,  2),      /* SD0_DAT0 */
@@ -6280,7 +6314,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 3] = RCAR_GP_PIN(5, 23),      /* MLB_CLK */
                 [ 4] = RCAR_GP_PIN(5, 24),      /* MLB_SIG */
                 [ 5] = RCAR_GP_PIN(5, 25),      /* MLB_DAT */
-                [ 6] = PIN_NUMBER('H', 37),     /* MLB_REF */
+                [ 6] = PIN_MLB_REF,             /* MLB_REF */
                 [ 7] = RCAR_GP_PIN(6,  0),      /* SSI_SCK01239 */
                 [ 8] = RCAR_GP_PIN(6,  1),      /* SSI_WS01239 */
                 [ 9] = RCAR_GP_PIN(6,  2),      /* SSI_SDATA0 */
@@ -6315,31 +6349,31 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [ 4] = RCAR_GP_PIN(6, 29),      /* USB30_OVC */
                 [ 5] = RCAR_GP_PIN(6, 30),      /* GP6_30 */
                 [ 6] = RCAR_GP_PIN(6, 31),      /* GP6_31 */
-                [ 7] = PIN_NONE,
-                [ 8] = PIN_NONE,
-                [ 9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
-                [30] = PIN_NONE,
-                [31] = PIN_NONE,
+                [ 7] = SH_PFC_PIN_NONE,
+                [ 8] = SH_PFC_PIN_NONE,
+                [ 9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
+                [30] = SH_PFC_PIN_NONE,
+                [31] = SH_PFC_PIN_NONE,
         } },
         { /* sentinel */ },
 };
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77970.c b/drivers/pinctrl/sh-pfc/pfc-r8a77970.c
index 2d76b548b942..25e27b6bee89 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77970.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77970.c
@@ -19,7 +19,7 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_CFG_22(0, fn, sfx, SH_PFC_PIN_CFG_IO_VOLTAGE),          \
         PORT_GP_28(1, fn, sfx),                                         \
         PORT_GP_CFG_17(2, fn, sfx, SH_PFC_PIN_CFG_IO_VOLTAGE),          \
@@ -205,8 +205,8 @@
 #define IP6_19_16       FM(VI1_DATA8)                   F_(0, 0)                FM(CTS4_N)      FM(D11)         FM(MMC_D5)              F_(0, 0)        F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
 #define IP6_23_20       FM(VI1_DATA9)                   F_(0, 0)                FM(RTS4_N)      FM(D12)         FM(MMC_D6)              FM(SCL3_B)      F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
 #define IP6_27_24       FM(VI1_DATA10)                  F_(0, 0)                F_(0, 0)        FM(D13)         FM(MMC_D7)              FM(SDA3_B)      F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
-#define IP6_31_28       FM(VI1_DATA11)                  FM(SCL4)                FM(IRQ4)        FM(D14)         FM(MMC_WP)              F_(0, 0)        F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
-#define IP7_3_0         FM(VI1_FIELD)                   FM(SDA4)                FM(IRQ5)        FM(D15)         FM(MMC_CD)              F_(0, 0)        F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
+#define IP6_31_28       FM(VI1_DATA11)                  FM(SCL4)                FM(IRQ4)        FM(D14)         F_(0, 0)                F_(0, 0)        F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
+#define IP7_3_0         FM(VI1_FIELD)                   FM(SDA4)                FM(IRQ5)        FM(D15)         F_(0, 0)                F_(0, 0)        F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
 #define IP7_7_4         FM(SCL0)                        FM(DU_DR0)              FM(TPU0TO0)     FM(CLKOUT)      F_(0, 0)                FM(MSIOF0_RXD)  F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
 #define IP7_11_8        FM(SDA0)                        FM(DU_DR1)              FM(TPU0TO1)     FM(BS_N)        FM(SCK0)                FM(MSIOF0_TXD)  F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
 #define IP7_15_12       FM(SCL1)                        FM(DU_DG0)              FM(TPU0TO2)     FM(RD_N)        FM(CTS0_N)              FM(MSIOF0_SCK)  F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0) F_(0, 0)
@@ -631,14 +631,12 @@ static const u16 pinmux_data[] = {
         PINMUX_IPSR_GPSR(IP6_31_28,     SCL4),
         PINMUX_IPSR_GPSR(IP6_31_28,     IRQ4),
         PINMUX_IPSR_GPSR(IP6_31_28,     D14),
-        PINMUX_IPSR_GPSR(IP6_31_28,     MMC_WP),
 
         /* IPSR7 */
         PINMUX_IPSR_GPSR(IP7_3_0,       VI1_FIELD),
         PINMUX_IPSR_GPSR(IP7_3_0,       SDA4),
         PINMUX_IPSR_GPSR(IP7_3_0,       IRQ5),
         PINMUX_IPSR_GPSR(IP7_3_0,       D15),
-        PINMUX_IPSR_GPSR(IP7_3_0,       MMC_CD),
 
         PINMUX_IPSR_GPSR(IP7_7_4,       SCL0),
         PINMUX_IPSR_GPSR(IP7_7_4,       DU_DR0),
@@ -1121,20 +1119,6 @@ static const unsigned int mmc_ctrl_pins[] = {
 static const unsigned int mmc_ctrl_mux[] = {
         MMC_CLK_MARK, MMC_CMD_MARK,
 };
-static const unsigned int mmc_cd_pins[] = {
-        /* CD */
-        RCAR_GP_PIN(3, 16),
-};
-static const unsigned int mmc_cd_mux[] = {
-        MMC_CD_MARK,
-};
-static const unsigned int mmc_wp_pins[] = {
-        /* WP */
-        RCAR_GP_PIN(3, 15),
-};
-static const unsigned int mmc_wp_mux[] = {
-        MMC_WP_MARK,
-};
 
 /* - MSIOF0 ----------------------------------------------------------------- */
 static const unsigned int msiof0_clk_pins[] = {
@@ -1726,8 +1710,6 @@ static const struct sh_pfc_pin_group pinmux_groups[] = {
         SH_PFC_PIN_GROUP(mmc_data4),
         SH_PFC_PIN_GROUP(mmc_data8),
         SH_PFC_PIN_GROUP(mmc_ctrl),
-        SH_PFC_PIN_GROUP(mmc_cd),
-        SH_PFC_PIN_GROUP(mmc_wp),
         SH_PFC_PIN_GROUP(msiof0_clk),
         SH_PFC_PIN_GROUP(msiof0_sync),
         SH_PFC_PIN_GROUP(msiof0_ss1),
@@ -1897,8 +1879,6 @@ static const char * const mmc_groups[] = {
         "mmc_data4",
         "mmc_data8",
         "mmc_ctrl",
-        "mmc_cd",
-        "mmc_wp",
 };
 
 static const char * const msiof0_groups[] = {
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77980.c b/drivers/pinctrl/sh-pfc/pfc-r8a77980.c
index 9ed4ead2dafb..14fe4032a52d 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77980.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77980.c
@@ -19,7 +19,7 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)   \
+#define CPU_ALL_GP(fn, sfx)     \
         PORT_GP_CFG_22(0, fn, sfx, SH_PFC_PIN_CFG_IO_VOLTAGE),  \
         PORT_GP_28(1, fn, sfx), \
         PORT_GP_CFG_30(2, fn, sfx, SH_PFC_PIN_CFG_IO_VOLTAGE),  \
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77990.c b/drivers/pinctrl/sh-pfc/pfc-r8a77990.c
index 91a837b02a36..2dfb8d9cfda1 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77990.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77990.c
@@ -17,10 +17,9 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CFG_FLAGS (SH_PFC_PIN_CFG_PULL_UP | \
-                   SH_PFC_PIN_CFG_PULL_DOWN)
+#define CFG_FLAGS (SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
-#define CPU_ALL_PORT(fn, sfx) \
+#define CPU_ALL_GP(fn, sfx) \
         PORT_GP_CFG_18(0, fn, sfx, CFG_FLAGS), \
         PORT_GP_CFG_23(1, fn, sfx, CFG_FLAGS), \
         PORT_GP_CFG_26(2, fn, sfx, CFG_FLAGS), \
@@ -41,6 +40,25 @@
         PORT_GP_CFG_1(6, 15, fn, sfx, CFG_FLAGS), \
         PORT_GP_CFG_1(6, 16, fn, sfx, CFG_FLAGS), \
         PORT_GP_CFG_1(6, 17, fn, sfx, CFG_FLAGS)
+
+#define CPU_ALL_NOGP(fn)                                                \
+        PIN_NOGP_CFG(ASEBRK, "ASEBRK", fn, CFG_FLAGS),                  \
+        PIN_NOGP_CFG(AVB_MDC, "AVB_MDC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_MDIO, "AVB_MDIO", fn, CFG_FLAGS),              \
+        PIN_NOGP_CFG(AVB_TD0, "AVB_TD0", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD1, "AVB_TD1", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD2, "AVB_TD2", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TD3, "AVB_TD3", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TXC, "AVB_TXC", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(AVB_TX_CTL, "AVB_TX_CTL", fn, CFG_FLAGS),          \
+        PIN_NOGP_CFG(FSCLKST_N, "FSCLKST_N", fn, CFG_FLAGS),            \
+        PIN_NOGP_CFG(MLB_REF, "MLB_REF", fn, CFG_FLAGS),                \
+        PIN_NOGP_CFG(PRESETOUT_N, "PRESETOUT_N", fn, CFG_FLAGS),        \
+        PIN_NOGP_CFG(TCK, "TCK", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TDI, "TDI", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TMS, "TMS", fn, CFG_FLAGS),                        \
+        PIN_NOGP_CFG(TRST_N, "TRST_N", fn, CFG_FLAGS)
+
 /*
  * F_() : just information
  * FM() : macro for FN_xxx / xxx_MARK
@@ -1277,41 +1295,16 @@ static const u16 pinmux_data[] = {
 };
 
 /*
- * R8A77990 has 7 banks with 32 GPIOs in each => 224 GPIOs.
- * Physical layout rows: A - AE, cols: 1 - 25.
+ * Pins not associated with a GPIO port.
  */
-#define ROW_GROUP_A(r) ('Z' - 'A' + 1 + (r))
-#define PIN_NUMBER(r, c) (((r) - 'A') * 25 + (c) + 300)
-#define PIN_A_NUMBER(r, c) PIN_NUMBER(ROW_GROUP_A(r), c)
-#define PIN_NONE U16_MAX
+enum {
+        GP_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         PINMUX_GPIO_GP_ALL(),
-
-        /*
-         * Pins not associated with a GPIO port.
-         *
-         * The pin positions are different between different R8A77990
-         * packages, all that is needed for the pfc driver is a unique
-         * number for each pin. To this end use the pin layout from
-         * R8A77990 to calculate a unique number for each pin.
-         */
-        SH_PFC_PIN_NAMED_CFG('F',  1, TRST_N,           CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('F',  3, TMS,              CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('F',  4, TCK,              CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('G',  2, TDI,              CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('G',  3, FSCLKST_N,        CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('H',  1, ASEBRK,           CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('N',  1, AVB_TXC,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('N',  2, AVB_TD0,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('N',  3, AVB_TD1,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('N',  5, AVB_TD2,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('N',  6, AVB_TD3,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('P',  3, AVB_TX_CTL,       CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('P',  4, AVB_MDIO,         CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('P',  5, AVB_MDC,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG('T', 21, MLB_REF,          CFG_FLAGS),
-        SH_PFC_PIN_NAMED_CFG(ROW_GROUP_A('D'), 3, PRESETOUT_N, CFG_FLAGS),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - AUDIO CLOCK ------------------------------------------------------------ */
@@ -5026,15 +5019,15 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                  [0] = RCAR_GP_PIN(2, 23),      /* RD# */
                  [1] = RCAR_GP_PIN(2, 22),      /* BS# */
                  [2] = RCAR_GP_PIN(2, 21),      /* AVB_PHY_INT */
-                 [3] = PIN_NUMBER('P', 5),      /* AVB_MDC */
-                 [4] = PIN_NUMBER('P', 4),      /* AVB_MDIO */
+                 [3] = PIN_AVB_MDC,             /* AVB_MDC */
+                 [4] = PIN_AVB_MDIO,            /* AVB_MDIO */
                  [5] = RCAR_GP_PIN(2, 20),      /* AVB_TXCREFCLK */
-                 [6] = PIN_NUMBER('N', 6),      /* AVB_TD3 */
-                 [7] = PIN_NUMBER('N', 5),      /* AVB_TD2 */
-                 [8] = PIN_NUMBER('N', 3),      /* AVB_TD1 */
-                 [9] = PIN_NUMBER('N', 2),      /* AVB_TD0 */
-                [10] = PIN_NUMBER('N', 1),      /* AVB_TXC */
-                [11] = PIN_NUMBER('P', 3),      /* AVB_TX_CTL */
+                 [6] = PIN_AVB_TD3,             /* AVB_TD3 */
+                 [7] = PIN_AVB_TD2,             /* AVB_TD2 */
+                 [8] = PIN_AVB_TD1,             /* AVB_TD1 */
+                 [9] = PIN_AVB_TD0,             /* AVB_TD0 */
+                [10] = PIN_AVB_TXC,             /* AVB_TXC */
+                [11] = PIN_AVB_TX_CTL,          /* AVB_TX_CTL */
                 [12] = RCAR_GP_PIN(2, 19),      /* AVB_RD3 */
                 [13] = RCAR_GP_PIN(2, 18),      /* AVB_RD2 */
                 [14] = RCAR_GP_PIN(2, 17),      /* AVB_RD1 */
@@ -5085,33 +5078,33 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [25] = RCAR_GP_PIN(1,  2),      /* A2 */
                 [26] = RCAR_GP_PIN(1,  1),      /* A1 */
                 [27] = RCAR_GP_PIN(1,  0),      /* A0 */
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
                 [30] = RCAR_GP_PIN(2, 25),      /* PUEN_EX_WAIT0 */
                 [31] = RCAR_GP_PIN(2, 24),      /* PUEN_RD/WR# */
         } },
         { PINMUX_BIAS_REG("PUEN2", 0xe6060408, "PUD2", 0xe6060448) {
                  [0] = RCAR_GP_PIN(3,  1),      /* SD0_CMD */
                  [1] = RCAR_GP_PIN(3,  0),      /* SD0_CLK */
-                 [2] = PIN_NUMBER('H', 1),      /* ASEBRK */
-                 [3] = PIN_NONE,
-                 [4] = PIN_NUMBER('G', 2),      /* TDI */
-                 [5] = PIN_NUMBER('F', 3),      /* TMS */
-                 [6] = PIN_NUMBER('F', 4),      /* TCK */
-                 [7] = PIN_NUMBER('F', 1),      /* TRST# */
-                 [8] = PIN_NONE,
-                 [9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NUMBER('G', 3),      /* FSCLKST# */
+                 [2] = PIN_ASEBRK,              /* ASEBRK */
+                 [3] = SH_PFC_PIN_NONE,
+                 [4] = PIN_TDI,                 /* TDI */
+                 [5] = PIN_TMS,                 /* TMS */
+                 [6] = PIN_TCK,                 /* TCK */
+                 [7] = PIN_TRST_N,              /* TRST# */
+                 [8] = SH_PFC_PIN_NONE,
+                 [9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = PIN_FSCLKST_N,           /* FSCLKST# */
                 [16] = RCAR_GP_PIN(0, 17),      /* SDA4 */
                 [17] = RCAR_GP_PIN(0, 16),      /* SCL4 */
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_A_NUMBER('D', 3),    /* PRESETOUT# */
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = PIN_PRESETOUT_N,         /* PRESETOUT# */
                 [21] = RCAR_GP_PIN(0, 15),      /* D15 */
                 [22] = RCAR_GP_PIN(0, 14),      /* D14 */
                 [23] = RCAR_GP_PIN(0, 13),      /* D13 */
@@ -5130,8 +5123,8 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                  [2] = RCAR_GP_PIN(5,  3),      /* CTS0#_A */
                  [3] = RCAR_GP_PIN(5,  2),      /* TX0_A */
                  [4] = RCAR_GP_PIN(5,  1),      /* RX0_A */
-                 [5] = PIN_NONE,
-                 [6] = PIN_NONE,
+                 [5] = SH_PFC_PIN_NONE,
+                 [6] = SH_PFC_PIN_NONE,
                  [7] = RCAR_GP_PIN(3, 15),      /* SD1_WP */
                  [8] = RCAR_GP_PIN(3, 14),      /* SD1_CD */
                  [9] = RCAR_GP_PIN(3, 13),      /* SD0_WP */
@@ -5175,7 +5168,7 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [13] = RCAR_GP_PIN(6,  2),      /* SSI_SDATA0 */
                 [14] = RCAR_GP_PIN(6,  1),      /* SSI_WS01239 */
                 [15] = RCAR_GP_PIN(6,  0),      /* SSI_SCK01239 */
-                [16] = PIN_NUMBER('T', 21),     /* MLB_REF */
+                [16] = PIN_MLB_REF,             /* MLB_REF */
                 [17] = RCAR_GP_PIN(5, 19),      /* MLB_DAT */
                 [18] = RCAR_GP_PIN(5, 18),      /* MLB_SIG */
                 [19] = RCAR_GP_PIN(5, 17),      /* MLB_CLK */
@@ -5193,36 +5186,36 @@ static const struct pinmux_bias_reg pinmux_bias_regs[] = {
                 [31] = RCAR_GP_PIN(5,  5),      /* RX1 */
         } },
         { PINMUX_BIAS_REG("PUEN5", 0xe6060414, "PUD5", 0xe6060454) {
-                 [0] = PIN_NONE,
-                 [1] = PIN_NONE,
-                 [2] = PIN_NONE,
-                 [3] = PIN_NONE,
-                 [4] = PIN_NONE,
-                 [5] = PIN_NONE,
-                 [6] = PIN_NONE,
-                 [7] = PIN_NONE,
-                 [8] = PIN_NONE,
-                 [9] = PIN_NONE,
-                [10] = PIN_NONE,
-                [11] = PIN_NONE,
-                [12] = PIN_NONE,
-                [13] = PIN_NONE,
-                [14] = PIN_NONE,
-                [15] = PIN_NONE,
-                [16] = PIN_NONE,
-                [17] = PIN_NONE,
-                [18] = PIN_NONE,
-                [19] = PIN_NONE,
-                [20] = PIN_NONE,
-                [21] = PIN_NONE,
-                [22] = PIN_NONE,
-                [23] = PIN_NONE,
-                [24] = PIN_NONE,
-                [25] = PIN_NONE,
-                [26] = PIN_NONE,
-                [27] = PIN_NONE,
-                [28] = PIN_NONE,
-                [29] = PIN_NONE,
+                 [0] = SH_PFC_PIN_NONE,
+                 [1] = SH_PFC_PIN_NONE,
+                 [2] = SH_PFC_PIN_NONE,
+                 [3] = SH_PFC_PIN_NONE,
+                 [4] = SH_PFC_PIN_NONE,
+                 [5] = SH_PFC_PIN_NONE,
+                 [6] = SH_PFC_PIN_NONE,
+                 [7] = SH_PFC_PIN_NONE,
+                 [8] = SH_PFC_PIN_NONE,
+                 [9] = SH_PFC_PIN_NONE,
+                [10] = SH_PFC_PIN_NONE,
+                [11] = SH_PFC_PIN_NONE,
+                [12] = SH_PFC_PIN_NONE,
+                [13] = SH_PFC_PIN_NONE,
+                [14] = SH_PFC_PIN_NONE,
+                [15] = SH_PFC_PIN_NONE,
+                [16] = SH_PFC_PIN_NONE,
+                [17] = SH_PFC_PIN_NONE,
+                [18] = SH_PFC_PIN_NONE,
+                [19] = SH_PFC_PIN_NONE,
+                [20] = SH_PFC_PIN_NONE,
+                [21] = SH_PFC_PIN_NONE,
+                [22] = SH_PFC_PIN_NONE,
+                [23] = SH_PFC_PIN_NONE,
+                [24] = SH_PFC_PIN_NONE,
+                [25] = SH_PFC_PIN_NONE,
+                [26] = SH_PFC_PIN_NONE,
+                [27] = SH_PFC_PIN_NONE,
+                [28] = SH_PFC_PIN_NONE,
+                [29] = SH_PFC_PIN_NONE,
                 [30] = RCAR_GP_PIN(6,  9),      /* PUEN_USB30_OVC */
                 [31] = RCAR_GP_PIN(6, 17),      /* PUEN_USB30_PWEN */
         } },
diff --git a/drivers/pinctrl/sh-pfc/pfc-r8a77995.c b/drivers/pinctrl/sh-pfc/pfc-r8a77995.c
index dd87085d48cb..c10b756476b1 100644
--- a/drivers/pinctrl/sh-pfc/pfc-r8a77995.c
+++ b/drivers/pinctrl/sh-pfc/pfc-r8a77995.c
@@ -17,7 +17,7 @@
 #include "core.h"
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                   \
+#define CPU_ALL_GP(fn, sfx)                     \
                 PORT_GP_9(0,  fn, sfx),         \
                 PORT_GP_32(1, fn, sfx),         \
                 PORT_GP_32(2, fn, sfx),         \
diff --git a/drivers/pinctrl/sh-pfc/pfc-sh73a0.c b/drivers/pinctrl/sh-pfc/pfc-sh73a0.c
index e1276d143117..afabd95105d5 100644
--- a/drivers/pinctrl/sh-pfc/pfc-sh73a0.c
+++ b/drivers/pinctrl/sh-pfc/pfc-sh73a0.c
@@ -43,6 +43,9 @@
         PORT_1(288, fn, pfx##288, sfx), PORT_1(289, fn, pfx##289, sfx), \
         PORT_10(290, fn, pfx##29, sfx), PORT_10(300, fn, pfx##30, sfx)
 
+#define CPU_ALL_NOGP(fn)        \
+        PIN_NOGP(A11, "F26", fn)
+
 enum {
         PINMUX_RESERVED = 0,
 
@@ -1147,7 +1150,7 @@ static const u16 pinmux_data[] = {
 #define __IO            (SH_PFC_PIN_CFG_INPUT | SH_PFC_PIN_CFG_OUTPUT)
 #define __PD            (SH_PFC_PIN_CFG_PULL_DOWN)
 #define __PU            (SH_PFC_PIN_CFG_PULL_UP)
-#define __PUD           (SH_PFC_PIN_CFG_PULL_DOWN | SH_PFC_PIN_CFG_PULL_UP)
+#define __PUD           (SH_PFC_PIN_CFG_PULL_UP_DOWN)
 
 #define SH73A0_PIN_I_PD(pin)            SH_PFC_PIN_CFG(pin, __I | __PD)
 #define SH73A0_PIN_I_PU(pin)            SH_PFC_PIN_CFG(pin, __I | __PU)
@@ -1158,11 +1161,13 @@ static const u16 pinmux_data[] = {
 #define SH73A0_PIN_IO_PU_PD(pin)        SH_PFC_PIN_CFG(pin, __IO | __PUD)
 #define SH73A0_PIN_O(pin)               SH_PFC_PIN_CFG(pin, __O)
 
-/* Pin numbers for pins without a corresponding GPIO port number are computed
- * from the row and column numbers with a 1000 offset to avoid collisions with
- * GPIO port numbers.
+/*
+ * Pins not associated with a GPIO port.
  */
-#define PIN_NUMBER(row, col)            (1000+((row)-1)*34+(col)-1)
+enum {
+        PORT_ASSIGN_LAST(),
+        NOGP_ALL(),
+};
 
 static const struct sh_pfc_pin pinmux_pins[] = {
         /* Table 25-1 (I/O and Pull U/D) */
@@ -1437,7 +1442,7 @@ static const struct sh_pfc_pin pinmux_pins[] = {
         SH73A0_PIN_O(309),
 
         /* Pins not associated with a GPIO port */
-        SH_PFC_PIN_NAMED(6, 26, F26),
+        PINMUX_NOGP_ALL(),
 };
 
 /* - BSC -------------------------------------------------------------------- */
@@ -1863,7 +1868,7 @@ static const unsigned int keysc_out7_2_mux[] = {
 };
 static const unsigned int keysc_out8_0_pins[] = {
         /* KEYOUT8 */
-        PIN_NUMBER(6, 26),
+        PIN_A11,
 };
 static const unsigned int keysc_out8_0_mux[] = {
         KEYOUT8_MARK,
@@ -3073,7 +3078,7 @@ static const unsigned int tpu4_to2_mux[] = {
 };
 static const unsigned int tpu4_to3_pins[] = {
         /* TO */
-        PIN_NUMBER(6, 26),
+        PIN_A11,
 };
 static const unsigned int tpu4_to3_mux[] = {
         TPU4TO3_MARK,
diff --git a/drivers/pinctrl/sh-pfc/pfc-sh7734.c b/drivers/pinctrl/sh-pfc/pfc-sh7734.c
index fac7b4699121..5dfd991ffdaa 100644
--- a/drivers/pinctrl/sh-pfc/pfc-sh7734.c
+++ b/drivers/pinctrl/sh-pfc/pfc-sh7734.c
@@ -11,7 +11,7 @@
 
 #include "sh_pfc.h"
 
-#define CPU_ALL_PORT(fn, sfx)                                           \
+#define CPU_ALL_GP(fn, sfx)                                             \
         PORT_GP_32(0, fn, sfx),                                         \
         PORT_GP_32(1, fn, sfx),                                         \
         PORT_GP_32(2, fn, sfx),                                         \
diff --git a/drivers/pinctrl/sh-pfc/pinctrl.c b/drivers/pinctrl/sh-pfc/pinctrl.c
index c97d2ba7677c..2824be4eb887 100644
--- a/drivers/pinctrl/sh-pfc/pinctrl.c
+++ b/drivers/pinctrl/sh-pfc/pinctrl.c
@@ -569,8 +569,7 @@ static bool sh_pfc_pinconf_validate(struct sh_pfc *pfc, unsigned int _pin,
 
         switch (param) {
         case PIN_CONFIG_BIAS_DISABLE:
-                return pin->configs &
-                        (SH_PFC_PIN_CFG_PULL_UP | SH_PFC_PIN_CFG_PULL_DOWN);
+                return pin->configs & SH_PFC_PIN_CFG_PULL_UP_DOWN;
 
         case PIN_CONFIG_BIAS_PULL_UP:
                 return pin->configs & SH_PFC_PIN_CFG_PULL_UP;
diff --git a/drivers/pinctrl/sh-pfc/sh_pfc.h b/drivers/pinctrl/sh-pfc/sh_pfc.h
index 7db5819eea7e..835148fc0f28 100644
--- a/drivers/pinctrl/sh-pfc/sh_pfc.h
+++ b/drivers/pinctrl/sh-pfc/sh_pfc.h
@@ -21,10 +21,14 @@ enum {
         PINMUX_TYPE_INPUT,
 };
 
+#define SH_PFC_PIN_NONE                 U16_MAX
+
 #define SH_PFC_PIN_CFG_INPUT            (1 << 0)
 #define SH_PFC_PIN_CFG_OUTPUT           (1 << 1)
 #define SH_PFC_PIN_CFG_PULL_UP          (1 << 2)
 #define SH_PFC_PIN_CFG_PULL_DOWN        (1 << 3)
+#define SH_PFC_PIN_CFG_PULL_UP_DOWN     (SH_PFC_PIN_CFG_PULL_UP | \
+                                         SH_PFC_PIN_CFG_PULL_DOWN)
 #define SH_PFC_PIN_CFG_IO_VOLTAGE       (1 << 4)
 #define SH_PFC_PIN_CFG_DRIVE_STRENGTH   (1 << 5)
 #define SH_PFC_PIN_CFG_NO_GPIO          (1 << 31)
@@ -542,9 +546,13 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
         PORT_GP_CFG_1(bank, 25, fn, sfx, cfg)
 #define PORT_GP_26(bank, fn, sfx)       PORT_GP_CFG_26(bank, fn, sfx, 0)
 
-#define PORT_GP_CFG_28(bank, fn, sfx, cfg)                              \
+#define PORT_GP_CFG_27(bank, fn, sfx, cfg)                              \
         PORT_GP_CFG_26(bank, fn, sfx, cfg),                             \
-        PORT_GP_CFG_1(bank, 26, fn, sfx, cfg),                          \
+        PORT_GP_CFG_1(bank, 26, fn, sfx, cfg)
+#define PORT_GP_27(bank, fn, sfx)       PORT_GP_CFG_27(bank, fn, sfx, 0)
+
+#define PORT_GP_CFG_28(bank, fn, sfx, cfg)                              \
+        PORT_GP_CFG_27(bank, fn, sfx, cfg),                             \
         PORT_GP_CFG_1(bank, 27, fn, sfx, cfg)
 #define PORT_GP_28(bank, fn, sfx)       PORT_GP_CFG_28(bank, fn, sfx, 0)
 
@@ -584,7 +592,7 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
 
 /* GP_ALL(suffix) - Expand to a list of GP_#_#_suffix */
 #define _GP_ALL(bank, pin, name, sfx, cfg)      name##_##sfx
-#define GP_ALL(str)                     CPU_ALL_PORT(_GP_ALL, str)
+#define GP_ALL(str)                     CPU_ALL_GP(_GP_ALL, str)
 
 /* PINMUX_GPIO_GP_ALL - Expand to a list of sh_pfc_pin entries */
 #define _GP_GPIO(bank, _pin, _name, sfx, cfg)                           \
@@ -594,11 +602,29 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
                 .enum_id = _name##_DATA,                                \
                 .configs = cfg,                                         \
         }
-#define PINMUX_GPIO_GP_ALL()            CPU_ALL_PORT(_GP_GPIO, unused)
+#define PINMUX_GPIO_GP_ALL()            CPU_ALL_GP(_GP_GPIO, unused)
 
 /* PINMUX_DATA_GP_ALL -  Expand to a list of name_DATA, name_FN marks */
 #define _GP_DATA(bank, pin, name, sfx, cfg)     PINMUX_DATA(name##_DATA, name##_FN)
-#define PINMUX_DATA_GP_ALL()            CPU_ALL_PORT(_GP_DATA, unused)
+#define PINMUX_DATA_GP_ALL()            CPU_ALL_GP(_GP_DATA, unused)
+
+/*
+ * GP_ASSIGN_LAST() - Expand to an enum definition for the last GP pin
+ *
+ * The largest GP pin index is obtained by taking the size of a union,
+ * containing one array per GP pin, sized by the corresponding pin index.
+ * As the fields in the CPU_ALL_GP() macro definition are separated by commas,
+ * while the members of a union must be terminated by semicolons, the commas
+ * are absorbed by wrapping them inside dummy attributes.
+ */
+#define _GP_ENTRY(bank, pin, name, sfx, cfg)                            \
+        deprecated)); char name[(bank * 32) + pin] __attribute__((deprecated
+#define GP_ASSIGN_LAST()                                                \
+        GP_LAST = sizeof(union {                                        \
+                char dummy[0] __attribute__((deprecated,                \
+                CPU_ALL_GP(_GP_ENTRY, unused),                          \
+                deprecated));                                           \
+        })
 
 /*
  * PORT style (linear pin space)
@@ -641,22 +667,6 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
                 .configs = cfgs,                                        \
         }
 
-/* SH_PFC_PIN_NAMED - Expand to a sh_pfc_pin entry with the given name */
-#define SH_PFC_PIN_NAMED(row, col, _name)                               \
-        {                                                               \
-                .pin = PIN_NUMBER(row, col),                            \
-                .name = __stringify(PIN_##_name),                       \
-                .configs = SH_PFC_PIN_CFG_NO_GPIO,                      \
-        }
-
-/* SH_PFC_PIN_NAMED_CFG - Expand to a sh_pfc_pin entry with the given name */
-#define SH_PFC_PIN_NAMED_CFG(row, col, _name, cfgs)                     \
-        {                                                               \
-                .pin = PIN_NUMBER(row, col),                            \
-                .name = __stringify(PIN_##_name),                       \
-                .configs = SH_PFC_PIN_CFG_NO_GPIO | cfgs,               \
-        }
-
 /* PINMUX_DATA_ALL - Expand to a list of PORT_name_DATA, PORT_name_FN0,
  *                   PORT_name_OUT, PORT_name_IN marks
  */
@@ -665,6 +675,24 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
                     PORT##pfx##_OUT, PORT##pfx##_IN)
 #define PINMUX_DATA_ALL()               CPU_ALL_PORT(_PORT_DATA, , unused)
 
+/*
+ * PORT_ASSIGN_LAST() - Expand to an enum definition for the last PORT pin
+ *
+ * The largest PORT pin index is obtained by taking the size of a union,
+ * containing one array per PORT pin, sized by the corresponding pin index.
+ * As the fields in the CPU_ALL_PORT() macro definition are separated by
+ * commas, while the members of a union must be terminated by semicolons, the
+ * commas are absorbed by wrapping them inside dummy attributes.
+ */
+#define _PORT_ENTRY(pn, pfx, sfx)                                       \
+        deprecated)); char pfx[pn] __attribute__((deprecated
+#define PORT_ASSIGN_LAST()                                              \
+        PORT_LAST = sizeof(union {                                      \
+                char dummy[0] __attribute__((deprecated,                \
+                CPU_ALL_PORT(_PORT_ENTRY, PORT, unused),                \
+                deprecated));                                           \
+        })
+
 /* GPIO_FN(name) - Expand to a sh_pfc_pin entry for a function GPIO */
 #define PINMUX_GPIO_FN(gpio, base, data_or_mark)                        \
         [gpio - (base)] = {                                             \
@@ -675,6 +703,26 @@ extern const struct sh_pfc_soc_info shx3_pinmux_info;
         PINMUX_GPIO_FN(GPIO_FN_##str, PINMUX_FN_BASE, str##_MARK)
 
 /*
+ * Pins not associated with a GPIO port
+ */
+
+#define PIN_NOGP_CFG(pin, name, fn, cfg)        fn(pin, name, cfg)
+#define PIN_NOGP(pin, name, fn)                 fn(pin, name, 0)
+
+/* NOGP_ALL - Expand to a list of PIN_id */
+#define _NOGP_ALL(pin, name, cfg)               PIN_##pin
+#define NOGP_ALL()                              CPU_ALL_NOGP(_NOGP_ALL)
+
+/* PINMUX_NOGP_ALL - Expand to a list of sh_pfc_pin entries */
+#define _NOGP_PINMUX(_pin, _name, cfg)                                  \
+        {                                                               \
+                .pin = PIN_##_pin,                                      \
+                .name = "PIN_" _name,                                   \
+                .configs = SH_PFC_PIN_CFG_NO_GPIO | cfg,                \
+        }
+#define PINMUX_NOGP_ALL()               CPU_ALL_NOGP(_NOGP_PINMUX)
+
+/*
  * PORTnCR helper macro for SH-Mobile/R-Mobile
  */
 #define PORTCR(nr, reg)                                                 \
diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.c b/drivers/pinctrl/stm32/pinctrl-stm32.c
index 2317ccf63321..b453aed1bbeb 100644
--- a/drivers/pinctrl/stm32/pinctrl-stm32.c
+++ b/drivers/pinctrl/stm32/pinctrl-stm32.c
@@ -44,6 +44,18 @@
 #define STM32_GPIO_AFRL         0x20
 #define STM32_GPIO_AFRH         0x24
 
+/* custom bitfield to backup pin status */
+#define STM32_GPIO_BKP_MODE_SHIFT       0
+#define STM32_GPIO_BKP_MODE_MASK        GENMASK(1, 0)
+#define STM32_GPIO_BKP_ALT_SHIFT        2
+#define STM32_GPIO_BKP_ALT_MASK         GENMASK(5, 2)
+#define STM32_GPIO_BKP_SPEED_SHIFT      6
+#define STM32_GPIO_BKP_SPEED_MASK       GENMASK(7, 6)
+#define STM32_GPIO_BKP_PUPD_SHIFT       8
+#define STM32_GPIO_BKP_PUPD_MASK        GENMASK(9, 8)
+#define STM32_GPIO_BKP_TYPE             10
+#define STM32_GPIO_BKP_VAL              11
+
 #define STM32_GPIO_PINS_PER_BANK 16
 #define STM32_GPIO_IRQ_LINE      16
 
@@ -79,6 +91,7 @@ struct stm32_gpio_bank {
         struct irq_domain *domain;
         u32 bank_nr;
         u32 bank_ioport_nr;
+        u32 pin_backup[STM32_GPIO_PINS_PER_BANK];
 };
 
 struct stm32_pinctrl {
@@ -98,6 +111,8 @@ struct stm32_pinctrl {
         struct stm32_desc_pin *pins;
         u32 npins;
         u32 pkg;
+        u16 irqmux_map;
+        spinlock_t irqmux_lock;
 };
 
 static inline int stm32_gpio_pin(int gpio)
@@ -133,11 +148,50 @@ static inline u32 stm32_gpio_get_alt(u32 function)
         return 0;
 }
 
+static void stm32_gpio_backup_value(struct stm32_gpio_bank *bank,
+                                    u32 offset, u32 value)
+{
+        bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_VAL);
+        bank->pin_backup[offset] |= value << STM32_GPIO_BKP_VAL;
+}
+
+static void stm32_gpio_backup_mode(struct stm32_gpio_bank *bank, u32 offset,
+                                   u32 mode, u32 alt)
+{
+        bank->pin_backup[offset] &= ~(STM32_GPIO_BKP_MODE_MASK |
+                                      STM32_GPIO_BKP_ALT_MASK);
+        bank->pin_backup[offset] |= mode << STM32_GPIO_BKP_MODE_SHIFT;
+        bank->pin_backup[offset] |= alt << STM32_GPIO_BKP_ALT_SHIFT;
+}
+
+static void stm32_gpio_backup_driving(struct stm32_gpio_bank *bank, u32 offset,
+                                      u32 drive)
+{
+        bank->pin_backup[offset] &= ~BIT(STM32_GPIO_BKP_TYPE);
+        bank->pin_backup[offset] |= drive << STM32_GPIO_BKP_TYPE;
+}
+
+static void stm32_gpio_backup_speed(struct stm32_gpio_bank *bank, u32 offset,
+                                    u32 speed)
+{
+        bank->pin_backup[offset] &= ~STM32_GPIO_BKP_SPEED_MASK;
+        bank->pin_backup[offset] |= speed << STM32_GPIO_BKP_SPEED_SHIFT;
+}
+
+static void stm32_gpio_backup_bias(struct stm32_gpio_bank *bank, u32 offset,
+                                   u32 bias)
+{
+        bank->pin_backup[offset] &= ~STM32_GPIO_BKP_PUPD_MASK;
+        bank->pin_backup[offset] |= bias << STM32_GPIO_BKP_PUPD_SHIFT;
+}
+
 /* GPIO functions */
 
 static inline void __stm32_gpio_set(struct stm32_gpio_bank *bank,
         unsigned offset, int value)
 {
+        stm32_gpio_backup_value(bank, offset, value);
+
         if (!value)
                 offset += STM32_GPIO_PINS_PER_BANK;
 
@@ -307,9 +361,53 @@ static int stm32_gpio_domain_activate(struct irq_domain *d,
 {
         struct stm32_gpio_bank *bank = d->host_data;
         struct stm32_pinctrl *pctl = dev_get_drvdata(bank->gpio_chip.parent);
+        unsigned long flags;
+        int ret = 0;
+
+        /*
+         * gpio irq mux is shared between several banks, a lock has to be done
+         * to avoid overriding.
+         */
+        spin_lock_irqsave(&pctl->irqmux_lock, flags);
+        if (pctl->hwlock)
+                ret = hwspin_lock_timeout(pctl->hwlock, HWSPINLOCK_TIMEOUT);
+
+        if (ret) {
+                dev_err(pctl->dev, "Can't get hwspinlock\n");
+                goto unlock;
+        }
+
+        if (pctl->irqmux_map & BIT(irq_data->hwirq)) {
+                dev_err(pctl->dev, "irq line %ld already requested.\n",
+                        irq_data->hwirq);
+                ret = -EBUSY;
+                if (pctl->hwlock)
+                        hwspin_unlock(pctl->hwlock);
+                goto unlock;
+        } else {
+                pctl->irqmux_map |= BIT(irq_data->hwirq);
+        }
 
         regmap_field_write(pctl->irqmux[irq_data->hwirq], bank->bank_ioport_nr);
-        return 0;
+
+        if (pctl->hwlock)
+                hwspin_unlock(pctl->hwlock);
+
+unlock:
+        spin_unlock_irqrestore(&pctl->irqmux_lock, flags);
+        return ret;
+}
+
+static void stm32_gpio_domain_deactivate(struct irq_domain *d,
+                                         struct irq_data *irq_data)
+{
+        struct stm32_gpio_bank *bank = d->host_data;
+        struct stm32_pinctrl *pctl = dev_get_drvdata(bank->gpio_chip.parent);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pctl->irqmux_lock, flags);
+        pctl->irqmux_map &= ~BIT(irq_data->hwirq);
+        spin_unlock_irqrestore(&pctl->irqmux_lock, flags);
 }
 
 static int stm32_gpio_domain_alloc(struct irq_domain *d,
@@ -338,6 +436,7 @@ static const struct irq_domain_ops stm32_gpio_domain_ops = {
         .alloc          = stm32_gpio_domain_alloc,
         .free           = irq_domain_free_irqs_common,
         .activate       = stm32_gpio_domain_activate,
+        .deactivate     = stm32_gpio_domain_deactivate,
 };
 
 /* Pinctrl functions */
@@ -620,6 +719,8 @@ static int stm32_pmx_set_mode(struct stm32_gpio_bank *bank,
         if (pctl->hwlock)
                 hwspin_unlock(pctl->hwlock);
 
+        stm32_gpio_backup_mode(bank, pin, mode, alt);
+
 unlock:
         spin_unlock_irqrestore(&bank->lock, flags);
         clk_disable(bank->clk);
@@ -732,6 +833,8 @@ static int stm32_pconf_set_driving(struct stm32_gpio_bank *bank,
         if (pctl->hwlock)
                 hwspin_unlock(pctl->hwlock);
 
+        stm32_gpio_backup_driving(bank, offset, drive);
+
 unlock:
         spin_unlock_irqrestore(&bank->lock, flags);
         clk_disable(bank->clk);
@@ -784,6 +887,8 @@ static int stm32_pconf_set_speed(struct stm32_gpio_bank *bank,
         if (pctl->hwlock)
                 hwspin_unlock(pctl->hwlock);
 
+        stm32_gpio_backup_speed(bank, offset, speed);
+
 unlock:
         spin_unlock_irqrestore(&bank->lock, flags);
         clk_disable(bank->clk);
@@ -836,6 +941,8 @@ static int stm32_pconf_set_bias(struct stm32_gpio_bank *bank,
         if (pctl->hwlock)
                 hwspin_unlock(pctl->hwlock);
 
+        stm32_gpio_backup_bias(bank, offset, bias);
+
 unlock:
         spin_unlock_irqrestore(&bank->lock, flags);
         clk_disable(bank->clk);
@@ -1290,6 +1397,8 @@ int stm32_pctl_probe(struct platform_device *pdev)
                 pctl->hwlock = hwspin_lock_request_specific(hwlock_id);
         }
 
+        spin_lock_init(&pctl->irqmux_lock);
+
         pctl->dev = dev;
         pctl->match_data = match->data;
 
@@ -1329,6 +1438,7 @@ int stm32_pctl_probe(struct platform_device *pdev)
         pctl->pctl_desc.owner = THIS_MODULE;
         pctl->pctl_desc.pins = pins;
         pctl->pctl_desc.npins = pctl->npins;
+        pctl->pctl_desc.link_consumers = true;
         pctl->pctl_desc.confops = &stm32_pconf_ops;
         pctl->pctl_desc.pctlops = &stm32_pctrl_ops;
         pctl->pctl_desc.pmxops = &stm32_pmx_ops;
@@ -1369,3 +1479,75 @@ int stm32_pctl_probe(struct platform_device *pdev)
 
         return 0;
 }
+
+static int __maybe_unused stm32_pinctrl_restore_gpio_regs(
+                                        struct stm32_pinctrl *pctl, u32 pin)
+{
+        const struct pin_desc *desc = pin_desc_get(pctl->pctl_dev, pin);
+        u32 val, alt, mode, offset = stm32_gpio_pin(pin);
+        struct pinctrl_gpio_range *range;
+        struct stm32_gpio_bank *bank;
+        bool pin_is_irq;
+        int ret;
+
+        range = pinctrl_find_gpio_range_from_pin(pctl->pctl_dev, pin);
+        if (!range)
+                return 0;
+
+        pin_is_irq = gpiochip_line_is_irq(range->gc, offset);
+
+        if (!desc || (!pin_is_irq && !desc->gpio_owner))
+                return 0;
+
+        bank = gpiochip_get_data(range->gc);
+
+        alt = bank->pin_backup[offset] & STM32_GPIO_BKP_ALT_MASK;
+        alt >>= STM32_GPIO_BKP_ALT_SHIFT;
+        mode = bank->pin_backup[offset] & STM32_GPIO_BKP_MODE_MASK;
+        mode >>= STM32_GPIO_BKP_MODE_SHIFT;
+
+        ret = stm32_pmx_set_mode(bank, offset, mode, alt);
+        if (ret)
+                return ret;
+
+        if (mode == 1) {
+                val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_VAL);
+                val = val >> STM32_GPIO_BKP_VAL;
+                __stm32_gpio_set(bank, offset, val);
+        }
+
+        val = bank->pin_backup[offset] & BIT(STM32_GPIO_BKP_TYPE);
+        val >>= STM32_GPIO_BKP_TYPE;
+        ret = stm32_pconf_set_driving(bank, offset, val);
+        if (ret)
+                return ret;
+
+        val = bank->pin_backup[offset] & STM32_GPIO_BKP_SPEED_MASK;
+        val >>= STM32_GPIO_BKP_SPEED_SHIFT;
+        ret = stm32_pconf_set_speed(bank, offset, val);
+        if (ret)
+                return ret;
+
+        val = bank->pin_backup[offset] & STM32_GPIO_BKP_PUPD_MASK;
+        val >>= STM32_GPIO_BKP_PUPD_SHIFT;
+        ret = stm32_pconf_set_bias(bank, offset, val);
+        if (ret)
+                return ret;
+
+        if (pin_is_irq)
+                regmap_field_write(pctl->irqmux[offset], bank->bank_ioport_nr);
+
+        return 0;
+}
+
+int __maybe_unused stm32_pinctrl_resume(struct device *dev)
+{
+        struct stm32_pinctrl *pctl = dev_get_drvdata(dev);
+        struct stm32_pinctrl_group *g = pctl->groups;
+        int i;
+
+        for (i = g->pin; i < g->pin + pctl->ngroups; i++)
+                stm32_pinctrl_restore_gpio_regs(pctl, i);
+
+        return 0;
+}
diff --git a/drivers/pinctrl/stm32/pinctrl-stm32.h b/drivers/pinctrl/stm32/pinctrl-stm32.h
index de5e7012ca03..ec0d34c33903 100644
--- a/drivers/pinctrl/stm32/pinctrl-stm32.h
+++ b/drivers/pinctrl/stm32/pinctrl-stm32.h
@@ -65,5 +65,7 @@ struct stm32_gpio_bank;
 int stm32_pctl_probe(struct platform_device *pdev);
 void stm32_pmx_get_mode(struct stm32_gpio_bank *bank,
                         int pin, u32 *mode, u32 *alt);
+int stm32_pinctrl_resume(struct device *dev);
+
 #endif /* __PINCTRL_STM32_H */
 
diff --git a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c
index 320544f69e57..2ccb99d64df8 100644
--- a/drivers/pinctrl/stm32/pinctrl-stm32mp157.c
+++ b/drivers/pinctrl/stm32/pinctrl-stm32mp157.c
@@ -2342,11 +2342,16 @@ static const struct of_device_id stm32mp157_pctrl_match[] = {
         { }
 };
 
+static const struct dev_pm_ops stm32_pinctrl_dev_pm_ops = {
+         SET_LATE_SYSTEM_SLEEP_PM_OPS(NULL, stm32_pinctrl_resume)
+};
+
 static struct platform_driver stm32mp157_pinctrl_driver = {
         .probe = stm32_pctl_probe,
         .driver = {
                 .name = "stm32mp157-pinctrl",
                 .of_match_table = stm32mp157_pctrl_match,
+                .pm = &stm32_pinctrl_dev_pm_ops,
         },
 };
 
diff --git a/drivers/pinctrl/tegra/Kconfig b/drivers/pinctrl/tegra/Kconfig
index 5906a856be38..a67d0d9ae8cd 100644
--- a/drivers/pinctrl/tegra/Kconfig
+++ b/drivers/pinctrl/tegra/Kconfig
@@ -24,6 +24,10 @@ config PINCTRL_TEGRA210
         bool
         select PINCTRL_TEGRA
 
+config PINCTRL_TEGRA194
+        bool
+        select PINCTRL_TEGRA
+
 config PINCTRL_TEGRA_XUSB
         def_bool y if ARCH_TEGRA
         select GENERIC_PHY
diff --git a/drivers/pinctrl/tegra/Makefile b/drivers/pinctrl/tegra/Makefile
index bbcb043c34a2..ead4e10097d0 100644
--- a/drivers/pinctrl/tegra/Makefile
+++ b/drivers/pinctrl/tegra/Makefile
@@ -5,4 +5,5 @@ obj-$(CONFIG_PINCTRL_TEGRA30)		+= pinctrl-tegra30.o
 obj-$(CONFIG_PINCTRL_TEGRA114)          += pinctrl-tegra114.o
 obj-$(CONFIG_PINCTRL_TEGRA124)          += pinctrl-tegra124.o
 obj-$(CONFIG_PINCTRL_TEGRA210)          += pinctrl-tegra210.o
+obj-$(CONFIG_PINCTRL_TEGRA194)          += pinctrl-tegra194.o
 obj-$(CONFIG_PINCTRL_TEGRA_XUSB)        += pinctrl-tegra-xusb.o
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra.c b/drivers/pinctrl/tegra/pinctrl-tegra.c
index abcfbad94f00..186ef98e7b2b 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra.c
@@ -284,7 +284,7 @@ static int tegra_pinconf_reg(struct tegra_pmx *pmx,
                              const struct tegra_pingroup *g,
                              enum tegra_pinconf_param param,
                              bool report_err,
-                             s8 *bank, s16 *reg, s8 *bit, s8 *width)
+                             s8 *bank, s32 *reg, s8 *bit, s8 *width)
 {
         switch (param) {
         case TEGRA_PINCONF_PARAM_PULL:
@@ -443,7 +443,7 @@ static int tegra_pinconf_group_get(struct pinctrl_dev *pctldev,
         const struct tegra_pingroup *g;
         int ret;
         s8 bank, bit, width;
-        s16 reg;
+        s32 reg;
         u32 val, mask;
 
         g = &pmx->soc->groups[group];
@@ -472,7 +472,7 @@ static int tegra_pinconf_group_set(struct pinctrl_dev *pctldev,
         const struct tegra_pingroup *g;
         int ret, i;
         s8 bank, bit, width;
-        s16 reg;
+        s32 reg;
         u32 val, mask;
 
         g = &pmx->soc->groups[group];
@@ -540,7 +540,7 @@ static void tegra_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
         const struct tegra_pingroup *g;
         int i, ret;
         s8 bank, bit, width;
-        s16 reg;
+        s32 reg;
         u32 val;
 
         g = &pmx->soc->groups[group];
@@ -613,10 +613,20 @@ static void tegra_pinctrl_clear_parked_bits(struct tegra_pmx *pmx)
 
         for (i = 0; i < pmx->soc->ngroups; ++i) {
                 g = &pmx->soc->groups[i];
-                if (g->parked_bit >= 0) {
-                        val = pmx_readl(pmx, g->mux_bank, g->mux_reg);
-                        val &= ~(1 << g->parked_bit);
-                        pmx_writel(pmx, val, g->mux_bank, g->mux_reg);
+                if (g->parked_bitmask > 0) {
+                        unsigned int bank, reg;
+
+                        if (g->mux_reg != -1) {
+                                bank = g->mux_bank;
+                                reg = g->mux_reg;
+                        } else {
+                                bank = g->drv_bank;
+                                reg = g->drv_reg;
+                        }
+
+                        val = pmx_readl(pmx, bank, reg);
+                        val &= ~g->parked_bitmask;
+                        pmx_writel(pmx, val, bank, reg);
                 }
         }
 }
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra.h b/drivers/pinctrl/tegra/pinctrl-tegra.h
index 9b5a71624fd0..105309774079 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra.h
+++ b/drivers/pinctrl/tegra/pinctrl-tegra.h
@@ -96,7 +96,6 @@ struct tegra_function {
  * @tri_reg:            Tri-state register offset.
  * @tri_bank:           Tri-state register bank.
  * @tri_bit:            Tri-state register bit.
- * @parked_bit:         Parked register bit. -1 if unsupported.
  * @einput_bit:         Enable-input register bit.
  * @odrain_bit:         Open-drain register bit.
  * @lock_bit:           Lock register bit.
@@ -118,6 +117,7 @@ struct tegra_function {
  * @slwf_bit:           Slew Falling register bit.
  * @slwf_width:         Slew Falling field width.
  * @drvtype_bit:        Drive type register bit.
+ * @parked_bitmask:     Parked register mask. 0 if unsupported.
  *
  * -1 in a *_reg field means that feature is unsupported for this group.
  * *_bank and *_reg values are irrelevant when *_reg is -1.
@@ -135,10 +135,10 @@ struct tegra_pingroup {
         const unsigned *pins;
         u8 npins;
         u8 funcs[4];
-        s16 mux_reg;
-        s16 pupd_reg;
-        s16 tri_reg;
-        s16 drv_reg;
+        s32 mux_reg;
+        s32 pupd_reg;
+        s32 tri_reg;
+        s32 drv_reg;
         u32 mux_bank:2;
         u32 pupd_bank:2;
         u32 tri_bank:2;
@@ -146,7 +146,6 @@ struct tegra_pingroup {
         s32 mux_bit:6;
         s32 pupd_bit:6;
         s32 tri_bit:6;
-        s32 parked_bit:6;
         s32 einput_bit:6;
         s32 odrain_bit:6;
         s32 lock_bit:6;
@@ -164,6 +163,7 @@ struct tegra_pingroup {
         s32 drvup_width:6;
         s32 slwr_width:6;
         s32 slwf_width:6;
+        u32 parked_bitmask;
 };
 
 /**
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra114.c b/drivers/pinctrl/tegra/pinctrl-tegra114.c
index 762151f17a88..e72ab1eb2398 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra114.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra114.c
@@ -1572,8 +1572,8 @@ static struct tegra_function tegra114_functions[] = {
                 .lock_bit = 7,                                          \
                 .ioreset_bit = PINGROUP_BIT_##ior(8),                   \
                 .rcv_sel_bit = PINGROUP_BIT_##rcv_sel(9),               \
-                .parked_bit = -1,                                       \
                 .drv_reg = -1,                                          \
+                .parked_bitmask = 0,                                    \
         }
 
 #define DRV_PINGROUP(pg_name, r, hsm_b, schmitt_b, lpmd_b, drvdn_b,     \
@@ -1593,7 +1593,6 @@ static struct tegra_function tegra114_functions[] = {
                 .rcv_sel_bit = -1,                                      \
                 .drv_reg = DRV_PINGROUP_REG(r),                         \
                 .drv_bank = 0,                                          \
-                .parked_bit = -1,                                       \
                 .hsm_bit = hsm_b,                                       \
                 .schmitt_bit = schmitt_b,                               \
                 .lpmd_bit = lpmd_b,                                     \
@@ -1606,6 +1605,7 @@ static struct tegra_function tegra114_functions[] = {
                 .slwf_bit = slwf_b,                                     \
                 .slwf_width = slwf_w,                                   \
                 .drvtype_bit = PINGROUP_BIT_##drvtype(6),               \
+                .parked_bitmask = 0,                                    \
         }
 
 static const struct tegra_pingroup tegra114_groups[] = {
@@ -1831,7 +1831,7 @@ static const struct tegra_pingroup tegra114_groups[] = {
 
 static const struct tegra_pinctrl_soc_data tegra114_pinctrl = {
         .ngpios = NUM_GPIOS,
-        .gpio_compatible = "nvidia,tegra30-gpio",
+        .gpio_compatible = "nvidia,tegra114-gpio",
         .pins = tegra114_pins,
         .npins = ARRAY_SIZE(tegra114_pins),
         .functions = tegra114_functions,
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra124.c b/drivers/pinctrl/tegra/pinctrl-tegra124.c
index 930c43758c92..26096c6b967e 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra124.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra124.c
@@ -1741,8 +1741,8 @@ static struct tegra_function tegra124_functions[] = {
                 .lock_bit = 7,                                          \
                 .ioreset_bit = PINGROUP_BIT_##ior(8),                   \
                 .rcv_sel_bit = PINGROUP_BIT_##rcv_sel(9),               \
-                .parked_bit = -1,                                       \
                 .drv_reg = -1,                                          \
+                .parked_bitmask = 0,                                    \
         }
 
 #define DRV_PINGROUP(pg_name, r, hsm_b, schmitt_b, lpmd_b, drvdn_b,     \
@@ -1762,7 +1762,6 @@ static struct tegra_function tegra124_functions[] = {
                 .rcv_sel_bit = -1,                                      \
                 .drv_reg = DRV_PINGROUP_REG(r),                         \
                 .drv_bank = 0,                                          \
-                .parked_bit = -1,                                       \
                 .hsm_bit = hsm_b,                                       \
                 .schmitt_bit = schmitt_b,                               \
                 .lpmd_bit = lpmd_b,                                     \
@@ -1775,6 +1774,7 @@ static struct tegra_function tegra124_functions[] = {
                 .slwf_bit = slwf_b,                                     \
                 .slwf_width = slwf_w,                                   \
                 .drvtype_bit = PINGROUP_BIT_##drvtype(6),               \
+                .parked_bitmask = 0,                                    \
         }
 
 #define MIPI_PAD_CTRL_PINGROUP(pg_name, r, b, f0, f1)                   \
@@ -2043,7 +2043,7 @@ static const struct tegra_pingroup tegra124_groups[] = {
 
 static const struct tegra_pinctrl_soc_data tegra124_pinctrl = {
         .ngpios = NUM_GPIOS,
-        .gpio_compatible = "nvidia,tegra30-gpio",
+        .gpio_compatible = "nvidia,tegra124-gpio",
         .pins = tegra124_pins,
         .npins = ARRAY_SIZE(tegra124_pins),
         .functions = tegra124_functions,
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra194.c b/drivers/pinctrl/tegra/pinctrl-tegra194.c
new file mode 100644
index 000000000000..daf44cf240c9
--- /dev/null
+++ b/drivers/pinctrl/tegra/pinctrl-tegra194.c
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Pinctrl data for the NVIDIA Tegra194 pinmux
+ *
+ * Copyright (c) 2019, 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.
+ */
+
+#include <linux/init.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/pinctrl/pinmux.h>
+
+#include "pinctrl-tegra.h"
+
+/* Define unique ID for each pins */
+enum pin_id {
+        TEGRA_PIN_PEX_L5_CLKREQ_N_PGG0 = 256,
+        TEGRA_PIN_PEX_L5_RST_N_PGG1 = 257,
+        TEGRA_PIN_NUM_GPIOS = 258,
+};
+
+/* Table for pin descriptor */
+static const struct pinctrl_pin_desc tegra194_pins[] = {
+        PINCTRL_PIN(TEGRA_PIN_PEX_L5_CLKREQ_N_PGG0,
+                    "TEGRA_PIN_PEX_L5_CLKREQ_N_PGG0"),
+        PINCTRL_PIN(TEGRA_PIN_PEX_L5_RST_N_PGG1,
+                    "TEGRA_PIN_PEX_L5_RST_N_PGG1"),
+};
+
+static const unsigned int pex_l5_clkreq_n_pgg0_pins[] = {
+        TEGRA_PIN_PEX_L5_CLKREQ_N_PGG0,
+};
+
+static const unsigned int pex_l5_rst_n_pgg1_pins[] = {
+        TEGRA_PIN_PEX_L5_RST_N_PGG1,
+};
+
+/* Define unique ID for each function */
+enum tegra_mux_dt {
+        TEGRA_MUX_RSVD0,
+        TEGRA_MUX_RSVD1,
+        TEGRA_MUX_RSVD2,
+        TEGRA_MUX_RSVD3,
+        TEGRA_MUX_PE5,
+};
+
+/* Make list of each function name */
+#define TEGRA_PIN_FUNCTION(lid)                 \
+        {                                       \
+                .name = #lid,                   \
+        }
+static struct tegra_function tegra194_functions[] = {
+        TEGRA_PIN_FUNCTION(rsvd0),
+        TEGRA_PIN_FUNCTION(rsvd1),
+        TEGRA_PIN_FUNCTION(rsvd2),
+        TEGRA_PIN_FUNCTION(rsvd3),
+        TEGRA_PIN_FUNCTION(pe5),
+};
+
+#define DRV_PINGROUP_ENTRY_Y(r, drvdn_b, drvdn_w, drvup_b,      \
+                             drvup_w, slwr_b, slwr_w, slwf_b,   \
+                             slwf_w, bank)                      \
+                .drv_reg = ((r)),                       \
+                .drv_bank = bank,                               \
+                .drvdn_bit = drvdn_b,                           \
+                .drvdn_width = drvdn_w,                         \
+                .drvup_bit = drvup_b,                           \
+                .drvup_width = drvup_w,                         \
+                .slwr_bit = slwr_b,                             \
+                .slwr_width = slwr_w,                           \
+                .slwf_bit = slwf_b,                             \
+                .slwf_width = slwf_w
+
+#define PIN_PINGROUP_ENTRY_Y(r, bank, pupd, e_lpbk, e_input,    \
+                             e_od, schmitt_b, drvtype)          \
+                .mux_reg = ((r)),                               \
+                .lpmd_bit = -1,                                 \
+                .lock_bit = -1,                                 \
+                .hsm_bit = -1,                                  \
+                .mux_bank = bank,                               \
+                .mux_bit = 0,                                   \
+                .pupd_reg = ((r)),              \
+                .pupd_bank = bank,                              \
+                .pupd_bit = 2,                                  \
+                .tri_reg = ((r)),                               \
+                .tri_bank = bank,                               \
+                .tri_bit = 4,                                   \
+                .einput_bit = e_input,                          \
+                .odrain_bit = e_od,                             \
+                .schmitt_bit = schmitt_b,                       \
+                .drvtype_bit = 13,                              \
+                .drv_reg = -1,                                  \
+                .parked_bitmask = 0
+
+#define drive_pex_l5_clkreq_n_pgg0                              \
+        DRV_PINGROUP_ENTRY_Y(0x14004, 12, 5, 20, 5, -1, -1, -1, -1, 0)
+#define drive_pex_l5_rst_n_pgg1                                 \
+        DRV_PINGROUP_ENTRY_Y(0x1400c, 12, 5, 20, 5, -1, -1, -1, -1, 0)
+
+#define PINGROUP(pg_name, f0, f1, f2, f3, r, bank, pupd, e_lpbk,        \
+                 e_input, e_lpdr, e_od, schmitt_b, drvtype, io_rail)    \
+        {                                                       \
+                .name = #pg_name,                               \
+                .pins = pg_name##_pins,                         \
+                .npins = ARRAY_SIZE(pg_name##_pins),            \
+                        .funcs = {                              \
+                                TEGRA_MUX_##f0,                 \
+                                TEGRA_MUX_##f1,                 \
+                                TEGRA_MUX_##f2,                 \
+                                TEGRA_MUX_##f3,                 \
+                        },                                      \
+                PIN_PINGROUP_ENTRY_Y(r, bank, pupd, e_lpbk,     \
+                                     e_input, e_od,             \
+                                     schmitt_b, drvtype),       \
+                drive_##pg_name,                                \
+        }
+
+static const struct tegra_pingroup tegra194_groups[] = {
+        PINGROUP(pex_l5_clkreq_n_pgg0, PE5, RSVD1, RSVD2, RSVD3, 0x14000, 0,
+                 Y, -1, 6, 8, 11, 12, N, "vddio_pex_ctl_2"),
+        PINGROUP(pex_l5_rst_n_pgg1, PE5, RSVD1, RSVD2, RSVD3, 0x14008, 0,
+                 Y, -1, 6, 8, 11, 12, N, "vddio_pex_ctl_2"),
+};
+
+static const struct tegra_pinctrl_soc_data tegra194_pinctrl = {
+        .ngpios = TEGRA_PIN_NUM_GPIOS,
+        .pins = tegra194_pins,
+        .npins = ARRAY_SIZE(tegra194_pins),
+        .functions = tegra194_functions,
+        .nfunctions = ARRAY_SIZE(tegra194_functions),
+        .groups = tegra194_groups,
+        .ngroups = ARRAY_SIZE(tegra194_groups),
+        .hsm_in_mux = true,
+        .schmitt_in_mux = true,
+        .drvtype_in_mux = true,
+};
+
+static int tegra194_pinctrl_probe(struct platform_device *pdev)
+{
+        return tegra_pinctrl_probe(pdev, &tegra194_pinctrl);
+}
+
+static const struct of_device_id tegra194_pinctrl_of_match[] = {
+        { .compatible = "nvidia,tegra194-pinmux", },
+        { },
+};
+
+static struct platform_driver tegra194_pinctrl_driver = {
+        .driver = {
+                .name = "tegra194-pinctrl",
+                .of_match_table = tegra194_pinctrl_of_match,
+        },
+        .probe = tegra194_pinctrl_probe,
+};
+
+static int __init tegra194_pinctrl_init(void)
+{
+        return platform_driver_register(&tegra194_pinctrl_driver);
+}
+arch_initcall(tegra194_pinctrl_init);
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra20.c b/drivers/pinctrl/tegra/pinctrl-tegra20.c
index 4b7837e38fb5..0dc2cf0d05b1 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra20.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra20.c
@@ -1989,13 +1989,13 @@ static struct tegra_function tegra20_functions[] = {
                 .tri_reg = ((tri_r) - TRISTATE_REG_A),          \
                 .tri_bank = 0,                                  \
                 .tri_bit = tri_b,                               \
-                .parked_bit = -1,                               \
                 .einput_bit = -1,                               \
                 .odrain_bit = -1,                               \
                 .lock_bit = -1,                                 \
                 .ioreset_bit = -1,                              \
                 .rcv_sel_bit = -1,                              \
                 .drv_reg = -1,                                  \
+                .parked_bitmask = 0,                            \
         }
 
 /* Pin groups with only pull up and pull down control */
@@ -2009,7 +2009,7 @@ static struct tegra_function tegra20_functions[] = {
                 .pupd_bank = 2,                                 \
                 .pupd_bit = pupd_b,                             \
                 .drv_reg = -1,                                  \
-                .parked_bit = -1,                               \
+                .parked_bitmask = 0,                            \
         }
 
 /* Pin groups for drive strength registers (configurable version) */
@@ -2025,7 +2025,7 @@ static struct tegra_function tegra20_functions[] = {
                 .tri_reg = -1,                                  \
                 .drv_reg = ((r) - PINGROUP_REG_A),              \
                 .drv_bank = 3,                                  \
-                .parked_bit = -1,                               \
+                .parked_bitmask = 0,                            \
                 .hsm_bit = hsm_b,                               \
                 .schmitt_bit = schmitt_b,                       \
                 .lpmd_bit = lpmd_b,                             \
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra210.c b/drivers/pinctrl/tegra/pinctrl-tegra210.c
index 0b56ad5c9c1c..39ab6480a941 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra210.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra210.c
@@ -1302,7 +1302,6 @@ static struct tegra_function tegra210_functions[] = {
                 .lock_bit = 7,                                          \
                 .ioreset_bit = -1,                                      \
                 .rcv_sel_bit = PINGROUP_BIT_##e_io_hv(10),              \
-                .parked_bit = 5,                                        \
                 .hsm_bit = PINGROUP_BIT_##hsm(9),                       \
                 .schmitt_bit = 12,                                      \
                 .drvtype_bit = PINGROUP_BIT_##drvtype(13),              \
@@ -1317,10 +1316,11 @@ static struct tegra_function tegra210_functions[] = {
                 .slwr_width = slwr_w,                                   \
                 .slwf_bit = slwf_b,                                     \
                 .slwf_width = slwf_w,                                   \
+                .parked_bitmask = BIT(5),                               \
         }
 
-#define DRV_PINGROUP(pg_name, r, drvdn_b, drvdn_w, drvup_b, drvup_w,    \
-                     slwr_b, slwr_w, slwf_b, slwf_w)                    \
+#define DRV_PINGROUP(pg_name, r, prk_mask, drvdn_b, drvdn_w, drvup_b,   \
+                     drvup_w, slwr_b, slwr_w, slwf_b, slwf_w)           \
         {                                                               \
                 .name = "drive_" #pg_name,                              \
                 .pins = drive_##pg_name##_pins,                         \
@@ -1335,7 +1335,6 @@ static struct tegra_function tegra210_functions[] = {
                 .rcv_sel_bit = -1,                                      \
                 .drv_reg = DRV_PINGROUP_REG(r),                         \
                 .drv_bank = 0,                                          \
-                .parked_bit = -1,                                       \
                 .hsm_bit = -1,                                          \
                 .schmitt_bit = -1,                                      \
                 .lpmd_bit = -1,                                         \
@@ -1348,6 +1347,7 @@ static struct tegra_function tegra210_functions[] = {
                 .slwf_bit = slwf_b,                                     \
                 .slwf_width = slwf_w,                                   \
                 .drvtype_bit = -1,                                      \
+                .parked_bitmask = prk_mask,                             \
         }
 
 static const struct tegra_pingroup tegra210_groups[] = {
@@ -1515,37 +1515,37 @@ static const struct tegra_pingroup tegra210_groups[] = {
         PINGROUP(pz4,                  SDMMC1,     RSVD1,  RSVD2, RSVD3, 0x328c, N,   N,       N,       -1,    -1,      -1,      -1,      -1,      -1,     -1,     -1,     -1),
         PINGROUP(pz5,                  SOC,        RSVD1,  RSVD2, RSVD3, 0x3290, N,   N,       N,       -1,    -1,      -1,      -1,      -1,      -1,     -1,     -1,     -1),
 
-        /* pg_name, r, drvdn_b, drvdn_w, drvup_b, drvup_w, slwr_b, slwr_w, slwf_b, slwf_w */
-        DRV_PINGROUP(pa6,    0x9c0, 12, 5,  20, 5,  -1, -1, -1, -1),
-        DRV_PINGROUP(pcc7,   0x9c4, 12, 5,  20, 5,  -1, -1, -1, -1),
-        DRV_PINGROUP(pe6,    0x9c8, 12, 5,  20, 5,  -1, -1, -1, -1),
-        DRV_PINGROUP(pe7,    0x9cc, 12, 5,  20, 5,  -1, -1, -1, -1),
-        DRV_PINGROUP(ph6,    0x9d0, 12, 5,  20, 5,  -1, -1, -1, -1),
-        DRV_PINGROUP(pk0,    0x9d4, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk1,    0x9d8, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk2,    0x9dc, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk3,    0x9e0, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk4,    0x9e4, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk5,    0x9e8, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk6,    0x9ec, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pk7,    0x9f0, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pl0,    0x9f4, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pl1,    0x9f8, -1, -1, -1, -1, 28, 2,  30, 2),
-        DRV_PINGROUP(pz0,    0x9fc, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(pz1,    0xa00, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(pz2,    0xa04, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(pz3,    0xa08, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(pz4,    0xa0c, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(pz5,    0xa10, 12, 7,  20, 7,  -1, -1, -1, -1),
-        DRV_PINGROUP(sdmmc1, 0xa98, 12, 7,  20, 7,  28, 2,  30, 2),
-        DRV_PINGROUP(sdmmc2, 0xa9c, 2,  6,  8,  6,  28, 2,  30, 2),
-        DRV_PINGROUP(sdmmc3, 0xab0, 12, 7,  20, 7,  28, 2,  30, 2),
-        DRV_PINGROUP(sdmmc4, 0xab4, 2,  6,  8,  6,  28, 2,  30, 2),
+        /* pg_name, r, prk_mask, drvdn_b, drvdn_w, drvup_b, drvup_w, slwr_b, slwr_w, slwf_b, slwf_w */
+        DRV_PINGROUP(pa6,    0x9c0, 0x0,       12, 5,  20, 5,  -1, -1, -1, -1),
+        DRV_PINGROUP(pcc7,   0x9c4, 0x0,       12, 5,  20, 5,  -1, -1, -1, -1),
+        DRV_PINGROUP(pe6,    0x9c8, 0x0,       12, 5,  20, 5,  -1, -1, -1, -1),
+        DRV_PINGROUP(pe7,    0x9cc, 0x0,       12, 5,  20, 5,  -1, -1, -1, -1),
+        DRV_PINGROUP(ph6,    0x9d0, 0x0,       12, 5,  20, 5,  -1, -1, -1, -1),
+        DRV_PINGROUP(pk0,    0x9d4, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk1,    0x9d8, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk2,    0x9dc, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk3,    0x9e0, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk4,    0x9e4, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk5,    0x9e8, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk6,    0x9ec, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pk7,    0x9f0, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pl0,    0x9f4, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pl1,    0x9f8, 0x0,       -1, -1, -1, -1, 28, 2,  30, 2),
+        DRV_PINGROUP(pz0,    0x9fc, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(pz1,    0xa00, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(pz2,    0xa04, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(pz3,    0xa08, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(pz4,    0xa0c, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(pz5,    0xa10, 0x0,       12, 7,  20, 7,  -1, -1, -1, -1),
+        DRV_PINGROUP(sdmmc1, 0xa98, 0x0,       12, 7,  20, 7,  28, 2,  30, 2),
+        DRV_PINGROUP(sdmmc2, 0xa9c, 0x7ffc000, 2,  6,  8,  6,  28, 2,  30, 2),
+        DRV_PINGROUP(sdmmc3, 0xab0, 0x0,       12, 7,  20, 7,  28, 2,  30, 2),
+        DRV_PINGROUP(sdmmc4, 0xab4, 0x7ffc000, 2,  6,  8,  6,  28, 2,  30, 2),
 };
 
 static const struct tegra_pinctrl_soc_data tegra210_pinctrl = {
         .ngpios = NUM_GPIOS,
-        .gpio_compatible = "nvidia,tegra30-gpio",
+        .gpio_compatible = "nvidia,tegra210-gpio",
         .pins = tegra210_pins,
         .npins = ARRAY_SIZE(tegra210_pins),
         .functions = tegra210_functions,
diff --git a/drivers/pinctrl/tegra/pinctrl-tegra30.c b/drivers/pinctrl/tegra/pinctrl-tegra30.c
index 610124c3d192..7299a371827f 100644
--- a/drivers/pinctrl/tegra/pinctrl-tegra30.c
+++ b/drivers/pinctrl/tegra/pinctrl-tegra30.c
@@ -2133,8 +2133,8 @@ static struct tegra_function tegra30_functions[] = {
                 .lock_bit = 7,                                          \
                 .ioreset_bit = PINGROUP_BIT_##ior(8),                   \
                 .rcv_sel_bit = -1,                                      \
-                .parked_bit = -1,                                       \
                 .drv_reg = -1,                                          \
+                .parked_bitmask = 0,                                    \
         }
 
 #define DRV_PINGROUP(pg_name, r, hsm_b, schmitt_b, lpmd_b, drvdn_b,     \
@@ -2154,7 +2154,6 @@ static struct tegra_function tegra30_functions[] = {
                 .rcv_sel_bit = -1,                                      \
                 .drv_reg = DRV_PINGROUP_REG(r),                         \
                 .drv_bank = 0,                                          \
-                .parked_bit = -1,                                       \
                 .hsm_bit = hsm_b,                                       \
                 .schmitt_bit = schmitt_b,                               \
                 .lpmd_bit = lpmd_b,                                     \
@@ -2167,6 +2166,7 @@ static struct tegra_function tegra30_functions[] = {
                 .slwf_bit = slwf_b,                                     \
                 .slwf_width = slwf_w,                                   \
                 .drvtype_bit = -1,                                      \
+                .parked_bitmask = 0,                                    \
         }
 
 static const struct tegra_pingroup tegra30_groups[] = {
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 39745b8bdd65..40915b461f18 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -106,6 +106,7 @@ void devm_gpio_free(struct device *dev, unsigned int gpio);
 
 struct device;
 struct gpio_chip;
+struct pinctrl_dev;
 
 static inline bool gpio_is_valid(int number)
 {
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index 8d58386aadd5..6a0e420915a3 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -586,6 +586,8 @@ void gpiochip_remove_pin_ranges(struct gpio_chip *chip);
 
 #else /* ! CONFIG_PINCTRL */
 
+struct pinctrl_dev;
+
 static inline int
 gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
                        unsigned int gpio_offset, unsigned int pin_offset,
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index 6f260c1d3467..6aeb711f7cd1 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -11,6 +11,12 @@
 #ifndef __LINUX_PINCTRL_PINCONF_GENERIC_H
 #define __LINUX_PINCTRL_PINCONF_GENERIC_H
 
+#include <linux/device.h>
+#include <linux/pinctrl/machine.h>
+
+struct pinctrl_dev;
+struct pinctrl_map;
+
 /**
  * enum pin_config_param - possible pin configuration parameters
  * @PIN_CONFIG_BIAS_BUS_HOLD: the pin will be set to weakly latch so that it
@@ -54,6 +60,8 @@
  *      push-pull mode, the argument is ignored.
  * @PIN_CONFIG_DRIVE_STRENGTH: the pin will sink or source at most the current
  *      passed as argument. The argument is in mA.
+ * @PIN_CONFIG_DRIVE_STRENGTH_UA: the pin will sink or source at most the current
+ *      passed as argument. The argument is in uA.
  * @PIN_CONFIG_INPUT_DEBOUNCE: this will configure the pin to debounce mode,
  *      which means it will wait for signals to settle when reading inputs. The
  *      argument gives the debounce time in usecs. Setting the
@@ -111,6 +119,7 @@ enum pin_config_param {
         PIN_CONFIG_DRIVE_OPEN_SOURCE,
         PIN_CONFIG_DRIVE_PUSH_PULL,
         PIN_CONFIG_DRIVE_STRENGTH,
+        PIN_CONFIG_DRIVE_STRENGTH_UA,
         PIN_CONFIG_INPUT_DEBOUNCE,
         PIN_CONFIG_INPUT_ENABLE,
         PIN_CONFIG_INPUT_SCHMITT,
@@ -155,9 +164,6 @@ static inline unsigned long pinconf_to_config_packed(enum pin_config_param param
         return PIN_CONF_PACKED(param, argument);
 }
 
-#ifdef CONFIG_GENERIC_PINCONF
-
-#ifdef CONFIG_DEBUG_FS
 #define PCONFDUMP(a, b, c, d) {                                 \
         .param = a, .display = b, .format = c, .has_arg = d     \
         }
@@ -168,14 +174,6 @@ struct pin_config_item {
         const char * const format;
         bool has_arg;
 };
-#endif /* CONFIG_DEBUG_FS */
-
-#ifdef CONFIG_OF
-
-#include <linux/device.h>
-#include <linux/pinctrl/machine.h>
-struct pinctrl_dev;
-struct pinctrl_map;
 
 struct pinconf_generic_params {
         const char * const property;
@@ -220,8 +218,5 @@ static inline int pinconf_generic_dt_node_to_map_all(
         return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
                         PIN_MAP_TYPE_INVALID);
 }
-#endif
-
-#endif /* CONFIG_GENERIC_PINCONF */
 
 #endif /* __LINUX_PINCTRL_PINCONF_GENERIC_H */
diff --git a/include/linux/pinctrl/pinconf.h b/include/linux/pinctrl/pinconf.h
index 514414a5ad01..f8a8215e9021 100644
--- a/include/linux/pinctrl/pinconf.h
+++ b/include/linux/pinctrl/pinconf.h
@@ -11,7 +11,7 @@
 #ifndef __LINUX_PINCTRL_PINCONF_H
 #define __LINUX_PINCTRL_PINCONF_H
 
-#ifdef CONFIG_PINCONF
+#include <linux/types.h>
 
 struct pinctrl_dev;
 struct seq_file;
@@ -64,6 +64,4 @@ struct pinconf_ops {
                                             unsigned long config);
 };
 
-#endif
-
 #endif /* __LINUX_PINCTRL_PINCONF_H */
diff --git a/include/linux/pinctrl/pinctrl-state.h b/include/linux/pinctrl/pinctrl-state.h
index a0e785815a64..635d97e9285e 100644
--- a/include/linux/pinctrl/pinctrl-state.h
+++ b/include/linux/pinctrl/pinctrl-state.h
@@ -3,6 +3,9 @@
  * Standard pin control state definitions
  */
 
+#ifndef __LINUX_PINCTRL_PINCTRL_STATE_H
+#define __LINUX_PINCTRL_PINCTRL_STATE_H
+
 /**
  * @PINCTRL_STATE_DEFAULT: the state the pinctrl handle shall be put
  *      into as default, usually this means the pins are up and ready to
@@ -31,3 +34,5 @@
 #define PINCTRL_STATE_INIT "init"
 #define PINCTRL_STATE_IDLE "idle"
 #define PINCTRL_STATE_SLEEP "sleep"
+
+#endif /* __LINUX_PINCTRL_PINCTRL_STATE_H */
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index e429e5d92dd6..7ce23450a1cb 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -11,8 +11,6 @@
 #ifndef __LINUX_PINCTRL_PINCTRL_H
 #define __LINUX_PINCTRL_PINCTRL_H
 
-#ifdef CONFIG_PINCTRL
-
 #include <linux/radix-tree.h>
 #include <linux/list.h>
 #include <linux/seq_file.h>
@@ -124,6 +122,10 @@ struct pinctrl_ops {
  *      the hardware description
  * @custom_conf_items: Information how to print @params in debugfs, must be
  *      the same size as the @custom_params, i.e. @num_custom_params
+ * @link_consumers: If true create a device link between pinctrl and its
+ *      consumers (i.e. the devices requesting pin control states). This is
+ *      sometimes necessary to ascertain the right suspend/resume order for
+ *      example.
  */
 struct pinctrl_desc {
         const char *name;
@@ -138,6 +140,7 @@ struct pinctrl_desc {
         const struct pinconf_generic_params *custom_params;
         const struct pin_config_item *custom_conf_items;
 #endif
+        bool link_consumers;
 };
 
 /* External interface to pin controller */
@@ -166,7 +169,6 @@ extern struct pinctrl_dev *devm_pinctrl_register(struct device *dev,
 extern void devm_pinctrl_unregister(struct device *dev,
                                 struct pinctrl_dev *pctldev);
 
-extern bool pin_is_valid(struct pinctrl_dev *pctldev, int pin);
 extern void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
                                 struct pinctrl_gpio_range *range);
 extern void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
@@ -197,16 +199,5 @@ struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
 extern const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev);
 extern const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev);
 extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
-#else
-
-struct pinctrl_dev;
-
-/* Sufficiently stupid default functions when pinctrl is not in use */
-static inline bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
-{
-        return pin >= 0;
-}
-
-#endif /* !CONFIG_PINCTRL */
 
 #endif /* __LINUX_PINCTRL_PINCTRL_H */
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index e873ed97d79e..9a647fa5c8f1 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -15,8 +15,6 @@
 #include <linux/seq_file.h>
 #include <linux/pinctrl/pinctrl.h>
 
-#ifdef CONFIG_PINMUX
-
 struct pinctrl_dev;
 
 /**
@@ -84,6 +82,4 @@ struct pinmux_ops {
         bool strict;
 };
 
-#endif /* CONFIG_PINMUX */
-
 #endif /* __LINUX_PINCTRL_PINMUX_H */