root/drivers/pinctrl/spear/pinctrl-spear1310.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. spear1310_pinctrl_probe
  2. spear1310_pinctrl_init

   1 /*
   2  * Driver for the ST Microelectronics SPEAr1310 pinmux
   3  *
   4  * Copyright (C) 2012 ST Microelectronics
   5  * Viresh Kumar <vireshk@kernel.org>
   6  *
   7  * This file is licensed under the terms of the GNU General Public
   8  * License version 2. This program is licensed "as is" without any
   9  * warranty of any kind, whether express or implied.
  10  */
  11 
  12 #include <linux/err.h>
  13 #include <linux/init.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include "pinctrl-spear.h"
  17 
  18 #define DRIVER_NAME "spear1310-pinmux"
  19 
  20 /* pins */
  21 static const struct pinctrl_pin_desc spear1310_pins[] = {
  22         SPEAR_PIN_0_TO_101,
  23         SPEAR_PIN_102_TO_245,
  24 };
  25 
  26 /* registers */
  27 #define PERIP_CFG                                       0x3B0
  28         #define MCIF_SEL_SHIFT                          5
  29         #define MCIF_SEL_SD                             (0x1 << MCIF_SEL_SHIFT)
  30         #define MCIF_SEL_CF                             (0x2 << MCIF_SEL_SHIFT)
  31         #define MCIF_SEL_XD                             (0x3 << MCIF_SEL_SHIFT)
  32         #define MCIF_SEL_MASK                           (0x3 << MCIF_SEL_SHIFT)
  33 
  34 #define PCIE_SATA_CFG                                   0x3A4
  35         #define PCIE_SATA2_SEL_PCIE                     (0 << 31)
  36         #define PCIE_SATA1_SEL_PCIE                     (0 << 30)
  37         #define PCIE_SATA0_SEL_PCIE                     (0 << 29)
  38         #define PCIE_SATA2_SEL_SATA                     (1 << 31)
  39         #define PCIE_SATA1_SEL_SATA                     (1 << 30)
  40         #define PCIE_SATA0_SEL_SATA                     (1 << 29)
  41         #define SATA2_CFG_TX_CLK_EN                     (1 << 27)
  42         #define SATA2_CFG_RX_CLK_EN                     (1 << 26)
  43         #define SATA2_CFG_POWERUP_RESET                 (1 << 25)
  44         #define SATA2_CFG_PM_CLK_EN                     (1 << 24)
  45         #define SATA1_CFG_TX_CLK_EN                     (1 << 23)
  46         #define SATA1_CFG_RX_CLK_EN                     (1 << 22)
  47         #define SATA1_CFG_POWERUP_RESET                 (1 << 21)
  48         #define SATA1_CFG_PM_CLK_EN                     (1 << 20)
  49         #define SATA0_CFG_TX_CLK_EN                     (1 << 19)
  50         #define SATA0_CFG_RX_CLK_EN                     (1 << 18)
  51         #define SATA0_CFG_POWERUP_RESET                 (1 << 17)
  52         #define SATA0_CFG_PM_CLK_EN                     (1 << 16)
  53         #define PCIE2_CFG_DEVICE_PRESENT                (1 << 11)
  54         #define PCIE2_CFG_POWERUP_RESET                 (1 << 10)
  55         #define PCIE2_CFG_CORE_CLK_EN                   (1 << 9)
  56         #define PCIE2_CFG_AUX_CLK_EN                    (1 << 8)
  57         #define PCIE1_CFG_DEVICE_PRESENT                (1 << 7)
  58         #define PCIE1_CFG_POWERUP_RESET                 (1 << 6)
  59         #define PCIE1_CFG_CORE_CLK_EN                   (1 << 5)
  60         #define PCIE1_CFG_AUX_CLK_EN                    (1 << 4)
  61         #define PCIE0_CFG_DEVICE_PRESENT                (1 << 3)
  62         #define PCIE0_CFG_POWERUP_RESET                 (1 << 2)
  63         #define PCIE0_CFG_CORE_CLK_EN                   (1 << 1)
  64         #define PCIE0_CFG_AUX_CLK_EN                    (1 << 0)
  65 
  66 #define PAD_FUNCTION_EN_0                               0x650
  67         #define PMX_UART0_MASK                          (1 << 1)
  68         #define PMX_I2C0_MASK                           (1 << 2)
  69         #define PMX_I2S0_MASK                           (1 << 3)
  70         #define PMX_SSP0_MASK                           (1 << 4)
  71         #define PMX_CLCD1_MASK                          (1 << 5)
  72         #define PMX_EGPIO00_MASK                        (1 << 6)
  73         #define PMX_EGPIO01_MASK                        (1 << 7)
  74         #define PMX_EGPIO02_MASK                        (1 << 8)
  75         #define PMX_EGPIO03_MASK                        (1 << 9)
  76         #define PMX_EGPIO04_MASK                        (1 << 10)
  77         #define PMX_EGPIO05_MASK                        (1 << 11)
  78         #define PMX_EGPIO06_MASK                        (1 << 12)
  79         #define PMX_EGPIO07_MASK                        (1 << 13)
  80         #define PMX_EGPIO08_MASK                        (1 << 14)
  81         #define PMX_EGPIO09_MASK                        (1 << 15)
  82         #define PMX_SMI_MASK                            (1 << 16)
  83         #define PMX_NAND8_MASK                          (1 << 17)
  84         #define PMX_GMIICLK_MASK                        (1 << 18)
  85         #define PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK    (1 << 19)
  86         #define PMX_RXCLK_RDV_TXEN_D03_MASK             (1 << 20)
  87         #define PMX_GMIID47_MASK                        (1 << 21)
  88         #define PMX_MDC_MDIO_MASK                       (1 << 22)
  89         #define PMX_MCI_DATA8_15_MASK                   (1 << 23)
  90         #define PMX_NFAD23_MASK                         (1 << 24)
  91         #define PMX_NFAD24_MASK                         (1 << 25)
  92         #define PMX_NFAD25_MASK                         (1 << 26)
  93         #define PMX_NFCE3_MASK                          (1 << 27)
  94         #define PMX_NFWPRT3_MASK                        (1 << 28)
  95         #define PMX_NFRSTPWDWN0_MASK                    (1 << 29)
  96         #define PMX_NFRSTPWDWN1_MASK                    (1 << 30)
  97         #define PMX_NFRSTPWDWN2_MASK                    (1 << 31)
  98 
  99 #define PAD_FUNCTION_EN_1                               0x654
 100         #define PMX_NFRSTPWDWN3_MASK                    (1 << 0)
 101         #define PMX_SMINCS2_MASK                        (1 << 1)
 102         #define PMX_SMINCS3_MASK                        (1 << 2)
 103         #define PMX_CLCD2_MASK                          (1 << 3)
 104         #define PMX_KBD_ROWCOL68_MASK                   (1 << 4)
 105         #define PMX_EGPIO10_MASK                        (1 << 5)
 106         #define PMX_EGPIO11_MASK                        (1 << 6)
 107         #define PMX_EGPIO12_MASK                        (1 << 7)
 108         #define PMX_EGPIO13_MASK                        (1 << 8)
 109         #define PMX_EGPIO14_MASK                        (1 << 9)
 110         #define PMX_EGPIO15_MASK                        (1 << 10)
 111         #define PMX_UART0_MODEM_MASK                    (1 << 11)
 112         #define PMX_GPT0_TMR0_MASK                      (1 << 12)
 113         #define PMX_GPT0_TMR1_MASK                      (1 << 13)
 114         #define PMX_GPT1_TMR0_MASK                      (1 << 14)
 115         #define PMX_GPT1_TMR1_MASK                      (1 << 15)
 116         #define PMX_I2S1_MASK                           (1 << 16)
 117         #define PMX_KBD_ROWCOL25_MASK                   (1 << 17)
 118         #define PMX_NFIO8_15_MASK                       (1 << 18)
 119         #define PMX_KBD_COL1_MASK                       (1 << 19)
 120         #define PMX_NFCE1_MASK                          (1 << 20)
 121         #define PMX_KBD_COL0_MASK                       (1 << 21)
 122         #define PMX_NFCE2_MASK                          (1 << 22)
 123         #define PMX_KBD_ROW1_MASK                       (1 << 23)
 124         #define PMX_NFWPRT1_MASK                        (1 << 24)
 125         #define PMX_KBD_ROW0_MASK                       (1 << 25)
 126         #define PMX_NFWPRT2_MASK                        (1 << 26)
 127         #define PMX_MCIDATA0_MASK                       (1 << 27)
 128         #define PMX_MCIDATA1_MASK                       (1 << 28)
 129         #define PMX_MCIDATA2_MASK                       (1 << 29)
 130         #define PMX_MCIDATA3_MASK                       (1 << 30)
 131         #define PMX_MCIDATA4_MASK                       (1 << 31)
 132 
 133 #define PAD_FUNCTION_EN_2                               0x658
 134         #define PMX_MCIDATA5_MASK                       (1 << 0)
 135         #define PMX_MCIDATA6_MASK                       (1 << 1)
 136         #define PMX_MCIDATA7_MASK                       (1 << 2)
 137         #define PMX_MCIDATA1SD_MASK                     (1 << 3)
 138         #define PMX_MCIDATA2SD_MASK                     (1 << 4)
 139         #define PMX_MCIDATA3SD_MASK                     (1 << 5)
 140         #define PMX_MCIADDR0ALE_MASK                    (1 << 6)
 141         #define PMX_MCIADDR1CLECLK_MASK                 (1 << 7)
 142         #define PMX_MCIADDR2_MASK                       (1 << 8)
 143         #define PMX_MCICECF_MASK                        (1 << 9)
 144         #define PMX_MCICEXD_MASK                        (1 << 10)
 145         #define PMX_MCICESDMMC_MASK                     (1 << 11)
 146         #define PMX_MCICDCF1_MASK                       (1 << 12)
 147         #define PMX_MCICDCF2_MASK                       (1 << 13)
 148         #define PMX_MCICDXD_MASK                        (1 << 14)
 149         #define PMX_MCICDSDMMC_MASK                     (1 << 15)
 150         #define PMX_MCIDATADIR_MASK                     (1 << 16)
 151         #define PMX_MCIDMARQWP_MASK                     (1 << 17)
 152         #define PMX_MCIIORDRE_MASK                      (1 << 18)
 153         #define PMX_MCIIOWRWE_MASK                      (1 << 19)
 154         #define PMX_MCIRESETCF_MASK                     (1 << 20)
 155         #define PMX_MCICS0CE_MASK                       (1 << 21)
 156         #define PMX_MCICFINTR_MASK                      (1 << 22)
 157         #define PMX_MCIIORDY_MASK                       (1 << 23)
 158         #define PMX_MCICS1_MASK                         (1 << 24)
 159         #define PMX_MCIDMAACK_MASK                      (1 << 25)
 160         #define PMX_MCISDCMD_MASK                       (1 << 26)
 161         #define PMX_MCILEDS_MASK                        (1 << 27)
 162         #define PMX_TOUCH_XY_MASK                       (1 << 28)
 163         #define PMX_SSP0_CS0_MASK                       (1 << 29)
 164         #define PMX_SSP0_CS1_2_MASK                     (1 << 30)
 165 
 166 #define PAD_DIRECTION_SEL_0                             0x65C
 167 #define PAD_DIRECTION_SEL_1                             0x660
 168 #define PAD_DIRECTION_SEL_2                             0x664
 169 
 170 /* combined macros */
 171 #define PMX_GMII_MASK           (PMX_GMIICLK_MASK |                     \
 172                                 PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK |  \
 173                                 PMX_RXCLK_RDV_TXEN_D03_MASK |           \
 174                                 PMX_GMIID47_MASK | PMX_MDC_MDIO_MASK)
 175 
 176 #define PMX_EGPIO_0_GRP_MASK    (PMX_EGPIO00_MASK | PMX_EGPIO01_MASK |  \
 177                                 PMX_EGPIO02_MASK |                      \
 178                                 PMX_EGPIO03_MASK | PMX_EGPIO04_MASK |   \
 179                                 PMX_EGPIO05_MASK | PMX_EGPIO06_MASK |   \
 180                                 PMX_EGPIO07_MASK | PMX_EGPIO08_MASK |   \
 181                                 PMX_EGPIO09_MASK)
 182 #define PMX_EGPIO_1_GRP_MASK    (PMX_EGPIO10_MASK | PMX_EGPIO11_MASK |  \
 183                                 PMX_EGPIO12_MASK | PMX_EGPIO13_MASK |   \
 184                                 PMX_EGPIO14_MASK | PMX_EGPIO15_MASK)
 185 
 186 #define PMX_KEYBOARD_6X6_MASK   (PMX_KBD_ROW0_MASK | PMX_KBD_ROW1_MASK | \
 187                                 PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL0_MASK | \
 188                                 PMX_KBD_COL1_MASK)
 189 
 190 #define PMX_NAND8BIT_0_MASK     (PMX_NAND8_MASK | PMX_NFAD23_MASK |     \
 191                                 PMX_NFAD24_MASK | PMX_NFAD25_MASK |     \
 192                                 PMX_NFWPRT3_MASK | PMX_NFRSTPWDWN0_MASK | \
 193                                 PMX_NFRSTPWDWN1_MASK | PMX_NFRSTPWDWN2_MASK | \
 194                                 PMX_NFCE3_MASK)
 195 #define PMX_NAND8BIT_1_MASK     PMX_NFRSTPWDWN3_MASK
 196 
 197 #define PMX_NAND16BIT_1_MASK    (PMX_KBD_ROWCOL25_MASK | PMX_NFIO8_15_MASK)
 198 #define PMX_NAND_4CHIPS_MASK    (PMX_NFCE1_MASK | PMX_NFCE2_MASK |      \
 199                                 PMX_NFWPRT1_MASK | PMX_NFWPRT2_MASK |   \
 200                                 PMX_KBD_ROW0_MASK | PMX_KBD_ROW1_MASK | \
 201                                 PMX_KBD_COL0_MASK | PMX_KBD_COL1_MASK)
 202 
 203 #define PMX_MCIFALL_1_MASK      0xF8000000
 204 #define PMX_MCIFALL_2_MASK      0x0FFFFFFF
 205 
 206 #define PMX_PCI_REG1_MASK       (PMX_SMINCS2_MASK | PMX_SMINCS3_MASK |  \
 207                                 PMX_CLCD2_MASK | PMX_KBD_ROWCOL68_MASK | \
 208                                 PMX_EGPIO_1_GRP_MASK | PMX_GPT0_TMR0_MASK | \
 209                                 PMX_GPT0_TMR1_MASK | PMX_GPT1_TMR0_MASK | \
 210                                 PMX_GPT1_TMR1_MASK | PMX_I2S1_MASK |    \
 211                                 PMX_NFCE2_MASK)
 212 #define PMX_PCI_REG2_MASK       (PMX_TOUCH_XY_MASK | PMX_SSP0_CS0_MASK | \
 213                                 PMX_SSP0_CS1_2_MASK)
 214 
 215 #define PMX_SMII_0_1_2_MASK     (PMX_CLCD2_MASK | PMX_KBD_ROWCOL68_MASK)
 216 #define PMX_RGMII_REG0_MASK     (PMX_MCI_DATA8_15_MASK |                \
 217                                 PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK |  \
 218                                 PMX_GMIID47_MASK)
 219 #define PMX_RGMII_REG1_MASK     (PMX_KBD_ROWCOL68_MASK | PMX_EGPIO_1_GRP_MASK |\
 220                                 PMX_KBD_ROW1_MASK | PMX_NFWPRT1_MASK |  \
 221                                 PMX_KBD_ROW0_MASK | PMX_NFWPRT2_MASK)
 222 #define PMX_RGMII_REG2_MASK     (PMX_TOUCH_XY_MASK | PMX_SSP0_CS0_MASK | \
 223                                 PMX_SSP0_CS1_2_MASK)
 224 
 225 #define PCIE_CFG_VAL(x)         (PCIE_SATA##x##_SEL_PCIE |      \
 226                                 PCIE##x##_CFG_AUX_CLK_EN |      \
 227                                 PCIE##x##_CFG_CORE_CLK_EN |     \
 228                                 PCIE##x##_CFG_POWERUP_RESET |   \
 229                                 PCIE##x##_CFG_DEVICE_PRESENT)
 230 #define SATA_CFG_VAL(x)         (PCIE_SATA##x##_SEL_SATA |      \
 231                                 SATA##x##_CFG_PM_CLK_EN |       \
 232                                 SATA##x##_CFG_POWERUP_RESET |   \
 233                                 SATA##x##_CFG_RX_CLK_EN |       \
 234                                 SATA##x##_CFG_TX_CLK_EN)
 235 
 236 /* Pad multiplexing for i2c0 device */
 237 static const unsigned i2c0_pins[] = { 102, 103 };
 238 static struct spear_muxreg i2c0_muxreg[] = {
 239         {
 240                 .reg = PAD_FUNCTION_EN_0,
 241                 .mask = PMX_I2C0_MASK,
 242                 .val = PMX_I2C0_MASK,
 243         }, {
 244                 .reg = PAD_DIRECTION_SEL_0,
 245                 .mask = PMX_I2C0_MASK,
 246                 .val = PMX_I2C0_MASK,
 247         },
 248 };
 249 
 250 static struct spear_modemux i2c0_modemux[] = {
 251         {
 252                 .muxregs = i2c0_muxreg,
 253                 .nmuxregs = ARRAY_SIZE(i2c0_muxreg),
 254         },
 255 };
 256 
 257 static struct spear_pingroup i2c0_pingroup = {
 258         .name = "i2c0_grp",
 259         .pins = i2c0_pins,
 260         .npins = ARRAY_SIZE(i2c0_pins),
 261         .modemuxs = i2c0_modemux,
 262         .nmodemuxs = ARRAY_SIZE(i2c0_modemux),
 263 };
 264 
 265 static const char *const i2c0_grps[] = { "i2c0_grp" };
 266 static struct spear_function i2c0_function = {
 267         .name = "i2c0",
 268         .groups = i2c0_grps,
 269         .ngroups = ARRAY_SIZE(i2c0_grps),
 270 };
 271 
 272 /* Pad multiplexing for ssp0 device */
 273 static const unsigned ssp0_pins[] = { 109, 110, 111, 112 };
 274 static struct spear_muxreg ssp0_muxreg[] = {
 275         {
 276                 .reg = PAD_FUNCTION_EN_0,
 277                 .mask = PMX_SSP0_MASK,
 278                 .val = PMX_SSP0_MASK,
 279         }, {
 280                 .reg = PAD_DIRECTION_SEL_0,
 281                 .mask = PMX_SSP0_MASK,
 282                 .val = PMX_SSP0_MASK,
 283         },
 284 };
 285 
 286 static struct spear_modemux ssp0_modemux[] = {
 287         {
 288                 .muxregs = ssp0_muxreg,
 289                 .nmuxregs = ARRAY_SIZE(ssp0_muxreg),
 290         },
 291 };
 292 
 293 static struct spear_pingroup ssp0_pingroup = {
 294         .name = "ssp0_grp",
 295         .pins = ssp0_pins,
 296         .npins = ARRAY_SIZE(ssp0_pins),
 297         .modemuxs = ssp0_modemux,
 298         .nmodemuxs = ARRAY_SIZE(ssp0_modemux),
 299 };
 300 
 301 /* Pad multiplexing for ssp0_cs0 device */
 302 static const unsigned ssp0_cs0_pins[] = { 96 };
 303 static struct spear_muxreg ssp0_cs0_muxreg[] = {
 304         {
 305                 .reg = PAD_FUNCTION_EN_2,
 306                 .mask = PMX_SSP0_CS0_MASK,
 307                 .val = PMX_SSP0_CS0_MASK,
 308         }, {
 309                 .reg = PAD_DIRECTION_SEL_2,
 310                 .mask = PMX_SSP0_CS0_MASK,
 311                 .val = PMX_SSP0_CS0_MASK,
 312         },
 313 };
 314 
 315 static struct spear_modemux ssp0_cs0_modemux[] = {
 316         {
 317                 .muxregs = ssp0_cs0_muxreg,
 318                 .nmuxregs = ARRAY_SIZE(ssp0_cs0_muxreg),
 319         },
 320 };
 321 
 322 static struct spear_pingroup ssp0_cs0_pingroup = {
 323         .name = "ssp0_cs0_grp",
 324         .pins = ssp0_cs0_pins,
 325         .npins = ARRAY_SIZE(ssp0_cs0_pins),
 326         .modemuxs = ssp0_cs0_modemux,
 327         .nmodemuxs = ARRAY_SIZE(ssp0_cs0_modemux),
 328 };
 329 
 330 /* ssp0_cs1_2 device */
 331 static const unsigned ssp0_cs1_2_pins[] = { 94, 95 };
 332 static struct spear_muxreg ssp0_cs1_2_muxreg[] = {
 333         {
 334                 .reg = PAD_FUNCTION_EN_2,
 335                 .mask = PMX_SSP0_CS1_2_MASK,
 336                 .val = PMX_SSP0_CS1_2_MASK,
 337         }, {
 338                 .reg = PAD_DIRECTION_SEL_2,
 339                 .mask = PMX_SSP0_CS1_2_MASK,
 340                 .val = PMX_SSP0_CS1_2_MASK,
 341         },
 342 };
 343 
 344 static struct spear_modemux ssp0_cs1_2_modemux[] = {
 345         {
 346                 .muxregs = ssp0_cs1_2_muxreg,
 347                 .nmuxregs = ARRAY_SIZE(ssp0_cs1_2_muxreg),
 348         },
 349 };
 350 
 351 static struct spear_pingroup ssp0_cs1_2_pingroup = {
 352         .name = "ssp0_cs1_2_grp",
 353         .pins = ssp0_cs1_2_pins,
 354         .npins = ARRAY_SIZE(ssp0_cs1_2_pins),
 355         .modemuxs = ssp0_cs1_2_modemux,
 356         .nmodemuxs = ARRAY_SIZE(ssp0_cs1_2_modemux),
 357 };
 358 
 359 static const char *const ssp0_grps[] = { "ssp0_grp", "ssp0_cs0_grp",
 360         "ssp0_cs1_2_grp" };
 361 static struct spear_function ssp0_function = {
 362         .name = "ssp0",
 363         .groups = ssp0_grps,
 364         .ngroups = ARRAY_SIZE(ssp0_grps),
 365 };
 366 
 367 /* Pad multiplexing for i2s0 device */
 368 static const unsigned i2s0_pins[] = { 104, 105, 106, 107, 108 };
 369 static struct spear_muxreg i2s0_muxreg[] = {
 370         {
 371                 .reg = PAD_FUNCTION_EN_0,
 372                 .mask = PMX_I2S0_MASK,
 373                 .val = PMX_I2S0_MASK,
 374         }, {
 375                 .reg = PAD_DIRECTION_SEL_0,
 376                 .mask = PMX_I2S0_MASK,
 377                 .val = PMX_I2S0_MASK,
 378         },
 379 };
 380 
 381 static struct spear_modemux i2s0_modemux[] = {
 382         {
 383                 .muxregs = i2s0_muxreg,
 384                 .nmuxregs = ARRAY_SIZE(i2s0_muxreg),
 385         },
 386 };
 387 
 388 static struct spear_pingroup i2s0_pingroup = {
 389         .name = "i2s0_grp",
 390         .pins = i2s0_pins,
 391         .npins = ARRAY_SIZE(i2s0_pins),
 392         .modemuxs = i2s0_modemux,
 393         .nmodemuxs = ARRAY_SIZE(i2s0_modemux),
 394 };
 395 
 396 static const char *const i2s0_grps[] = { "i2s0_grp" };
 397 static struct spear_function i2s0_function = {
 398         .name = "i2s0",
 399         .groups = i2s0_grps,
 400         .ngroups = ARRAY_SIZE(i2s0_grps),
 401 };
 402 
 403 /* Pad multiplexing for i2s1 device */
 404 static const unsigned i2s1_pins[] = { 0, 1, 2, 3 };
 405 static struct spear_muxreg i2s1_muxreg[] = {
 406         {
 407                 .reg = PAD_FUNCTION_EN_1,
 408                 .mask = PMX_I2S1_MASK,
 409                 .val = PMX_I2S1_MASK,
 410         }, {
 411                 .reg = PAD_DIRECTION_SEL_1,
 412                 .mask = PMX_I2S1_MASK,
 413                 .val = PMX_I2S1_MASK,
 414         },
 415 };
 416 
 417 static struct spear_modemux i2s1_modemux[] = {
 418         {
 419                 .muxregs = i2s1_muxreg,
 420                 .nmuxregs = ARRAY_SIZE(i2s1_muxreg),
 421         },
 422 };
 423 
 424 static struct spear_pingroup i2s1_pingroup = {
 425         .name = "i2s1_grp",
 426         .pins = i2s1_pins,
 427         .npins = ARRAY_SIZE(i2s1_pins),
 428         .modemuxs = i2s1_modemux,
 429         .nmodemuxs = ARRAY_SIZE(i2s1_modemux),
 430 };
 431 
 432 static const char *const i2s1_grps[] = { "i2s1_grp" };
 433 static struct spear_function i2s1_function = {
 434         .name = "i2s1",
 435         .groups = i2s1_grps,
 436         .ngroups = ARRAY_SIZE(i2s1_grps),
 437 };
 438 
 439 /* Pad multiplexing for clcd device */
 440 static const unsigned clcd_pins[] = { 113, 114, 115, 116, 117, 118, 119, 120,
 441         121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
 442         135, 136, 137, 138, 139, 140, 141, 142 };
 443 static struct spear_muxreg clcd_muxreg[] = {
 444         {
 445                 .reg = PAD_FUNCTION_EN_0,
 446                 .mask = PMX_CLCD1_MASK,
 447                 .val = PMX_CLCD1_MASK,
 448         }, {
 449                 .reg = PAD_DIRECTION_SEL_0,
 450                 .mask = PMX_CLCD1_MASK,
 451                 .val = PMX_CLCD1_MASK,
 452         },
 453 };
 454 
 455 static struct spear_modemux clcd_modemux[] = {
 456         {
 457                 .muxregs = clcd_muxreg,
 458                 .nmuxregs = ARRAY_SIZE(clcd_muxreg),
 459         },
 460 };
 461 
 462 static struct spear_pingroup clcd_pingroup = {
 463         .name = "clcd_grp",
 464         .pins = clcd_pins,
 465         .npins = ARRAY_SIZE(clcd_pins),
 466         .modemuxs = clcd_modemux,
 467         .nmodemuxs = ARRAY_SIZE(clcd_modemux),
 468 };
 469 
 470 static const unsigned clcd_high_res_pins[] = { 30, 31, 32, 33, 34, 35, 36, 37,
 471         38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 };
 472 static struct spear_muxreg clcd_high_res_muxreg[] = {
 473         {
 474                 .reg = PAD_FUNCTION_EN_1,
 475                 .mask = PMX_CLCD2_MASK,
 476                 .val = PMX_CLCD2_MASK,
 477         }, {
 478                 .reg = PAD_DIRECTION_SEL_1,
 479                 .mask = PMX_CLCD2_MASK,
 480                 .val = PMX_CLCD2_MASK,
 481         },
 482 };
 483 
 484 static struct spear_modemux clcd_high_res_modemux[] = {
 485         {
 486                 .muxregs = clcd_high_res_muxreg,
 487                 .nmuxregs = ARRAY_SIZE(clcd_high_res_muxreg),
 488         },
 489 };
 490 
 491 static struct spear_pingroup clcd_high_res_pingroup = {
 492         .name = "clcd_high_res_grp",
 493         .pins = clcd_high_res_pins,
 494         .npins = ARRAY_SIZE(clcd_high_res_pins),
 495         .modemuxs = clcd_high_res_modemux,
 496         .nmodemuxs = ARRAY_SIZE(clcd_high_res_modemux),
 497 };
 498 
 499 static const char *const clcd_grps[] = { "clcd_grp", "clcd_high_res_grp" };
 500 static struct spear_function clcd_function = {
 501         .name = "clcd",
 502         .groups = clcd_grps,
 503         .ngroups = ARRAY_SIZE(clcd_grps),
 504 };
 505 
 506 static const unsigned arm_gpio_pins[] = { 18, 19, 20, 21, 22, 23, 143, 144, 145,
 507         146, 147, 148, 149, 150, 151, 152 };
 508 static struct spear_muxreg arm_gpio_muxreg[] = {
 509         {
 510                 .reg = PAD_FUNCTION_EN_0,
 511                 .mask = PMX_EGPIO_0_GRP_MASK,
 512                 .val = PMX_EGPIO_0_GRP_MASK,
 513         }, {
 514                 .reg = PAD_FUNCTION_EN_1,
 515                 .mask = PMX_EGPIO_1_GRP_MASK,
 516                 .val = PMX_EGPIO_1_GRP_MASK,
 517         }, {
 518                 .reg = PAD_DIRECTION_SEL_0,
 519                 .mask = PMX_EGPIO_0_GRP_MASK,
 520                 .val = PMX_EGPIO_0_GRP_MASK,
 521         }, {
 522                 .reg = PAD_DIRECTION_SEL_1,
 523                 .mask = PMX_EGPIO_1_GRP_MASK,
 524                 .val = PMX_EGPIO_1_GRP_MASK,
 525         },
 526 };
 527 
 528 static struct spear_modemux arm_gpio_modemux[] = {
 529         {
 530                 .muxregs = arm_gpio_muxreg,
 531                 .nmuxregs = ARRAY_SIZE(arm_gpio_muxreg),
 532         },
 533 };
 534 
 535 static struct spear_pingroup arm_gpio_pingroup = {
 536         .name = "arm_gpio_grp",
 537         .pins = arm_gpio_pins,
 538         .npins = ARRAY_SIZE(arm_gpio_pins),
 539         .modemuxs = arm_gpio_modemux,
 540         .nmodemuxs = ARRAY_SIZE(arm_gpio_modemux),
 541 };
 542 
 543 static const char *const arm_gpio_grps[] = { "arm_gpio_grp" };
 544 static struct spear_function arm_gpio_function = {
 545         .name = "arm_gpio",
 546         .groups = arm_gpio_grps,
 547         .ngroups = ARRAY_SIZE(arm_gpio_grps),
 548 };
 549 
 550 /* Pad multiplexing for smi 2 chips device */
 551 static const unsigned smi_2_chips_pins[] = { 153, 154, 155, 156, 157 };
 552 static struct spear_muxreg smi_2_chips_muxreg[] = {
 553         {
 554                 .reg = PAD_FUNCTION_EN_0,
 555                 .mask = PMX_SMI_MASK,
 556                 .val = PMX_SMI_MASK,
 557         }, {
 558                 .reg = PAD_DIRECTION_SEL_0,
 559                 .mask = PMX_SMI_MASK,
 560                 .val = PMX_SMI_MASK,
 561         },
 562 };
 563 
 564 static struct spear_modemux smi_2_chips_modemux[] = {
 565         {
 566                 .muxregs = smi_2_chips_muxreg,
 567                 .nmuxregs = ARRAY_SIZE(smi_2_chips_muxreg),
 568         },
 569 };
 570 
 571 static struct spear_pingroup smi_2_chips_pingroup = {
 572         .name = "smi_2_chips_grp",
 573         .pins = smi_2_chips_pins,
 574         .npins = ARRAY_SIZE(smi_2_chips_pins),
 575         .modemuxs = smi_2_chips_modemux,
 576         .nmodemuxs = ARRAY_SIZE(smi_2_chips_modemux),
 577 };
 578 
 579 static const unsigned smi_4_chips_pins[] = { 54, 55 };
 580 static struct spear_muxreg smi_4_chips_muxreg[] = {
 581         {
 582                 .reg = PAD_FUNCTION_EN_0,
 583                 .mask = PMX_SMI_MASK,
 584                 .val = PMX_SMI_MASK,
 585         }, {
 586                 .reg = PAD_FUNCTION_EN_1,
 587                 .mask = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
 588                 .val = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
 589         }, {
 590                 .reg = PAD_DIRECTION_SEL_0,
 591                 .mask = PMX_SMI_MASK,
 592                 .val = PMX_SMI_MASK,
 593         }, {
 594                 .reg = PAD_DIRECTION_SEL_1,
 595                 .mask = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
 596                 .val = PMX_SMINCS2_MASK | PMX_SMINCS3_MASK,
 597         },
 598 };
 599 
 600 static struct spear_modemux smi_4_chips_modemux[] = {
 601         {
 602                 .muxregs = smi_4_chips_muxreg,
 603                 .nmuxregs = ARRAY_SIZE(smi_4_chips_muxreg),
 604         },
 605 };
 606 
 607 static struct spear_pingroup smi_4_chips_pingroup = {
 608         .name = "smi_4_chips_grp",
 609         .pins = smi_4_chips_pins,
 610         .npins = ARRAY_SIZE(smi_4_chips_pins),
 611         .modemuxs = smi_4_chips_modemux,
 612         .nmodemuxs = ARRAY_SIZE(smi_4_chips_modemux),
 613 };
 614 
 615 static const char *const smi_grps[] = { "smi_2_chips_grp", "smi_4_chips_grp" };
 616 static struct spear_function smi_function = {
 617         .name = "smi",
 618         .groups = smi_grps,
 619         .ngroups = ARRAY_SIZE(smi_grps),
 620 };
 621 
 622 /* Pad multiplexing for gmii device */
 623 static const unsigned gmii_pins[] = { 173, 174, 175, 176, 177, 178, 179, 180,
 624         181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
 625         195, 196, 197, 198, 199, 200 };
 626 static struct spear_muxreg gmii_muxreg[] = {
 627         {
 628                 .reg = PAD_FUNCTION_EN_0,
 629                 .mask = PMX_GMII_MASK,
 630                 .val = PMX_GMII_MASK,
 631         }, {
 632                 .reg = PAD_DIRECTION_SEL_0,
 633                 .mask = PMX_GMII_MASK,
 634                 .val = PMX_GMII_MASK,
 635         },
 636 };
 637 
 638 static struct spear_modemux gmii_modemux[] = {
 639         {
 640                 .muxregs = gmii_muxreg,
 641                 .nmuxregs = ARRAY_SIZE(gmii_muxreg),
 642         },
 643 };
 644 
 645 static struct spear_pingroup gmii_pingroup = {
 646         .name = "gmii_grp",
 647         .pins = gmii_pins,
 648         .npins = ARRAY_SIZE(gmii_pins),
 649         .modemuxs = gmii_modemux,
 650         .nmodemuxs = ARRAY_SIZE(gmii_modemux),
 651 };
 652 
 653 static const char *const gmii_grps[] = { "gmii_grp" };
 654 static struct spear_function gmii_function = {
 655         .name = "gmii",
 656         .groups = gmii_grps,
 657         .ngroups = ARRAY_SIZE(gmii_grps),
 658 };
 659 
 660 /* Pad multiplexing for rgmii device */
 661 static const unsigned rgmii_pins[] = { 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
 662         28, 29, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 175,
 663         180, 181, 182, 183, 185, 188, 193, 194, 195, 196, 197, 198, 211, 212 };
 664 static struct spear_muxreg rgmii_muxreg[] = {
 665         {
 666                 .reg = PAD_FUNCTION_EN_0,
 667                 .mask = PMX_RGMII_REG0_MASK,
 668                 .val = 0,
 669         }, {
 670                 .reg = PAD_FUNCTION_EN_1,
 671                 .mask = PMX_RGMII_REG1_MASK,
 672                 .val = 0,
 673         }, {
 674                 .reg = PAD_FUNCTION_EN_2,
 675                 .mask = PMX_RGMII_REG2_MASK,
 676                 .val = 0,
 677         }, {
 678                 .reg = PAD_DIRECTION_SEL_0,
 679                 .mask = PMX_RGMII_REG0_MASK,
 680                 .val = PMX_RGMII_REG0_MASK,
 681         }, {
 682                 .reg = PAD_DIRECTION_SEL_1,
 683                 .mask = PMX_RGMII_REG1_MASK,
 684                 .val = PMX_RGMII_REG1_MASK,
 685         }, {
 686                 .reg = PAD_DIRECTION_SEL_2,
 687                 .mask = PMX_RGMII_REG2_MASK,
 688                 .val = PMX_RGMII_REG2_MASK,
 689         },
 690 };
 691 
 692 static struct spear_modemux rgmii_modemux[] = {
 693         {
 694                 .muxregs = rgmii_muxreg,
 695                 .nmuxregs = ARRAY_SIZE(rgmii_muxreg),
 696         },
 697 };
 698 
 699 static struct spear_pingroup rgmii_pingroup = {
 700         .name = "rgmii_grp",
 701         .pins = rgmii_pins,
 702         .npins = ARRAY_SIZE(rgmii_pins),
 703         .modemuxs = rgmii_modemux,
 704         .nmodemuxs = ARRAY_SIZE(rgmii_modemux),
 705 };
 706 
 707 static const char *const rgmii_grps[] = { "rgmii_grp" };
 708 static struct spear_function rgmii_function = {
 709         .name = "rgmii",
 710         .groups = rgmii_grps,
 711         .ngroups = ARRAY_SIZE(rgmii_grps),
 712 };
 713 
 714 /* Pad multiplexing for smii_0_1_2 device */
 715 static const unsigned smii_0_1_2_pins[] = { 24, 25, 26, 27, 28, 29, 30, 31, 32,
 716         33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
 717         51, 52, 53, 54, 55 };
 718 static struct spear_muxreg smii_0_1_2_muxreg[] = {
 719         {
 720                 .reg = PAD_FUNCTION_EN_1,
 721                 .mask = PMX_SMII_0_1_2_MASK,
 722                 .val = 0,
 723         }, {
 724                 .reg = PAD_DIRECTION_SEL_1,
 725                 .mask = PMX_SMII_0_1_2_MASK,
 726                 .val = PMX_SMII_0_1_2_MASK,
 727         },
 728 };
 729 
 730 static struct spear_modemux smii_0_1_2_modemux[] = {
 731         {
 732                 .muxregs = smii_0_1_2_muxreg,
 733                 .nmuxregs = ARRAY_SIZE(smii_0_1_2_muxreg),
 734         },
 735 };
 736 
 737 static struct spear_pingroup smii_0_1_2_pingroup = {
 738         .name = "smii_0_1_2_grp",
 739         .pins = smii_0_1_2_pins,
 740         .npins = ARRAY_SIZE(smii_0_1_2_pins),
 741         .modemuxs = smii_0_1_2_modemux,
 742         .nmodemuxs = ARRAY_SIZE(smii_0_1_2_modemux),
 743 };
 744 
 745 static const char *const smii_0_1_2_grps[] = { "smii_0_1_2_grp" };
 746 static struct spear_function smii_0_1_2_function = {
 747         .name = "smii_0_1_2",
 748         .groups = smii_0_1_2_grps,
 749         .ngroups = ARRAY_SIZE(smii_0_1_2_grps),
 750 };
 751 
 752 /* Pad multiplexing for ras_mii_txclk device */
 753 static const unsigned ras_mii_txclk_pins[] = { 98, 99 };
 754 static struct spear_muxreg ras_mii_txclk_muxreg[] = {
 755         {
 756                 .reg = PAD_FUNCTION_EN_1,
 757                 .mask = PMX_NFCE2_MASK,
 758                 .val = 0,
 759         }, {
 760                 .reg = PAD_DIRECTION_SEL_1,
 761                 .mask = PMX_NFCE2_MASK,
 762                 .val = PMX_NFCE2_MASK,
 763         },
 764 };
 765 
 766 static struct spear_modemux ras_mii_txclk_modemux[] = {
 767         {
 768                 .muxregs = ras_mii_txclk_muxreg,
 769                 .nmuxregs = ARRAY_SIZE(ras_mii_txclk_muxreg),
 770         },
 771 };
 772 
 773 static struct spear_pingroup ras_mii_txclk_pingroup = {
 774         .name = "ras_mii_txclk_grp",
 775         .pins = ras_mii_txclk_pins,
 776         .npins = ARRAY_SIZE(ras_mii_txclk_pins),
 777         .modemuxs = ras_mii_txclk_modemux,
 778         .nmodemuxs = ARRAY_SIZE(ras_mii_txclk_modemux),
 779 };
 780 
 781 static const char *const ras_mii_txclk_grps[] = { "ras_mii_txclk_grp" };
 782 static struct spear_function ras_mii_txclk_function = {
 783         .name = "ras_mii_txclk",
 784         .groups = ras_mii_txclk_grps,
 785         .ngroups = ARRAY_SIZE(ras_mii_txclk_grps),
 786 };
 787 
 788 /* Pad multiplexing for nand 8bit device (cs0 only) */
 789 static const unsigned nand_8bit_pins[] = { 56, 57, 58, 59, 60, 61, 62, 63, 64,
 790         65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
 791         83, 84, 85, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
 792         170, 171, 172, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
 793         212 };
 794 static struct spear_muxreg nand_8bit_muxreg[] = {
 795         {
 796                 .reg = PAD_FUNCTION_EN_0,
 797                 .mask = PMX_NAND8BIT_0_MASK,
 798                 .val = PMX_NAND8BIT_0_MASK,
 799         }, {
 800                 .reg = PAD_FUNCTION_EN_1,
 801                 .mask = PMX_NAND8BIT_1_MASK,
 802                 .val = PMX_NAND8BIT_1_MASK,
 803         }, {
 804                 .reg = PAD_DIRECTION_SEL_0,
 805                 .mask = PMX_NAND8BIT_0_MASK,
 806                 .val = PMX_NAND8BIT_0_MASK,
 807         }, {
 808                 .reg = PAD_DIRECTION_SEL_1,
 809                 .mask = PMX_NAND8BIT_1_MASK,
 810                 .val = PMX_NAND8BIT_1_MASK,
 811         },
 812 };
 813 
 814 static struct spear_modemux nand_8bit_modemux[] = {
 815         {
 816                 .muxregs = nand_8bit_muxreg,
 817                 .nmuxregs = ARRAY_SIZE(nand_8bit_muxreg),
 818         },
 819 };
 820 
 821 static struct spear_pingroup nand_8bit_pingroup = {
 822         .name = "nand_8bit_grp",
 823         .pins = nand_8bit_pins,
 824         .npins = ARRAY_SIZE(nand_8bit_pins),
 825         .modemuxs = nand_8bit_modemux,
 826         .nmodemuxs = ARRAY_SIZE(nand_8bit_modemux),
 827 };
 828 
 829 /* Pad multiplexing for nand 16bit device */
 830 static const unsigned nand_16bit_pins[] = { 201, 202, 203, 204, 207, 208, 209,
 831         210 };
 832 static struct spear_muxreg nand_16bit_muxreg[] = {
 833         {
 834                 .reg = PAD_FUNCTION_EN_1,
 835                 .mask = PMX_NAND16BIT_1_MASK,
 836                 .val = PMX_NAND16BIT_1_MASK,
 837         }, {
 838                 .reg = PAD_DIRECTION_SEL_1,
 839                 .mask = PMX_NAND16BIT_1_MASK,
 840                 .val = PMX_NAND16BIT_1_MASK,
 841         },
 842 };
 843 
 844 static struct spear_modemux nand_16bit_modemux[] = {
 845         {
 846                 .muxregs = nand_16bit_muxreg,
 847                 .nmuxregs = ARRAY_SIZE(nand_16bit_muxreg),
 848         },
 849 };
 850 
 851 static struct spear_pingroup nand_16bit_pingroup = {
 852         .name = "nand_16bit_grp",
 853         .pins = nand_16bit_pins,
 854         .npins = ARRAY_SIZE(nand_16bit_pins),
 855         .modemuxs = nand_16bit_modemux,
 856         .nmodemuxs = ARRAY_SIZE(nand_16bit_modemux),
 857 };
 858 
 859 /* Pad multiplexing for nand 4 chips */
 860 static const unsigned nand_4_chips_pins[] = { 205, 206, 211, 212 };
 861 static struct spear_muxreg nand_4_chips_muxreg[] = {
 862         {
 863                 .reg = PAD_FUNCTION_EN_1,
 864                 .mask = PMX_NAND_4CHIPS_MASK,
 865                 .val = PMX_NAND_4CHIPS_MASK,
 866         }, {
 867                 .reg = PAD_DIRECTION_SEL_1,
 868                 .mask = PMX_NAND_4CHIPS_MASK,
 869                 .val = PMX_NAND_4CHIPS_MASK,
 870         },
 871 };
 872 
 873 static struct spear_modemux nand_4_chips_modemux[] = {
 874         {
 875                 .muxregs = nand_4_chips_muxreg,
 876                 .nmuxregs = ARRAY_SIZE(nand_4_chips_muxreg),
 877         },
 878 };
 879 
 880 static struct spear_pingroup nand_4_chips_pingroup = {
 881         .name = "nand_4_chips_grp",
 882         .pins = nand_4_chips_pins,
 883         .npins = ARRAY_SIZE(nand_4_chips_pins),
 884         .modemuxs = nand_4_chips_modemux,
 885         .nmodemuxs = ARRAY_SIZE(nand_4_chips_modemux),
 886 };
 887 
 888 static const char *const nand_grps[] = { "nand_8bit_grp", "nand_16bit_grp",
 889         "nand_4_chips_grp" };
 890 static struct spear_function nand_function = {
 891         .name = "nand",
 892         .groups = nand_grps,
 893         .ngroups = ARRAY_SIZE(nand_grps),
 894 };
 895 
 896 /* Pad multiplexing for keyboard_6x6 device */
 897 static const unsigned keyboard_6x6_pins[] = { 201, 202, 203, 204, 205, 206, 207,
 898         208, 209, 210, 211, 212 };
 899 static struct spear_muxreg keyboard_6x6_muxreg[] = {
 900         {
 901                 .reg = PAD_FUNCTION_EN_1,
 902                 .mask = PMX_KEYBOARD_6X6_MASK | PMX_NFIO8_15_MASK |
 903                         PMX_NFCE1_MASK | PMX_NFCE2_MASK | PMX_NFWPRT1_MASK |
 904                         PMX_NFWPRT2_MASK,
 905                 .val = PMX_KEYBOARD_6X6_MASK,
 906         },
 907 };
 908 
 909 static struct spear_modemux keyboard_6x6_modemux[] = {
 910         {
 911                 .muxregs = keyboard_6x6_muxreg,
 912                 .nmuxregs = ARRAY_SIZE(keyboard_6x6_muxreg),
 913         },
 914 };
 915 
 916 static struct spear_pingroup keyboard_6x6_pingroup = {
 917         .name = "keyboard_6x6_grp",
 918         .pins = keyboard_6x6_pins,
 919         .npins = ARRAY_SIZE(keyboard_6x6_pins),
 920         .modemuxs = keyboard_6x6_modemux,
 921         .nmodemuxs = ARRAY_SIZE(keyboard_6x6_modemux),
 922 };
 923 
 924 /* Pad multiplexing for keyboard_rowcol6_8 device */
 925 static const unsigned keyboard_rowcol6_8_pins[] = { 24, 25, 26, 27, 28, 29 };
 926 static struct spear_muxreg keyboard_rowcol6_8_muxreg[] = {
 927         {
 928                 .reg = PAD_FUNCTION_EN_1,
 929                 .mask = PMX_KBD_ROWCOL68_MASK,
 930                 .val = PMX_KBD_ROWCOL68_MASK,
 931         }, {
 932                 .reg = PAD_DIRECTION_SEL_1,
 933                 .mask = PMX_KBD_ROWCOL68_MASK,
 934                 .val = PMX_KBD_ROWCOL68_MASK,
 935         },
 936 };
 937 
 938 static struct spear_modemux keyboard_rowcol6_8_modemux[] = {
 939         {
 940                 .muxregs = keyboard_rowcol6_8_muxreg,
 941                 .nmuxregs = ARRAY_SIZE(keyboard_rowcol6_8_muxreg),
 942         },
 943 };
 944 
 945 static struct spear_pingroup keyboard_rowcol6_8_pingroup = {
 946         .name = "keyboard_rowcol6_8_grp",
 947         .pins = keyboard_rowcol6_8_pins,
 948         .npins = ARRAY_SIZE(keyboard_rowcol6_8_pins),
 949         .modemuxs = keyboard_rowcol6_8_modemux,
 950         .nmodemuxs = ARRAY_SIZE(keyboard_rowcol6_8_modemux),
 951 };
 952 
 953 static const char *const keyboard_grps[] = { "keyboard_6x6_grp",
 954         "keyboard_rowcol6_8_grp" };
 955 static struct spear_function keyboard_function = {
 956         .name = "keyboard",
 957         .groups = keyboard_grps,
 958         .ngroups = ARRAY_SIZE(keyboard_grps),
 959 };
 960 
 961 /* Pad multiplexing for uart0 device */
 962 static const unsigned uart0_pins[] = { 100, 101 };
 963 static struct spear_muxreg uart0_muxreg[] = {
 964         {
 965                 .reg = PAD_FUNCTION_EN_0,
 966                 .mask = PMX_UART0_MASK,
 967                 .val = PMX_UART0_MASK,
 968         }, {
 969                 .reg = PAD_DIRECTION_SEL_0,
 970                 .mask = PMX_UART0_MASK,
 971                 .val = PMX_UART0_MASK,
 972         },
 973 };
 974 
 975 static struct spear_modemux uart0_modemux[] = {
 976         {
 977                 .muxregs = uart0_muxreg,
 978                 .nmuxregs = ARRAY_SIZE(uart0_muxreg),
 979         },
 980 };
 981 
 982 static struct spear_pingroup uart0_pingroup = {
 983         .name = "uart0_grp",
 984         .pins = uart0_pins,
 985         .npins = ARRAY_SIZE(uart0_pins),
 986         .modemuxs = uart0_modemux,
 987         .nmodemuxs = ARRAY_SIZE(uart0_modemux),
 988 };
 989 
 990 /* Pad multiplexing for uart0_modem device */
 991 static const unsigned uart0_modem_pins[] = { 12, 13, 14, 15, 16, 17 };
 992 static struct spear_muxreg uart0_modem_muxreg[] = {
 993         {
 994                 .reg = PAD_FUNCTION_EN_1,
 995                 .mask = PMX_UART0_MODEM_MASK,
 996                 .val = PMX_UART0_MODEM_MASK,
 997         }, {
 998                 .reg = PAD_DIRECTION_SEL_1,
 999                 .mask = PMX_UART0_MODEM_MASK,
1000                 .val = PMX_UART0_MODEM_MASK,
1001         },
1002 };
1003 
1004 static struct spear_modemux uart0_modem_modemux[] = {
1005         {
1006                 .muxregs = uart0_modem_muxreg,
1007                 .nmuxregs = ARRAY_SIZE(uart0_modem_muxreg),
1008         },
1009 };
1010 
1011 static struct spear_pingroup uart0_modem_pingroup = {
1012         .name = "uart0_modem_grp",
1013         .pins = uart0_modem_pins,
1014         .npins = ARRAY_SIZE(uart0_modem_pins),
1015         .modemuxs = uart0_modem_modemux,
1016         .nmodemuxs = ARRAY_SIZE(uart0_modem_modemux),
1017 };
1018 
1019 static const char *const uart0_grps[] = { "uart0_grp", "uart0_modem_grp" };
1020 static struct spear_function uart0_function = {
1021         .name = "uart0",
1022         .groups = uart0_grps,
1023         .ngroups = ARRAY_SIZE(uart0_grps),
1024 };
1025 
1026 /* Pad multiplexing for gpt0_tmr0 device */
1027 static const unsigned gpt0_tmr0_pins[] = { 10, 11 };
1028 static struct spear_muxreg gpt0_tmr0_muxreg[] = {
1029         {
1030                 .reg = PAD_FUNCTION_EN_1,
1031                 .mask = PMX_GPT0_TMR0_MASK,
1032                 .val = PMX_GPT0_TMR0_MASK,
1033         }, {
1034                 .reg = PAD_DIRECTION_SEL_1,
1035                 .mask = PMX_GPT0_TMR0_MASK,
1036                 .val = PMX_GPT0_TMR0_MASK,
1037         },
1038 };
1039 
1040 static struct spear_modemux gpt0_tmr0_modemux[] = {
1041         {
1042                 .muxregs = gpt0_tmr0_muxreg,
1043                 .nmuxregs = ARRAY_SIZE(gpt0_tmr0_muxreg),
1044         },
1045 };
1046 
1047 static struct spear_pingroup gpt0_tmr0_pingroup = {
1048         .name = "gpt0_tmr0_grp",
1049         .pins = gpt0_tmr0_pins,
1050         .npins = ARRAY_SIZE(gpt0_tmr0_pins),
1051         .modemuxs = gpt0_tmr0_modemux,
1052         .nmodemuxs = ARRAY_SIZE(gpt0_tmr0_modemux),
1053 };
1054 
1055 /* Pad multiplexing for gpt0_tmr1 device */
1056 static const unsigned gpt0_tmr1_pins[] = { 8, 9 };
1057 static struct spear_muxreg gpt0_tmr1_muxreg[] = {
1058         {
1059                 .reg = PAD_FUNCTION_EN_1,
1060                 .mask = PMX_GPT0_TMR1_MASK,
1061                 .val = PMX_GPT0_TMR1_MASK,
1062         }, {
1063                 .reg = PAD_DIRECTION_SEL_1,
1064                 .mask = PMX_GPT0_TMR1_MASK,
1065                 .val = PMX_GPT0_TMR1_MASK,
1066         },
1067 };
1068 
1069 static struct spear_modemux gpt0_tmr1_modemux[] = {
1070         {
1071                 .muxregs = gpt0_tmr1_muxreg,
1072                 .nmuxregs = ARRAY_SIZE(gpt0_tmr1_muxreg),
1073         },
1074 };
1075 
1076 static struct spear_pingroup gpt0_tmr1_pingroup = {
1077         .name = "gpt0_tmr1_grp",
1078         .pins = gpt0_tmr1_pins,
1079         .npins = ARRAY_SIZE(gpt0_tmr1_pins),
1080         .modemuxs = gpt0_tmr1_modemux,
1081         .nmodemuxs = ARRAY_SIZE(gpt0_tmr1_modemux),
1082 };
1083 
1084 static const char *const gpt0_grps[] = { "gpt0_tmr0_grp", "gpt0_tmr1_grp" };
1085 static struct spear_function gpt0_function = {
1086         .name = "gpt0",
1087         .groups = gpt0_grps,
1088         .ngroups = ARRAY_SIZE(gpt0_grps),
1089 };
1090 
1091 /* Pad multiplexing for gpt1_tmr0 device */
1092 static const unsigned gpt1_tmr0_pins[] = { 6, 7 };
1093 static struct spear_muxreg gpt1_tmr0_muxreg[] = {
1094         {
1095                 .reg = PAD_FUNCTION_EN_1,
1096                 .mask = PMX_GPT1_TMR0_MASK,
1097                 .val = PMX_GPT1_TMR0_MASK,
1098         }, {
1099                 .reg = PAD_DIRECTION_SEL_1,
1100                 .mask = PMX_GPT1_TMR0_MASK,
1101                 .val = PMX_GPT1_TMR0_MASK,
1102         },
1103 };
1104 
1105 static struct spear_modemux gpt1_tmr0_modemux[] = {
1106         {
1107                 .muxregs = gpt1_tmr0_muxreg,
1108                 .nmuxregs = ARRAY_SIZE(gpt1_tmr0_muxreg),
1109         },
1110 };
1111 
1112 static struct spear_pingroup gpt1_tmr0_pingroup = {
1113         .name = "gpt1_tmr0_grp",
1114         .pins = gpt1_tmr0_pins,
1115         .npins = ARRAY_SIZE(gpt1_tmr0_pins),
1116         .modemuxs = gpt1_tmr0_modemux,
1117         .nmodemuxs = ARRAY_SIZE(gpt1_tmr0_modemux),
1118 };
1119 
1120 /* Pad multiplexing for gpt1_tmr1 device */
1121 static const unsigned gpt1_tmr1_pins[] = { 4, 5 };
1122 static struct spear_muxreg gpt1_tmr1_muxreg[] = {
1123         {
1124                 .reg = PAD_FUNCTION_EN_1,
1125                 .mask = PMX_GPT1_TMR1_MASK,
1126                 .val = PMX_GPT1_TMR1_MASK,
1127         }, {
1128                 .reg = PAD_DIRECTION_SEL_1,
1129                 .mask = PMX_GPT1_TMR1_MASK,
1130                 .val = PMX_GPT1_TMR1_MASK,
1131         },
1132 };
1133 
1134 static struct spear_modemux gpt1_tmr1_modemux[] = {
1135         {
1136                 .muxregs = gpt1_tmr1_muxreg,
1137                 .nmuxregs = ARRAY_SIZE(gpt1_tmr1_muxreg),
1138         },
1139 };
1140 
1141 static struct spear_pingroup gpt1_tmr1_pingroup = {
1142         .name = "gpt1_tmr1_grp",
1143         .pins = gpt1_tmr1_pins,
1144         .npins = ARRAY_SIZE(gpt1_tmr1_pins),
1145         .modemuxs = gpt1_tmr1_modemux,
1146         .nmodemuxs = ARRAY_SIZE(gpt1_tmr1_modemux),
1147 };
1148 
1149 static const char *const gpt1_grps[] = { "gpt1_tmr1_grp", "gpt1_tmr0_grp" };
1150 static struct spear_function gpt1_function = {
1151         .name = "gpt1",
1152         .groups = gpt1_grps,
1153         .ngroups = ARRAY_SIZE(gpt1_grps),
1154 };
1155 
1156 /* Pad multiplexing for mcif device */
1157 static const unsigned mcif_pins[] = { 86, 87, 88, 89, 90, 91, 92, 93, 213, 214,
1158         215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
1159         229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
1160         243, 244, 245 };
1161 #define MCIF_MUXREG                                             \
1162         {                                                       \
1163                 .reg = PAD_FUNCTION_EN_0,                       \
1164                 .mask = PMX_MCI_DATA8_15_MASK,                  \
1165                 .val = PMX_MCI_DATA8_15_MASK,                   \
1166         }, {                                                    \
1167                 .reg = PAD_FUNCTION_EN_1,                       \
1168                 .mask = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK | \
1169                         PMX_NFWPRT2_MASK,                       \
1170                 .val = PMX_MCIFALL_1_MASK,                      \
1171         }, {                                                    \
1172                 .reg = PAD_FUNCTION_EN_2,                       \
1173                 .mask = PMX_MCIFALL_2_MASK,                     \
1174                 .val = PMX_MCIFALL_2_MASK,                      \
1175         }, {                                                    \
1176                 .reg = PAD_DIRECTION_SEL_0,                     \
1177                 .mask = PMX_MCI_DATA8_15_MASK,                  \
1178                 .val = PMX_MCI_DATA8_15_MASK,                   \
1179         }, {                                                    \
1180                 .reg = PAD_DIRECTION_SEL_1,                     \
1181                 .mask = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK | \
1182                         PMX_NFWPRT2_MASK,                       \
1183                 .val = PMX_MCIFALL_1_MASK | PMX_NFWPRT1_MASK |  \
1184                         PMX_NFWPRT2_MASK,                       \
1185         }, {                                                    \
1186                 .reg = PAD_DIRECTION_SEL_2,                     \
1187                 .mask = PMX_MCIFALL_2_MASK,                     \
1188                 .val = PMX_MCIFALL_2_MASK,                      \
1189         }
1190 
1191 /* sdhci device */
1192 static struct spear_muxreg sdhci_muxreg[] = {
1193         MCIF_MUXREG,
1194         {
1195                 .reg = PERIP_CFG,
1196                 .mask = MCIF_SEL_MASK,
1197                 .val = MCIF_SEL_SD,
1198         },
1199 };
1200 
1201 static struct spear_modemux sdhci_modemux[] = {
1202         {
1203                 .muxregs = sdhci_muxreg,
1204                 .nmuxregs = ARRAY_SIZE(sdhci_muxreg),
1205         },
1206 };
1207 
1208 static struct spear_pingroup sdhci_pingroup = {
1209         .name = "sdhci_grp",
1210         .pins = mcif_pins,
1211         .npins = ARRAY_SIZE(mcif_pins),
1212         .modemuxs = sdhci_modemux,
1213         .nmodemuxs = ARRAY_SIZE(sdhci_modemux),
1214 };
1215 
1216 static const char *const sdhci_grps[] = { "sdhci_grp" };
1217 static struct spear_function sdhci_function = {
1218         .name = "sdhci",
1219         .groups = sdhci_grps,
1220         .ngroups = ARRAY_SIZE(sdhci_grps),
1221 };
1222 
1223 /* cf device */
1224 static struct spear_muxreg cf_muxreg[] = {
1225         MCIF_MUXREG,
1226         {
1227                 .reg = PERIP_CFG,
1228                 .mask = MCIF_SEL_MASK,
1229                 .val = MCIF_SEL_CF,
1230         },
1231 };
1232 
1233 static struct spear_modemux cf_modemux[] = {
1234         {
1235                 .muxregs = cf_muxreg,
1236                 .nmuxregs = ARRAY_SIZE(cf_muxreg),
1237         },
1238 };
1239 
1240 static struct spear_pingroup cf_pingroup = {
1241         .name = "cf_grp",
1242         .pins = mcif_pins,
1243         .npins = ARRAY_SIZE(mcif_pins),
1244         .modemuxs = cf_modemux,
1245         .nmodemuxs = ARRAY_SIZE(cf_modemux),
1246 };
1247 
1248 static const char *const cf_grps[] = { "cf_grp" };
1249 static struct spear_function cf_function = {
1250         .name = "cf",
1251         .groups = cf_grps,
1252         .ngroups = ARRAY_SIZE(cf_grps),
1253 };
1254 
1255 /* xd device */
1256 static struct spear_muxreg xd_muxreg[] = {
1257         MCIF_MUXREG,
1258         {
1259                 .reg = PERIP_CFG,
1260                 .mask = MCIF_SEL_MASK,
1261                 .val = MCIF_SEL_XD,
1262         },
1263 };
1264 
1265 static struct spear_modemux xd_modemux[] = {
1266         {
1267                 .muxregs = xd_muxreg,
1268                 .nmuxregs = ARRAY_SIZE(xd_muxreg),
1269         },
1270 };
1271 
1272 static struct spear_pingroup xd_pingroup = {
1273         .name = "xd_grp",
1274         .pins = mcif_pins,
1275         .npins = ARRAY_SIZE(mcif_pins),
1276         .modemuxs = xd_modemux,
1277         .nmodemuxs = ARRAY_SIZE(xd_modemux),
1278 };
1279 
1280 static const char *const xd_grps[] = { "xd_grp" };
1281 static struct spear_function xd_function = {
1282         .name = "xd",
1283         .groups = xd_grps,
1284         .ngroups = ARRAY_SIZE(xd_grps),
1285 };
1286 
1287 /* Pad multiplexing for touch_xy device */
1288 static const unsigned touch_xy_pins[] = { 97 };
1289 static struct spear_muxreg touch_xy_muxreg[] = {
1290         {
1291                 .reg = PAD_FUNCTION_EN_2,
1292                 .mask = PMX_TOUCH_XY_MASK,
1293                 .val = PMX_TOUCH_XY_MASK,
1294         }, {
1295                 .reg = PAD_DIRECTION_SEL_2,
1296                 .mask = PMX_TOUCH_XY_MASK,
1297                 .val = PMX_TOUCH_XY_MASK,
1298         },
1299 };
1300 
1301 static struct spear_modemux touch_xy_modemux[] = {
1302         {
1303                 .muxregs = touch_xy_muxreg,
1304                 .nmuxregs = ARRAY_SIZE(touch_xy_muxreg),
1305         },
1306 };
1307 
1308 static struct spear_pingroup touch_xy_pingroup = {
1309         .name = "touch_xy_grp",
1310         .pins = touch_xy_pins,
1311         .npins = ARRAY_SIZE(touch_xy_pins),
1312         .modemuxs = touch_xy_modemux,
1313         .nmodemuxs = ARRAY_SIZE(touch_xy_modemux),
1314 };
1315 
1316 static const char *const touch_xy_grps[] = { "touch_xy_grp" };
1317 static struct spear_function touch_xy_function = {
1318         .name = "touchscreen",
1319         .groups = touch_xy_grps,
1320         .ngroups = ARRAY_SIZE(touch_xy_grps),
1321 };
1322 
1323 /* Pad multiplexing for uart1 device */
1324 /* Muxed with I2C */
1325 static const unsigned uart1_dis_i2c_pins[] = { 102, 103 };
1326 static struct spear_muxreg uart1_dis_i2c_muxreg[] = {
1327         {
1328                 .reg = PAD_FUNCTION_EN_0,
1329                 .mask = PMX_I2C0_MASK,
1330                 .val = 0,
1331         }, {
1332                 .reg = PAD_DIRECTION_SEL_0,
1333                 .mask = PMX_I2C0_MASK,
1334                 .val = PMX_I2C0_MASK,
1335         },
1336 };
1337 
1338 static struct spear_modemux uart1_dis_i2c_modemux[] = {
1339         {
1340                 .muxregs = uart1_dis_i2c_muxreg,
1341                 .nmuxregs = ARRAY_SIZE(uart1_dis_i2c_muxreg),
1342         },
1343 };
1344 
1345 static struct spear_pingroup uart_1_dis_i2c_pingroup = {
1346         .name = "uart1_disable_i2c_grp",
1347         .pins = uart1_dis_i2c_pins,
1348         .npins = ARRAY_SIZE(uart1_dis_i2c_pins),
1349         .modemuxs = uart1_dis_i2c_modemux,
1350         .nmodemuxs = ARRAY_SIZE(uart1_dis_i2c_modemux),
1351 };
1352 
1353 /* Muxed with SD/MMC */
1354 static const unsigned uart1_dis_sd_pins[] = { 214, 215 };
1355 static struct spear_muxreg uart1_dis_sd_muxreg[] = {
1356         {
1357                 .reg = PAD_FUNCTION_EN_1,
1358                 .mask = PMX_MCIDATA1_MASK |
1359                         PMX_MCIDATA2_MASK,
1360                 .val = 0,
1361         }, {
1362                 .reg = PAD_DIRECTION_SEL_1,
1363                 .mask = PMX_MCIDATA1_MASK |
1364                         PMX_MCIDATA2_MASK,
1365                 .val = PMX_MCIDATA1_MASK |
1366                         PMX_MCIDATA2_MASK,
1367         },
1368 };
1369 
1370 static struct spear_modemux uart1_dis_sd_modemux[] = {
1371         {
1372                 .muxregs = uart1_dis_sd_muxreg,
1373                 .nmuxregs = ARRAY_SIZE(uart1_dis_sd_muxreg),
1374         },
1375 };
1376 
1377 static struct spear_pingroup uart_1_dis_sd_pingroup = {
1378         .name = "uart1_disable_sd_grp",
1379         .pins = uart1_dis_sd_pins,
1380         .npins = ARRAY_SIZE(uart1_dis_sd_pins),
1381         .modemuxs = uart1_dis_sd_modemux,
1382         .nmodemuxs = ARRAY_SIZE(uart1_dis_sd_modemux),
1383 };
1384 
1385 static const char *const uart1_grps[] = { "uart1_disable_i2c_grp",
1386         "uart1_disable_sd_grp" };
1387 static struct spear_function uart1_function = {
1388         .name = "uart1",
1389         .groups = uart1_grps,
1390         .ngroups = ARRAY_SIZE(uart1_grps),
1391 };
1392 
1393 /* Pad multiplexing for uart2_3 device */
1394 static const unsigned uart2_3_pins[] = { 104, 105, 106, 107 };
1395 static struct spear_muxreg uart2_3_muxreg[] = {
1396         {
1397                 .reg = PAD_FUNCTION_EN_0,
1398                 .mask = PMX_I2S0_MASK,
1399                 .val = 0,
1400         }, {
1401                 .reg = PAD_DIRECTION_SEL_0,
1402                 .mask = PMX_I2S0_MASK,
1403                 .val = PMX_I2S0_MASK,
1404         },
1405 };
1406 
1407 static struct spear_modemux uart2_3_modemux[] = {
1408         {
1409                 .muxregs = uart2_3_muxreg,
1410                 .nmuxregs = ARRAY_SIZE(uart2_3_muxreg),
1411         },
1412 };
1413 
1414 static struct spear_pingroup uart_2_3_pingroup = {
1415         .name = "uart2_3_grp",
1416         .pins = uart2_3_pins,
1417         .npins = ARRAY_SIZE(uart2_3_pins),
1418         .modemuxs = uart2_3_modemux,
1419         .nmodemuxs = ARRAY_SIZE(uart2_3_modemux),
1420 };
1421 
1422 static const char *const uart2_3_grps[] = { "uart2_3_grp" };
1423 static struct spear_function uart2_3_function = {
1424         .name = "uart2_3",
1425         .groups = uart2_3_grps,
1426         .ngroups = ARRAY_SIZE(uart2_3_grps),
1427 };
1428 
1429 /* Pad multiplexing for uart4 device */
1430 static const unsigned uart4_pins[] = { 108, 113 };
1431 static struct spear_muxreg uart4_muxreg[] = {
1432         {
1433                 .reg = PAD_FUNCTION_EN_0,
1434                 .mask = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1435                 .val = 0,
1436         }, {
1437                 .reg = PAD_DIRECTION_SEL_0,
1438                 .mask = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1439                 .val = PMX_I2S0_MASK | PMX_CLCD1_MASK,
1440         },
1441 };
1442 
1443 static struct spear_modemux uart4_modemux[] = {
1444         {
1445                 .muxregs = uart4_muxreg,
1446                 .nmuxregs = ARRAY_SIZE(uart4_muxreg),
1447         },
1448 };
1449 
1450 static struct spear_pingroup uart_4_pingroup = {
1451         .name = "uart4_grp",
1452         .pins = uart4_pins,
1453         .npins = ARRAY_SIZE(uart4_pins),
1454         .modemuxs = uart4_modemux,
1455         .nmodemuxs = ARRAY_SIZE(uart4_modemux),
1456 };
1457 
1458 static const char *const uart4_grps[] = { "uart4_grp" };
1459 static struct spear_function uart4_function = {
1460         .name = "uart4",
1461         .groups = uart4_grps,
1462         .ngroups = ARRAY_SIZE(uart4_grps),
1463 };
1464 
1465 /* Pad multiplexing for uart5 device */
1466 static const unsigned uart5_pins[] = { 114, 115 };
1467 static struct spear_muxreg uart5_muxreg[] = {
1468         {
1469                 .reg = PAD_FUNCTION_EN_0,
1470                 .mask = PMX_CLCD1_MASK,
1471                 .val = 0,
1472         }, {
1473                 .reg = PAD_DIRECTION_SEL_0,
1474                 .mask = PMX_CLCD1_MASK,
1475                 .val = PMX_CLCD1_MASK,
1476         },
1477 };
1478 
1479 static struct spear_modemux uart5_modemux[] = {
1480         {
1481                 .muxregs = uart5_muxreg,
1482                 .nmuxregs = ARRAY_SIZE(uart5_muxreg),
1483         },
1484 };
1485 
1486 static struct spear_pingroup uart_5_pingroup = {
1487         .name = "uart5_grp",
1488         .pins = uart5_pins,
1489         .npins = ARRAY_SIZE(uart5_pins),
1490         .modemuxs = uart5_modemux,
1491         .nmodemuxs = ARRAY_SIZE(uart5_modemux),
1492 };
1493 
1494 static const char *const uart5_grps[] = { "uart5_grp" };
1495 static struct spear_function uart5_function = {
1496         .name = "uart5",
1497         .groups = uart5_grps,
1498         .ngroups = ARRAY_SIZE(uart5_grps),
1499 };
1500 
1501 /* Pad multiplexing for rs485_0_1_tdm_0_1 device */
1502 static const unsigned rs485_0_1_tdm_0_1_pins[] = { 116, 117, 118, 119, 120, 121,
1503         122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1504         136, 137 };
1505 static struct spear_muxreg rs485_0_1_tdm_0_1_muxreg[] = {
1506         {
1507                 .reg = PAD_FUNCTION_EN_0,
1508                 .mask = PMX_CLCD1_MASK,
1509                 .val = 0,
1510         }, {
1511                 .reg = PAD_DIRECTION_SEL_0,
1512                 .mask = PMX_CLCD1_MASK,
1513                 .val = PMX_CLCD1_MASK,
1514         },
1515 };
1516 
1517 static struct spear_modemux rs485_0_1_tdm_0_1_modemux[] = {
1518         {
1519                 .muxregs = rs485_0_1_tdm_0_1_muxreg,
1520                 .nmuxregs = ARRAY_SIZE(rs485_0_1_tdm_0_1_muxreg),
1521         },
1522 };
1523 
1524 static struct spear_pingroup rs485_0_1_tdm_0_1_pingroup = {
1525         .name = "rs485_0_1_tdm_0_1_grp",
1526         .pins = rs485_0_1_tdm_0_1_pins,
1527         .npins = ARRAY_SIZE(rs485_0_1_tdm_0_1_pins),
1528         .modemuxs = rs485_0_1_tdm_0_1_modemux,
1529         .nmodemuxs = ARRAY_SIZE(rs485_0_1_tdm_0_1_modemux),
1530 };
1531 
1532 static const char *const rs485_0_1_tdm_0_1_grps[] = { "rs485_0_1_tdm_0_1_grp" };
1533 static struct spear_function rs485_0_1_tdm_0_1_function = {
1534         .name = "rs485_0_1_tdm_0_1",
1535         .groups = rs485_0_1_tdm_0_1_grps,
1536         .ngroups = ARRAY_SIZE(rs485_0_1_tdm_0_1_grps),
1537 };
1538 
1539 /* Pad multiplexing for i2c_1_2 device */
1540 static const unsigned i2c_1_2_pins[] = { 138, 139, 140, 141 };
1541 static struct spear_muxreg i2c_1_2_muxreg[] = {
1542         {
1543                 .reg = PAD_FUNCTION_EN_0,
1544                 .mask = PMX_CLCD1_MASK,
1545                 .val = 0,
1546         }, {
1547                 .reg = PAD_DIRECTION_SEL_0,
1548                 .mask = PMX_CLCD1_MASK,
1549                 .val = PMX_CLCD1_MASK,
1550         },
1551 };
1552 
1553 static struct spear_modemux i2c_1_2_modemux[] = {
1554         {
1555                 .muxregs = i2c_1_2_muxreg,
1556                 .nmuxregs = ARRAY_SIZE(i2c_1_2_muxreg),
1557         },
1558 };
1559 
1560 static struct spear_pingroup i2c_1_2_pingroup = {
1561         .name = "i2c_1_2_grp",
1562         .pins = i2c_1_2_pins,
1563         .npins = ARRAY_SIZE(i2c_1_2_pins),
1564         .modemuxs = i2c_1_2_modemux,
1565         .nmodemuxs = ARRAY_SIZE(i2c_1_2_modemux),
1566 };
1567 
1568 static const char *const i2c_1_2_grps[] = { "i2c_1_2_grp" };
1569 static struct spear_function i2c_1_2_function = {
1570         .name = "i2c_1_2",
1571         .groups = i2c_1_2_grps,
1572         .ngroups = ARRAY_SIZE(i2c_1_2_grps),
1573 };
1574 
1575 /* Pad multiplexing for i2c3_dis_smi_clcd device */
1576 /* Muxed with SMI & CLCD */
1577 static const unsigned i2c3_dis_smi_clcd_pins[] = { 142, 153 };
1578 static struct spear_muxreg i2c3_dis_smi_clcd_muxreg[] = {
1579         {
1580                 .reg = PAD_FUNCTION_EN_0,
1581                 .mask = PMX_CLCD1_MASK | PMX_SMI_MASK,
1582                 .val = 0,
1583         }, {
1584                 .reg = PAD_DIRECTION_SEL_0,
1585                 .mask = PMX_CLCD1_MASK | PMX_SMI_MASK,
1586                 .val = PMX_CLCD1_MASK | PMX_SMI_MASK,
1587         },
1588 };
1589 
1590 static struct spear_modemux i2c3_dis_smi_clcd_modemux[] = {
1591         {
1592                 .muxregs = i2c3_dis_smi_clcd_muxreg,
1593                 .nmuxregs = ARRAY_SIZE(i2c3_dis_smi_clcd_muxreg),
1594         },
1595 };
1596 
1597 static struct spear_pingroup i2c3_dis_smi_clcd_pingroup = {
1598         .name = "i2c3_dis_smi_clcd_grp",
1599         .pins = i2c3_dis_smi_clcd_pins,
1600         .npins = ARRAY_SIZE(i2c3_dis_smi_clcd_pins),
1601         .modemuxs = i2c3_dis_smi_clcd_modemux,
1602         .nmodemuxs = ARRAY_SIZE(i2c3_dis_smi_clcd_modemux),
1603 };
1604 
1605 /* Pad multiplexing for i2c3_dis_sd_i2s0 device */
1606 /* Muxed with SD/MMC & I2S1 */
1607 static const unsigned i2c3_dis_sd_i2s0_pins[] = { 0, 216 };
1608 static struct spear_muxreg i2c3_dis_sd_i2s0_muxreg[] = {
1609         {
1610                 .reg = PAD_FUNCTION_EN_1,
1611                 .mask = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1612                 .val = 0,
1613         }, {
1614                 .reg = PAD_DIRECTION_SEL_1,
1615                 .mask = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1616                 .val = PMX_I2S1_MASK | PMX_MCIDATA3_MASK,
1617         },
1618 };
1619 
1620 static struct spear_modemux i2c3_dis_sd_i2s0_modemux[] = {
1621         {
1622                 .muxregs = i2c3_dis_sd_i2s0_muxreg,
1623                 .nmuxregs = ARRAY_SIZE(i2c3_dis_sd_i2s0_muxreg),
1624         },
1625 };
1626 
1627 static struct spear_pingroup i2c3_dis_sd_i2s0_pingroup = {
1628         .name = "i2c3_dis_sd_i2s0_grp",
1629         .pins = i2c3_dis_sd_i2s0_pins,
1630         .npins = ARRAY_SIZE(i2c3_dis_sd_i2s0_pins),
1631         .modemuxs = i2c3_dis_sd_i2s0_modemux,
1632         .nmodemuxs = ARRAY_SIZE(i2c3_dis_sd_i2s0_modemux),
1633 };
1634 
1635 static const char *const i2c3_grps[] = { "i2c3_dis_smi_clcd_grp",
1636         "i2c3_dis_sd_i2s0_grp" };
1637 static struct spear_function i2c3_unction = {
1638         .name = "i2c3_i2s1",
1639         .groups = i2c3_grps,
1640         .ngroups = ARRAY_SIZE(i2c3_grps),
1641 };
1642 
1643 /* Pad multiplexing for i2c_4_5_dis_smi device */
1644 /* Muxed with SMI */
1645 static const unsigned i2c_4_5_dis_smi_pins[] = { 154, 155, 156, 157 };
1646 static struct spear_muxreg i2c_4_5_dis_smi_muxreg[] = {
1647         {
1648                 .reg = PAD_FUNCTION_EN_0,
1649                 .mask = PMX_SMI_MASK,
1650                 .val = 0,
1651         }, {
1652                 .reg = PAD_DIRECTION_SEL_0,
1653                 .mask = PMX_SMI_MASK,
1654                 .val = PMX_SMI_MASK,
1655         },
1656 };
1657 
1658 static struct spear_modemux i2c_4_5_dis_smi_modemux[] = {
1659         {
1660                 .muxregs = i2c_4_5_dis_smi_muxreg,
1661                 .nmuxregs = ARRAY_SIZE(i2c_4_5_dis_smi_muxreg),
1662         },
1663 };
1664 
1665 static struct spear_pingroup i2c_4_5_dis_smi_pingroup = {
1666         .name = "i2c_4_5_dis_smi_grp",
1667         .pins = i2c_4_5_dis_smi_pins,
1668         .npins = ARRAY_SIZE(i2c_4_5_dis_smi_pins),
1669         .modemuxs = i2c_4_5_dis_smi_modemux,
1670         .nmodemuxs = ARRAY_SIZE(i2c_4_5_dis_smi_modemux),
1671 };
1672 
1673 /* Pad multiplexing for i2c4_dis_sd device */
1674 /* Muxed with SD/MMC */
1675 static const unsigned i2c4_dis_sd_pins[] = { 217, 218 };
1676 static struct spear_muxreg i2c4_dis_sd_muxreg[] = {
1677         {
1678                 .reg = PAD_FUNCTION_EN_1,
1679                 .mask = PMX_MCIDATA4_MASK,
1680                 .val = 0,
1681         }, {
1682                 .reg = PAD_FUNCTION_EN_2,
1683                 .mask = PMX_MCIDATA5_MASK,
1684                 .val = 0,
1685         }, {
1686                 .reg = PAD_DIRECTION_SEL_1,
1687                 .mask = PMX_MCIDATA4_MASK,
1688                 .val = PMX_MCIDATA4_MASK,
1689         }, {
1690                 .reg = PAD_DIRECTION_SEL_2,
1691                 .mask = PMX_MCIDATA5_MASK,
1692                 .val = PMX_MCIDATA5_MASK,
1693         },
1694 };
1695 
1696 static struct spear_modemux i2c4_dis_sd_modemux[] = {
1697         {
1698                 .muxregs = i2c4_dis_sd_muxreg,
1699                 .nmuxregs = ARRAY_SIZE(i2c4_dis_sd_muxreg),
1700         },
1701 };
1702 
1703 static struct spear_pingroup i2c4_dis_sd_pingroup = {
1704         .name = "i2c4_dis_sd_grp",
1705         .pins = i2c4_dis_sd_pins,
1706         .npins = ARRAY_SIZE(i2c4_dis_sd_pins),
1707         .modemuxs = i2c4_dis_sd_modemux,
1708         .nmodemuxs = ARRAY_SIZE(i2c4_dis_sd_modemux),
1709 };
1710 
1711 /* Pad multiplexing for i2c5_dis_sd device */
1712 /* Muxed with SD/MMC */
1713 static const unsigned i2c5_dis_sd_pins[] = { 219, 220 };
1714 static struct spear_muxreg i2c5_dis_sd_muxreg[] = {
1715         {
1716                 .reg = PAD_FUNCTION_EN_2,
1717                 .mask = PMX_MCIDATA6_MASK |
1718                         PMX_MCIDATA7_MASK,
1719                 .val = 0,
1720         }, {
1721                 .reg = PAD_DIRECTION_SEL_2,
1722                 .mask = PMX_MCIDATA6_MASK |
1723                         PMX_MCIDATA7_MASK,
1724                 .val = PMX_MCIDATA6_MASK |
1725                         PMX_MCIDATA7_MASK,
1726         },
1727 };
1728 
1729 static struct spear_modemux i2c5_dis_sd_modemux[] = {
1730         {
1731                 .muxregs = i2c5_dis_sd_muxreg,
1732                 .nmuxregs = ARRAY_SIZE(i2c5_dis_sd_muxreg),
1733         },
1734 };
1735 
1736 static struct spear_pingroup i2c5_dis_sd_pingroup = {
1737         .name = "i2c5_dis_sd_grp",
1738         .pins = i2c5_dis_sd_pins,
1739         .npins = ARRAY_SIZE(i2c5_dis_sd_pins),
1740         .modemuxs = i2c5_dis_sd_modemux,
1741         .nmodemuxs = ARRAY_SIZE(i2c5_dis_sd_modemux),
1742 };
1743 
1744 static const char *const i2c_4_5_grps[] = { "i2c5_dis_sd_grp",
1745         "i2c4_dis_sd_grp", "i2c_4_5_dis_smi_grp" };
1746 static struct spear_function i2c_4_5_function = {
1747         .name = "i2c_4_5",
1748         .groups = i2c_4_5_grps,
1749         .ngroups = ARRAY_SIZE(i2c_4_5_grps),
1750 };
1751 
1752 /* Pad multiplexing for i2c_6_7_dis_kbd device */
1753 /* Muxed with KBD */
1754 static const unsigned i2c_6_7_dis_kbd_pins[] = { 207, 208, 209, 210 };
1755 static struct spear_muxreg i2c_6_7_dis_kbd_muxreg[] = {
1756         {
1757                 .reg = PAD_FUNCTION_EN_1,
1758                 .mask = PMX_KBD_ROWCOL25_MASK,
1759                 .val = 0,
1760         }, {
1761                 .reg = PAD_DIRECTION_SEL_1,
1762                 .mask = PMX_KBD_ROWCOL25_MASK,
1763                 .val = PMX_KBD_ROWCOL25_MASK,
1764         },
1765 };
1766 
1767 static struct spear_modemux i2c_6_7_dis_kbd_modemux[] = {
1768         {
1769                 .muxregs = i2c_6_7_dis_kbd_muxreg,
1770                 .nmuxregs = ARRAY_SIZE(i2c_6_7_dis_kbd_muxreg),
1771         },
1772 };
1773 
1774 static struct spear_pingroup i2c_6_7_dis_kbd_pingroup = {
1775         .name = "i2c_6_7_dis_kbd_grp",
1776         .pins = i2c_6_7_dis_kbd_pins,
1777         .npins = ARRAY_SIZE(i2c_6_7_dis_kbd_pins),
1778         .modemuxs = i2c_6_7_dis_kbd_modemux,
1779         .nmodemuxs = ARRAY_SIZE(i2c_6_7_dis_kbd_modemux),
1780 };
1781 
1782 /* Pad multiplexing for i2c6_dis_sd device */
1783 /* Muxed with SD/MMC */
1784 static const unsigned i2c6_dis_sd_pins[] = { 236, 237 };
1785 static struct spear_muxreg i2c6_dis_sd_muxreg[] = {
1786         {
1787                 .reg = PAD_FUNCTION_EN_2,
1788                 .mask = PMX_MCIIORDRE_MASK |
1789                         PMX_MCIIOWRWE_MASK,
1790                 .val = 0,
1791         }, {
1792                 .reg = PAD_DIRECTION_SEL_2,
1793                 .mask = PMX_MCIIORDRE_MASK |
1794                         PMX_MCIIOWRWE_MASK,
1795                 .val = PMX_MCIIORDRE_MASK |
1796                         PMX_MCIIOWRWE_MASK,
1797         },
1798 };
1799 
1800 static struct spear_modemux i2c6_dis_sd_modemux[] = {
1801         {
1802                 .muxregs = i2c6_dis_sd_muxreg,
1803                 .nmuxregs = ARRAY_SIZE(i2c6_dis_sd_muxreg),
1804         },
1805 };
1806 
1807 static struct spear_pingroup i2c6_dis_sd_pingroup = {
1808         .name = "i2c6_dis_sd_grp",
1809         .pins = i2c6_dis_sd_pins,
1810         .npins = ARRAY_SIZE(i2c6_dis_sd_pins),
1811         .modemuxs = i2c6_dis_sd_modemux,
1812         .nmodemuxs = ARRAY_SIZE(i2c6_dis_sd_modemux),
1813 };
1814 
1815 /* Pad multiplexing for i2c7_dis_sd device */
1816 static const unsigned i2c7_dis_sd_pins[] = { 238, 239 };
1817 static struct spear_muxreg i2c7_dis_sd_muxreg[] = {
1818         {
1819                 .reg = PAD_FUNCTION_EN_2,
1820                 .mask = PMX_MCIRESETCF_MASK |
1821                         PMX_MCICS0CE_MASK,
1822                 .val = 0,
1823         }, {
1824                 .reg = PAD_DIRECTION_SEL_2,
1825                 .mask = PMX_MCIRESETCF_MASK |
1826                         PMX_MCICS0CE_MASK,
1827                 .val = PMX_MCIRESETCF_MASK |
1828                         PMX_MCICS0CE_MASK,
1829         },
1830 };
1831 
1832 static struct spear_modemux i2c7_dis_sd_modemux[] = {
1833         {
1834                 .muxregs = i2c7_dis_sd_muxreg,
1835                 .nmuxregs = ARRAY_SIZE(i2c7_dis_sd_muxreg),
1836         },
1837 };
1838 
1839 static struct spear_pingroup i2c7_dis_sd_pingroup = {
1840         .name = "i2c7_dis_sd_grp",
1841         .pins = i2c7_dis_sd_pins,
1842         .npins = ARRAY_SIZE(i2c7_dis_sd_pins),
1843         .modemuxs = i2c7_dis_sd_modemux,
1844         .nmodemuxs = ARRAY_SIZE(i2c7_dis_sd_modemux),
1845 };
1846 
1847 static const char *const i2c_6_7_grps[] = { "i2c6_dis_sd_grp",
1848         "i2c7_dis_sd_grp", "i2c_6_7_dis_kbd_grp" };
1849 static struct spear_function i2c_6_7_function = {
1850         .name = "i2c_6_7",
1851         .groups = i2c_6_7_grps,
1852         .ngroups = ARRAY_SIZE(i2c_6_7_grps),
1853 };
1854 
1855 /* Pad multiplexing for can0_dis_nor device */
1856 /* Muxed with NOR */
1857 static const unsigned can0_dis_nor_pins[] = { 56, 57 };
1858 static struct spear_muxreg can0_dis_nor_muxreg[] = {
1859         {
1860                 .reg = PAD_FUNCTION_EN_0,
1861                 .mask = PMX_NFRSTPWDWN2_MASK,
1862                 .val = 0,
1863         }, {
1864                 .reg = PAD_FUNCTION_EN_1,
1865                 .mask = PMX_NFRSTPWDWN3_MASK,
1866                 .val = 0,
1867         }, {
1868                 .reg = PAD_DIRECTION_SEL_0,
1869                 .mask = PMX_NFRSTPWDWN2_MASK,
1870                 .val = PMX_NFRSTPWDWN2_MASK,
1871         }, {
1872                 .reg = PAD_DIRECTION_SEL_1,
1873                 .mask = PMX_NFRSTPWDWN3_MASK,
1874                 .val = PMX_NFRSTPWDWN3_MASK,
1875         },
1876 };
1877 
1878 static struct spear_modemux can0_dis_nor_modemux[] = {
1879         {
1880                 .muxregs = can0_dis_nor_muxreg,
1881                 .nmuxregs = ARRAY_SIZE(can0_dis_nor_muxreg),
1882         },
1883 };
1884 
1885 static struct spear_pingroup can0_dis_nor_pingroup = {
1886         .name = "can0_dis_nor_grp",
1887         .pins = can0_dis_nor_pins,
1888         .npins = ARRAY_SIZE(can0_dis_nor_pins),
1889         .modemuxs = can0_dis_nor_modemux,
1890         .nmodemuxs = ARRAY_SIZE(can0_dis_nor_modemux),
1891 };
1892 
1893 /* Pad multiplexing for can0_dis_sd device */
1894 /* Muxed with SD/MMC */
1895 static const unsigned can0_dis_sd_pins[] = { 240, 241 };
1896 static struct spear_muxreg can0_dis_sd_muxreg[] = {
1897         {
1898                 .reg = PAD_FUNCTION_EN_2,
1899                 .mask = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1900                 .val = 0,
1901         }, {
1902                 .reg = PAD_DIRECTION_SEL_2,
1903                 .mask = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1904                 .val = PMX_MCICFINTR_MASK | PMX_MCIIORDY_MASK,
1905         },
1906 };
1907 
1908 static struct spear_modemux can0_dis_sd_modemux[] = {
1909         {
1910                 .muxregs = can0_dis_sd_muxreg,
1911                 .nmuxregs = ARRAY_SIZE(can0_dis_sd_muxreg),
1912         },
1913 };
1914 
1915 static struct spear_pingroup can0_dis_sd_pingroup = {
1916         .name = "can0_dis_sd_grp",
1917         .pins = can0_dis_sd_pins,
1918         .npins = ARRAY_SIZE(can0_dis_sd_pins),
1919         .modemuxs = can0_dis_sd_modemux,
1920         .nmodemuxs = ARRAY_SIZE(can0_dis_sd_modemux),
1921 };
1922 
1923 static const char *const can0_grps[] = { "can0_dis_nor_grp", "can0_dis_sd_grp"
1924 };
1925 static struct spear_function can0_function = {
1926         .name = "can0",
1927         .groups = can0_grps,
1928         .ngroups = ARRAY_SIZE(can0_grps),
1929 };
1930 
1931 /* Pad multiplexing for can1_dis_sd device */
1932 /* Muxed with SD/MMC */
1933 static const unsigned can1_dis_sd_pins[] = { 242, 243 };
1934 static struct spear_muxreg can1_dis_sd_muxreg[] = {
1935         {
1936                 .reg = PAD_FUNCTION_EN_2,
1937                 .mask = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1938                 .val = 0,
1939         }, {
1940                 .reg = PAD_DIRECTION_SEL_2,
1941                 .mask = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1942                 .val = PMX_MCICS1_MASK | PMX_MCIDMAACK_MASK,
1943         },
1944 };
1945 
1946 static struct spear_modemux can1_dis_sd_modemux[] = {
1947         {
1948                 .muxregs = can1_dis_sd_muxreg,
1949                 .nmuxregs = ARRAY_SIZE(can1_dis_sd_muxreg),
1950         },
1951 };
1952 
1953 static struct spear_pingroup can1_dis_sd_pingroup = {
1954         .name = "can1_dis_sd_grp",
1955         .pins = can1_dis_sd_pins,
1956         .npins = ARRAY_SIZE(can1_dis_sd_pins),
1957         .modemuxs = can1_dis_sd_modemux,
1958         .nmodemuxs = ARRAY_SIZE(can1_dis_sd_modemux),
1959 };
1960 
1961 /* Pad multiplexing for can1_dis_kbd device */
1962 /* Muxed with KBD */
1963 static const unsigned can1_dis_kbd_pins[] = { 201, 202 };
1964 static struct spear_muxreg can1_dis_kbd_muxreg[] = {
1965         {
1966                 .reg = PAD_FUNCTION_EN_1,
1967                 .mask = PMX_KBD_ROWCOL25_MASK,
1968                 .val = 0,
1969         }, {
1970                 .reg = PAD_DIRECTION_SEL_1,
1971                 .mask = PMX_KBD_ROWCOL25_MASK,
1972                 .val = PMX_KBD_ROWCOL25_MASK,
1973         },
1974 };
1975 
1976 static struct spear_modemux can1_dis_kbd_modemux[] = {
1977         {
1978                 .muxregs = can1_dis_kbd_muxreg,
1979                 .nmuxregs = ARRAY_SIZE(can1_dis_kbd_muxreg),
1980         },
1981 };
1982 
1983 static struct spear_pingroup can1_dis_kbd_pingroup = {
1984         .name = "can1_dis_kbd_grp",
1985         .pins = can1_dis_kbd_pins,
1986         .npins = ARRAY_SIZE(can1_dis_kbd_pins),
1987         .modemuxs = can1_dis_kbd_modemux,
1988         .nmodemuxs = ARRAY_SIZE(can1_dis_kbd_modemux),
1989 };
1990 
1991 static const char *const can1_grps[] = { "can1_dis_sd_grp", "can1_dis_kbd_grp"
1992 };
1993 static struct spear_function can1_function = {
1994         .name = "can1",
1995         .groups = can1_grps,
1996         .ngroups = ARRAY_SIZE(can1_grps),
1997 };
1998 
1999 /* Pad multiplexing for (ras-ip) pci device */
2000 static const unsigned pci_pins[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 18,
2001         19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2002         37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2003         55, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 };
2004 
2005 static struct spear_muxreg pci_muxreg[] = {
2006         {
2007                 .reg = PAD_FUNCTION_EN_0,
2008                 .mask = PMX_MCI_DATA8_15_MASK,
2009                 .val = 0,
2010         }, {
2011                 .reg = PAD_FUNCTION_EN_1,
2012                 .mask = PMX_PCI_REG1_MASK,
2013                 .val = 0,
2014         }, {
2015                 .reg = PAD_FUNCTION_EN_2,
2016                 .mask = PMX_PCI_REG2_MASK,
2017                 .val = 0,
2018         }, {
2019                 .reg = PAD_DIRECTION_SEL_0,
2020                 .mask = PMX_MCI_DATA8_15_MASK,
2021                 .val = PMX_MCI_DATA8_15_MASK,
2022         }, {
2023                 .reg = PAD_DIRECTION_SEL_1,
2024                 .mask = PMX_PCI_REG1_MASK,
2025                 .val = PMX_PCI_REG1_MASK,
2026         }, {
2027                 .reg = PAD_DIRECTION_SEL_2,
2028                 .mask = PMX_PCI_REG2_MASK,
2029                 .val = PMX_PCI_REG2_MASK,
2030         },
2031 };
2032 
2033 static struct spear_modemux pci_modemux[] = {
2034         {
2035                 .muxregs = pci_muxreg,
2036                 .nmuxregs = ARRAY_SIZE(pci_muxreg),
2037         },
2038 };
2039 
2040 static struct spear_pingroup pci_pingroup = {
2041         .name = "pci_grp",
2042         .pins = pci_pins,
2043         .npins = ARRAY_SIZE(pci_pins),
2044         .modemuxs = pci_modemux,
2045         .nmodemuxs = ARRAY_SIZE(pci_modemux),
2046 };
2047 
2048 static const char *const pci_grps[] = { "pci_grp" };
2049 static struct spear_function pci_function = {
2050         .name = "pci",
2051         .groups = pci_grps,
2052         .ngroups = ARRAY_SIZE(pci_grps),
2053 };
2054 
2055 /* pad multiplexing for (fix-part) pcie0 device */
2056 static struct spear_muxreg pcie0_muxreg[] = {
2057         {
2058                 .reg = PCIE_SATA_CFG,
2059                 .mask = PCIE_CFG_VAL(0),
2060                 .val = PCIE_CFG_VAL(0),
2061         },
2062 };
2063 
2064 static struct spear_modemux pcie0_modemux[] = {
2065         {
2066                 .muxregs = pcie0_muxreg,
2067                 .nmuxregs = ARRAY_SIZE(pcie0_muxreg),
2068         },
2069 };
2070 
2071 static struct spear_pingroup pcie0_pingroup = {
2072         .name = "pcie0_grp",
2073         .modemuxs = pcie0_modemux,
2074         .nmodemuxs = ARRAY_SIZE(pcie0_modemux),
2075 };
2076 
2077 /* pad multiplexing for (fix-part) pcie1 device */
2078 static struct spear_muxreg pcie1_muxreg[] = {
2079         {
2080                 .reg = PCIE_SATA_CFG,
2081                 .mask = PCIE_CFG_VAL(1),
2082                 .val = PCIE_CFG_VAL(1),
2083         },
2084 };
2085 
2086 static struct spear_modemux pcie1_modemux[] = {
2087         {
2088                 .muxregs = pcie1_muxreg,
2089                 .nmuxregs = ARRAY_SIZE(pcie1_muxreg),
2090         },
2091 };
2092 
2093 static struct spear_pingroup pcie1_pingroup = {
2094         .name = "pcie1_grp",
2095         .modemuxs = pcie1_modemux,
2096         .nmodemuxs = ARRAY_SIZE(pcie1_modemux),
2097 };
2098 
2099 /* pad multiplexing for (fix-part) pcie2 device */
2100 static struct spear_muxreg pcie2_muxreg[] = {
2101         {
2102                 .reg = PCIE_SATA_CFG,
2103                 .mask = PCIE_CFG_VAL(2),
2104                 .val = PCIE_CFG_VAL(2),
2105         },
2106 };
2107 
2108 static struct spear_modemux pcie2_modemux[] = {
2109         {
2110                 .muxregs = pcie2_muxreg,
2111                 .nmuxregs = ARRAY_SIZE(pcie2_muxreg),
2112         },
2113 };
2114 
2115 static struct spear_pingroup pcie2_pingroup = {
2116         .name = "pcie2_grp",
2117         .modemuxs = pcie2_modemux,
2118         .nmodemuxs = ARRAY_SIZE(pcie2_modemux),
2119 };
2120 
2121 static const char *const pcie_grps[] = { "pcie0_grp", "pcie1_grp", "pcie2_grp"
2122 };
2123 static struct spear_function pcie_function = {
2124         .name = "pci_express",
2125         .groups = pcie_grps,
2126         .ngroups = ARRAY_SIZE(pcie_grps),
2127 };
2128 
2129 /* pad multiplexing for sata0 device */
2130 static struct spear_muxreg sata0_muxreg[] = {
2131         {
2132                 .reg = PCIE_SATA_CFG,
2133                 .mask = SATA_CFG_VAL(0),
2134                 .val = SATA_CFG_VAL(0),
2135         },
2136 };
2137 
2138 static struct spear_modemux sata0_modemux[] = {
2139         {
2140                 .muxregs = sata0_muxreg,
2141                 .nmuxregs = ARRAY_SIZE(sata0_muxreg),
2142         },
2143 };
2144 
2145 static struct spear_pingroup sata0_pingroup = {
2146         .name = "sata0_grp",
2147         .modemuxs = sata0_modemux,
2148         .nmodemuxs = ARRAY_SIZE(sata0_modemux),
2149 };
2150 
2151 /* pad multiplexing for sata1 device */
2152 static struct spear_muxreg sata1_muxreg[] = {
2153         {
2154                 .reg = PCIE_SATA_CFG,
2155                 .mask = SATA_CFG_VAL(1),
2156                 .val = SATA_CFG_VAL(1),
2157         },
2158 };
2159 
2160 static struct spear_modemux sata1_modemux[] = {
2161         {
2162                 .muxregs = sata1_muxreg,
2163                 .nmuxregs = ARRAY_SIZE(sata1_muxreg),
2164         },
2165 };
2166 
2167 static struct spear_pingroup sata1_pingroup = {
2168         .name = "sata1_grp",
2169         .modemuxs = sata1_modemux,
2170         .nmodemuxs = ARRAY_SIZE(sata1_modemux),
2171 };
2172 
2173 /* pad multiplexing for sata2 device */
2174 static struct spear_muxreg sata2_muxreg[] = {
2175         {
2176                 .reg = PCIE_SATA_CFG,
2177                 .mask = SATA_CFG_VAL(2),
2178                 .val = SATA_CFG_VAL(2),
2179         },
2180 };
2181 
2182 static struct spear_modemux sata2_modemux[] = {
2183         {
2184                 .muxregs = sata2_muxreg,
2185                 .nmuxregs = ARRAY_SIZE(sata2_muxreg),
2186         },
2187 };
2188 
2189 static struct spear_pingroup sata2_pingroup = {
2190         .name = "sata2_grp",
2191         .modemuxs = sata2_modemux,
2192         .nmodemuxs = ARRAY_SIZE(sata2_modemux),
2193 };
2194 
2195 static const char *const sata_grps[] = { "sata0_grp", "sata1_grp", "sata2_grp"
2196 };
2197 static struct spear_function sata_function = {
2198         .name = "sata",
2199         .groups = sata_grps,
2200         .ngroups = ARRAY_SIZE(sata_grps),
2201 };
2202 
2203 /* Pad multiplexing for ssp1_dis_kbd device */
2204 static const unsigned ssp1_dis_kbd_pins[] = { 203, 204, 205, 206 };
2205 static struct spear_muxreg ssp1_dis_kbd_muxreg[] = {
2206         {
2207                 .reg = PAD_FUNCTION_EN_1,
2208                 .mask = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2209                         PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2210                         PMX_NFCE2_MASK,
2211                 .val = 0,
2212         }, {
2213                 .reg = PAD_DIRECTION_SEL_1,
2214                 .mask = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2215                         PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2216                         PMX_NFCE2_MASK,
2217                 .val = PMX_KBD_ROWCOL25_MASK | PMX_KBD_COL1_MASK |
2218                         PMX_KBD_COL0_MASK | PMX_NFIO8_15_MASK | PMX_NFCE1_MASK |
2219                         PMX_NFCE2_MASK,
2220         },
2221 };
2222 
2223 static struct spear_modemux ssp1_dis_kbd_modemux[] = {
2224         {
2225                 .muxregs = ssp1_dis_kbd_muxreg,
2226                 .nmuxregs = ARRAY_SIZE(ssp1_dis_kbd_muxreg),
2227         },
2228 };
2229 
2230 static struct spear_pingroup ssp1_dis_kbd_pingroup = {
2231         .name = "ssp1_dis_kbd_grp",
2232         .pins = ssp1_dis_kbd_pins,
2233         .npins = ARRAY_SIZE(ssp1_dis_kbd_pins),
2234         .modemuxs = ssp1_dis_kbd_modemux,
2235         .nmodemuxs = ARRAY_SIZE(ssp1_dis_kbd_modemux),
2236 };
2237 
2238 /* Pad multiplexing for ssp1_dis_sd device */
2239 static const unsigned ssp1_dis_sd_pins[] = { 224, 226, 227, 228 };
2240 static struct spear_muxreg ssp1_dis_sd_muxreg[] = {
2241         {
2242                 .reg = PAD_FUNCTION_EN_2,
2243                 .mask = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2244                         PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2245                 .val = 0,
2246         }, {
2247                 .reg = PAD_DIRECTION_SEL_2,
2248                 .mask = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2249                         PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2250                 .val = PMX_MCIADDR0ALE_MASK | PMX_MCIADDR2_MASK |
2251                         PMX_MCICECF_MASK | PMX_MCICEXD_MASK,
2252         },
2253 };
2254 
2255 static struct spear_modemux ssp1_dis_sd_modemux[] = {
2256         {
2257                 .muxregs = ssp1_dis_sd_muxreg,
2258                 .nmuxregs = ARRAY_SIZE(ssp1_dis_sd_muxreg),
2259         },
2260 };
2261 
2262 static struct spear_pingroup ssp1_dis_sd_pingroup = {
2263         .name = "ssp1_dis_sd_grp",
2264         .pins = ssp1_dis_sd_pins,
2265         .npins = ARRAY_SIZE(ssp1_dis_sd_pins),
2266         .modemuxs = ssp1_dis_sd_modemux,
2267         .nmodemuxs = ARRAY_SIZE(ssp1_dis_sd_modemux),
2268 };
2269 
2270 static const char *const ssp1_grps[] = { "ssp1_dis_kbd_grp",
2271         "ssp1_dis_sd_grp" };
2272 static struct spear_function ssp1_function = {
2273         .name = "ssp1",
2274         .groups = ssp1_grps,
2275         .ngroups = ARRAY_SIZE(ssp1_grps),
2276 };
2277 
2278 /* Pad multiplexing for gpt64 device */
2279 static const unsigned gpt64_pins[] = { 230, 231, 232, 245 };
2280 static struct spear_muxreg gpt64_muxreg[] = {
2281         {
2282                 .reg = PAD_FUNCTION_EN_2,
2283                 .mask = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2284                         | PMX_MCILEDS_MASK,
2285                 .val = 0,
2286         }, {
2287                 .reg = PAD_DIRECTION_SEL_2,
2288                 .mask = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2289                         | PMX_MCILEDS_MASK,
2290                 .val = PMX_MCICDCF1_MASK | PMX_MCICDCF2_MASK | PMX_MCICDXD_MASK
2291                         | PMX_MCILEDS_MASK,
2292         },
2293 };
2294 
2295 static struct spear_modemux gpt64_modemux[] = {
2296         {
2297                 .muxregs = gpt64_muxreg,
2298                 .nmuxregs = ARRAY_SIZE(gpt64_muxreg),
2299         },
2300 };
2301 
2302 static struct spear_pingroup gpt64_pingroup = {
2303         .name = "gpt64_grp",
2304         .pins = gpt64_pins,
2305         .npins = ARRAY_SIZE(gpt64_pins),
2306         .modemuxs = gpt64_modemux,
2307         .nmodemuxs = ARRAY_SIZE(gpt64_modemux),
2308 };
2309 
2310 static const char *const gpt64_grps[] = { "gpt64_grp" };
2311 static struct spear_function gpt64_function = {
2312         .name = "gpt64",
2313         .groups = gpt64_grps,
2314         .ngroups = ARRAY_SIZE(gpt64_grps),
2315 };
2316 
2317 /* pingroups */
2318 static struct spear_pingroup *spear1310_pingroups[] = {
2319         &i2c0_pingroup,
2320         &ssp0_pingroup,
2321         &i2s0_pingroup,
2322         &i2s1_pingroup,
2323         &clcd_pingroup,
2324         &clcd_high_res_pingroup,
2325         &arm_gpio_pingroup,
2326         &smi_2_chips_pingroup,
2327         &smi_4_chips_pingroup,
2328         &gmii_pingroup,
2329         &rgmii_pingroup,
2330         &smii_0_1_2_pingroup,
2331         &ras_mii_txclk_pingroup,
2332         &nand_8bit_pingroup,
2333         &nand_16bit_pingroup,
2334         &nand_4_chips_pingroup,
2335         &keyboard_6x6_pingroup,
2336         &keyboard_rowcol6_8_pingroup,
2337         &uart0_pingroup,
2338         &uart0_modem_pingroup,
2339         &gpt0_tmr0_pingroup,
2340         &gpt0_tmr1_pingroup,
2341         &gpt1_tmr0_pingroup,
2342         &gpt1_tmr1_pingroup,
2343         &sdhci_pingroup,
2344         &cf_pingroup,
2345         &xd_pingroup,
2346         &touch_xy_pingroup,
2347         &ssp0_cs0_pingroup,
2348         &ssp0_cs1_2_pingroup,
2349         &uart_1_dis_i2c_pingroup,
2350         &uart_1_dis_sd_pingroup,
2351         &uart_2_3_pingroup,
2352         &uart_4_pingroup,
2353         &uart_5_pingroup,
2354         &rs485_0_1_tdm_0_1_pingroup,
2355         &i2c_1_2_pingroup,
2356         &i2c3_dis_smi_clcd_pingroup,
2357         &i2c3_dis_sd_i2s0_pingroup,
2358         &i2c_4_5_dis_smi_pingroup,
2359         &i2c4_dis_sd_pingroup,
2360         &i2c5_dis_sd_pingroup,
2361         &i2c_6_7_dis_kbd_pingroup,
2362         &i2c6_dis_sd_pingroup,
2363         &i2c7_dis_sd_pingroup,
2364         &can0_dis_nor_pingroup,
2365         &can0_dis_sd_pingroup,
2366         &can1_dis_sd_pingroup,
2367         &can1_dis_kbd_pingroup,
2368         &pci_pingroup,
2369         &pcie0_pingroup,
2370         &pcie1_pingroup,
2371         &pcie2_pingroup,
2372         &sata0_pingroup,
2373         &sata1_pingroup,
2374         &sata2_pingroup,
2375         &ssp1_dis_kbd_pingroup,
2376         &ssp1_dis_sd_pingroup,
2377         &gpt64_pingroup,
2378 };
2379 
2380 /* functions */
2381 static struct spear_function *spear1310_functions[] = {
2382         &i2c0_function,
2383         &ssp0_function,
2384         &i2s0_function,
2385         &i2s1_function,
2386         &clcd_function,
2387         &arm_gpio_function,
2388         &smi_function,
2389         &gmii_function,
2390         &rgmii_function,
2391         &smii_0_1_2_function,
2392         &ras_mii_txclk_function,
2393         &nand_function,
2394         &keyboard_function,
2395         &uart0_function,
2396         &gpt0_function,
2397         &gpt1_function,
2398         &sdhci_function,
2399         &cf_function,
2400         &xd_function,
2401         &touch_xy_function,
2402         &uart1_function,
2403         &uart2_3_function,
2404         &uart4_function,
2405         &uart5_function,
2406         &rs485_0_1_tdm_0_1_function,
2407         &i2c_1_2_function,
2408         &i2c3_unction,
2409         &i2c_4_5_function,
2410         &i2c_6_7_function,
2411         &can0_function,
2412         &can1_function,
2413         &pci_function,
2414         &pcie_function,
2415         &sata_function,
2416         &ssp1_function,
2417         &gpt64_function,
2418 };
2419 
2420 static const unsigned pin18[] = { 18, };
2421 static const unsigned pin19[] = { 19, };
2422 static const unsigned pin20[] = { 20, };
2423 static const unsigned pin21[] = { 21, };
2424 static const unsigned pin22[] = { 22, };
2425 static const unsigned pin23[] = { 23, };
2426 static const unsigned pin54[] = { 54, };
2427 static const unsigned pin55[] = { 55, };
2428 static const unsigned pin56[] = { 56, };
2429 static const unsigned pin57[] = { 57, };
2430 static const unsigned pin58[] = { 58, };
2431 static const unsigned pin59[] = { 59, };
2432 static const unsigned pin60[] = { 60, };
2433 static const unsigned pin61[] = { 61, };
2434 static const unsigned pin62[] = { 62, };
2435 static const unsigned pin63[] = { 63, };
2436 static const unsigned pin143[] = { 143, };
2437 static const unsigned pin144[] = { 144, };
2438 static const unsigned pin145[] = { 145, };
2439 static const unsigned pin146[] = { 146, };
2440 static const unsigned pin147[] = { 147, };
2441 static const unsigned pin148[] = { 148, };
2442 static const unsigned pin149[] = { 149, };
2443 static const unsigned pin150[] = { 150, };
2444 static const unsigned pin151[] = { 151, };
2445 static const unsigned pin152[] = { 152, };
2446 static const unsigned pin205[] = { 205, };
2447 static const unsigned pin206[] = { 206, };
2448 static const unsigned pin211[] = { 211, };
2449 static const unsigned pin212[] = { 212, };
2450 static const unsigned pin213[] = { 213, };
2451 static const unsigned pin214[] = { 214, };
2452 static const unsigned pin215[] = { 215, };
2453 static const unsigned pin216[] = { 216, };
2454 static const unsigned pin217[] = { 217, };
2455 static const unsigned pin218[] = { 218, };
2456 static const unsigned pin219[] = { 219, };
2457 static const unsigned pin220[] = { 220, };
2458 static const unsigned pin221[] = { 221, };
2459 static const unsigned pin222[] = { 222, };
2460 static const unsigned pin223[] = { 223, };
2461 static const unsigned pin224[] = { 224, };
2462 static const unsigned pin225[] = { 225, };
2463 static const unsigned pin226[] = { 226, };
2464 static const unsigned pin227[] = { 227, };
2465 static const unsigned pin228[] = { 228, };
2466 static const unsigned pin229[] = { 229, };
2467 static const unsigned pin230[] = { 230, };
2468 static const unsigned pin231[] = { 231, };
2469 static const unsigned pin232[] = { 232, };
2470 static const unsigned pin233[] = { 233, };
2471 static const unsigned pin234[] = { 234, };
2472 static const unsigned pin235[] = { 235, };
2473 static const unsigned pin236[] = { 236, };
2474 static const unsigned pin237[] = { 237, };
2475 static const unsigned pin238[] = { 238, };
2476 static const unsigned pin239[] = { 239, };
2477 static const unsigned pin240[] = { 240, };
2478 static const unsigned pin241[] = { 241, };
2479 static const unsigned pin242[] = { 242, };
2480 static const unsigned pin243[] = { 243, };
2481 static const unsigned pin244[] = { 244, };
2482 static const unsigned pin245[] = { 245, };
2483 
2484 static const unsigned pin_grp0[] = { 173, 174, };
2485 static const unsigned pin_grp1[] = { 175, 185, 188, 197, 198, };
2486 static const unsigned pin_grp2[] = { 176, 177, 178, 179, 184, 186, 187, 189,
2487         190, 191, 192, };
2488 static const unsigned pin_grp3[] = { 180, 181, 182, 183, 193, 194, 195, 196, };
2489 static const unsigned pin_grp4[] = { 199, 200, };
2490 static const unsigned pin_grp5[] = { 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2491         75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, };
2492 static const unsigned pin_grp6[] = { 86, 87, 88, 89, 90, 91, 92, 93, };
2493 static const unsigned pin_grp7[] = { 98, 99, };
2494 static const unsigned pin_grp8[] = { 158, 159, 160, 161, 162, 163, 164, 165,
2495         166, 167, 168, 169, 170, 171, 172, };
2496 
2497 /* Define muxreg arrays */
2498 DEFINE_2_MUXREG(i2c0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_I2C0_MASK, 0, 1);
2499 DEFINE_2_MUXREG(ssp0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_SSP0_MASK, 0, 1);
2500 DEFINE_2_MUXREG(ssp0_cs0_pins, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_SSP0_CS0_MASK, 0, 1);
2501 DEFINE_2_MUXREG(ssp0_cs1_2_pins, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_SSP0_CS1_2_MASK, 0, 1);
2502 DEFINE_2_MUXREG(i2s0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_I2S0_MASK, 0, 1);
2503 DEFINE_2_MUXREG(i2s1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_I2S1_MASK, 0, 1);
2504 DEFINE_2_MUXREG(clcd_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_CLCD1_MASK, 0, 1);
2505 DEFINE_2_MUXREG(clcd_high_res_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_CLCD2_MASK, 0, 1);
2506 DEFINE_2_MUXREG(pin18, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO15_MASK, 0, 1);
2507 DEFINE_2_MUXREG(pin19, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO14_MASK, 0, 1);
2508 DEFINE_2_MUXREG(pin20, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO13_MASK, 0, 1);
2509 DEFINE_2_MUXREG(pin21, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO12_MASK, 0, 1);
2510 DEFINE_2_MUXREG(pin22, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO11_MASK, 0, 1);
2511 DEFINE_2_MUXREG(pin23, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO10_MASK, 0, 1);
2512 DEFINE_2_MUXREG(pin143, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO00_MASK, 0, 1);
2513 DEFINE_2_MUXREG(pin144, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO01_MASK, 0, 1);
2514 DEFINE_2_MUXREG(pin145, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO02_MASK, 0, 1);
2515 DEFINE_2_MUXREG(pin146, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO03_MASK, 0, 1);
2516 DEFINE_2_MUXREG(pin147, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO04_MASK, 0, 1);
2517 DEFINE_2_MUXREG(pin148, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO05_MASK, 0, 1);
2518 DEFINE_2_MUXREG(pin149, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO06_MASK, 0, 1);
2519 DEFINE_2_MUXREG(pin150, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO07_MASK, 0, 1);
2520 DEFINE_2_MUXREG(pin151, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO08_MASK, 0, 1);
2521 DEFINE_2_MUXREG(pin152, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_EGPIO09_MASK, 0, 1);
2522 DEFINE_2_MUXREG(smi_2_chips_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_SMI_MASK, 0, 1);
2523 DEFINE_2_MUXREG(pin54, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_SMINCS3_MASK, 0, 1);
2524 DEFINE_2_MUXREG(pin55, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_SMINCS2_MASK, 0, 1);
2525 DEFINE_2_MUXREG(pin56, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NFRSTPWDWN3_MASK, 0, 1);
2526 DEFINE_2_MUXREG(pin57, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN2_MASK, 0, 1);
2527 DEFINE_2_MUXREG(pin58, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN1_MASK, 0, 1);
2528 DEFINE_2_MUXREG(pin59, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFRSTPWDWN0_MASK, 0, 1);
2529 DEFINE_2_MUXREG(pin60, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFWPRT3_MASK, 0, 1);
2530 DEFINE_2_MUXREG(pin61, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFCE3_MASK, 0, 1);
2531 DEFINE_2_MUXREG(pin62, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD25_MASK, 0, 1);
2532 DEFINE_2_MUXREG(pin63, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD24_MASK, 0, 1);
2533 DEFINE_2_MUXREG(pin_grp0, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIICLK_MASK, 0, 1);
2534 DEFINE_2_MUXREG(pin_grp1, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIICOL_CRS_XFERER_MIITXCLK_MASK, 0, 1);
2535 DEFINE_2_MUXREG(pin_grp2, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_RXCLK_RDV_TXEN_D03_MASK, 0, 1);
2536 DEFINE_2_MUXREG(pin_grp3, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_GMIID47_MASK, 0, 1);
2537 DEFINE_2_MUXREG(pin_grp4, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_MDC_MDIO_MASK, 0, 1);
2538 DEFINE_2_MUXREG(pin_grp5, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_NFAD23_MASK, 0, 1);
2539 DEFINE_2_MUXREG(pin_grp6, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_MCI_DATA8_15_MASK, 0, 1);
2540 DEFINE_2_MUXREG(pin_grp7, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NFCE2_MASK, 0, 1);
2541 DEFINE_2_MUXREG(pin_grp8, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NAND8_MASK, 0, 1);
2542 DEFINE_2_MUXREG(nand_16bit_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_NAND16BIT_1_MASK, 0, 1);
2543 DEFINE_2_MUXREG(pin205, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_COL1_MASK | PMX_NFCE1_MASK, 0, 1);
2544 DEFINE_2_MUXREG(pin206, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_COL0_MASK | PMX_NFCE2_MASK, 0, 1);
2545 DEFINE_2_MUXREG(pin211, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROW1_MASK | PMX_NFWPRT1_MASK, 0, 1);
2546 DEFINE_2_MUXREG(pin212, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROW0_MASK | PMX_NFWPRT2_MASK, 0, 1);
2547 DEFINE_2_MUXREG(pin213, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA0_MASK, 0, 1);
2548 DEFINE_2_MUXREG(pin214, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA1_MASK, 0, 1);
2549 DEFINE_2_MUXREG(pin215, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA2_MASK, 0, 1);
2550 DEFINE_2_MUXREG(pin216, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA3_MASK, 0, 1);
2551 DEFINE_2_MUXREG(pin217, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_MCIDATA4_MASK, 0, 1);
2552 DEFINE_2_MUXREG(pin218, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA5_MASK, 0, 1);
2553 DEFINE_2_MUXREG(pin219, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA6_MASK, 0, 1);
2554 DEFINE_2_MUXREG(pin220, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA7_MASK, 0, 1);
2555 DEFINE_2_MUXREG(pin221, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA1SD_MASK, 0, 1);
2556 DEFINE_2_MUXREG(pin222, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA2SD_MASK, 0, 1);
2557 DEFINE_2_MUXREG(pin223, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATA3SD_MASK, 0, 1);
2558 DEFINE_2_MUXREG(pin224, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR0ALE_MASK, 0, 1);
2559 DEFINE_2_MUXREG(pin225, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR1CLECLK_MASK, 0, 1);
2560 DEFINE_2_MUXREG(pin226, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIADDR2_MASK, 0, 1);
2561 DEFINE_2_MUXREG(pin227, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICECF_MASK, 0, 1);
2562 DEFINE_2_MUXREG(pin228, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICEXD_MASK, 0, 1);
2563 DEFINE_2_MUXREG(pin229, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICESDMMC_MASK, 0, 1);
2564 DEFINE_2_MUXREG(pin230, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDCF1_MASK, 0, 1);
2565 DEFINE_2_MUXREG(pin231, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDCF2_MASK, 0, 1);
2566 DEFINE_2_MUXREG(pin232, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDXD_MASK, 0, 1);
2567 DEFINE_2_MUXREG(pin233, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICDSDMMC_MASK, 0, 1);
2568 DEFINE_2_MUXREG(pin234, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDATADIR_MASK, 0, 1);
2569 DEFINE_2_MUXREG(pin235, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDMARQWP_MASK, 0, 1);
2570 DEFINE_2_MUXREG(pin236, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIORDRE_MASK, 0, 1);
2571 DEFINE_2_MUXREG(pin237, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIOWRWE_MASK, 0, 1);
2572 DEFINE_2_MUXREG(pin238, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIRESETCF_MASK, 0, 1);
2573 DEFINE_2_MUXREG(pin239, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICS0CE_MASK, 0, 1);
2574 DEFINE_2_MUXREG(pin240, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICFINTR_MASK, 0, 1);
2575 DEFINE_2_MUXREG(pin241, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIIORDY_MASK, 0, 1);
2576 DEFINE_2_MUXREG(pin242, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCICS1_MASK, 0, 1);
2577 DEFINE_2_MUXREG(pin243, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCIDMAACK_MASK, 0, 1);
2578 DEFINE_2_MUXREG(pin244, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCISDCMD_MASK, 0, 1);
2579 DEFINE_2_MUXREG(pin245, PAD_FUNCTION_EN_2, PAD_DIRECTION_SEL_2, PMX_MCILEDS_MASK, 0, 1);
2580 DEFINE_2_MUXREG(keyboard_rowcol6_8_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_KBD_ROWCOL68_MASK, 0, 1);
2581 DEFINE_2_MUXREG(uart0_pins, PAD_FUNCTION_EN_0, PAD_DIRECTION_SEL_0, PMX_UART0_MASK, 0, 1);
2582 DEFINE_2_MUXREG(uart0_modem_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_UART0_MODEM_MASK, 0, 1);
2583 DEFINE_2_MUXREG(gpt0_tmr0_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT0_TMR0_MASK, 0, 1);
2584 DEFINE_2_MUXREG(gpt0_tmr1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT0_TMR1_MASK, 0, 1);
2585 DEFINE_2_MUXREG(gpt1_tmr0_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT1_TMR0_MASK, 0, 1);
2586 DEFINE_2_MUXREG(gpt1_tmr1_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_GPT1_TMR1_MASK, 0, 1);
2587 DEFINE_2_MUXREG(touch_xy_pins, PAD_FUNCTION_EN_1, PAD_DIRECTION_SEL_1, PMX_TOUCH_XY_MASK, 0, 1);
2588 
2589 static struct spear_gpio_pingroup spear1310_gpio_pingroup[] = {
2590         GPIO_PINGROUP(i2c0_pins),
2591         GPIO_PINGROUP(ssp0_pins),
2592         GPIO_PINGROUP(ssp0_cs0_pins),
2593         GPIO_PINGROUP(ssp0_cs1_2_pins),
2594         GPIO_PINGROUP(i2s0_pins),
2595         GPIO_PINGROUP(i2s1_pins),
2596         GPIO_PINGROUP(clcd_pins),
2597         GPIO_PINGROUP(clcd_high_res_pins),
2598         GPIO_PINGROUP(pin18),
2599         GPIO_PINGROUP(pin19),
2600         GPIO_PINGROUP(pin20),
2601         GPIO_PINGROUP(pin21),
2602         GPIO_PINGROUP(pin22),
2603         GPIO_PINGROUP(pin23),
2604         GPIO_PINGROUP(pin143),
2605         GPIO_PINGROUP(pin144),
2606         GPIO_PINGROUP(pin145),
2607         GPIO_PINGROUP(pin146),
2608         GPIO_PINGROUP(pin147),
2609         GPIO_PINGROUP(pin148),
2610         GPIO_PINGROUP(pin149),
2611         GPIO_PINGROUP(pin150),
2612         GPIO_PINGROUP(pin151),
2613         GPIO_PINGROUP(pin152),
2614         GPIO_PINGROUP(smi_2_chips_pins),
2615         GPIO_PINGROUP(pin54),
2616         GPIO_PINGROUP(pin55),
2617         GPIO_PINGROUP(pin56),
2618         GPIO_PINGROUP(pin57),
2619         GPIO_PINGROUP(pin58),
2620         GPIO_PINGROUP(pin59),
2621         GPIO_PINGROUP(pin60),
2622         GPIO_PINGROUP(pin61),
2623         GPIO_PINGROUP(pin62),
2624         GPIO_PINGROUP(pin63),
2625         GPIO_PINGROUP(pin_grp0),
2626         GPIO_PINGROUP(pin_grp1),
2627         GPIO_PINGROUP(pin_grp2),
2628         GPIO_PINGROUP(pin_grp3),
2629         GPIO_PINGROUP(pin_grp4),
2630         GPIO_PINGROUP(pin_grp5),
2631         GPIO_PINGROUP(pin_grp6),
2632         GPIO_PINGROUP(pin_grp7),
2633         GPIO_PINGROUP(pin_grp8),
2634         GPIO_PINGROUP(nand_16bit_pins),
2635         GPIO_PINGROUP(pin205),
2636         GPIO_PINGROUP(pin206),
2637         GPIO_PINGROUP(pin211),
2638         GPIO_PINGROUP(pin212),
2639         GPIO_PINGROUP(pin213),
2640         GPIO_PINGROUP(pin214),
2641         GPIO_PINGROUP(pin215),
2642         GPIO_PINGROUP(pin216),
2643         GPIO_PINGROUP(pin217),
2644         GPIO_PINGROUP(pin218),
2645         GPIO_PINGROUP(pin219),
2646         GPIO_PINGROUP(pin220),
2647         GPIO_PINGROUP(pin221),
2648         GPIO_PINGROUP(pin222),
2649         GPIO_PINGROUP(pin223),
2650         GPIO_PINGROUP(pin224),
2651         GPIO_PINGROUP(pin225),
2652         GPIO_PINGROUP(pin226),
2653         GPIO_PINGROUP(pin227),
2654         GPIO_PINGROUP(pin228),
2655         GPIO_PINGROUP(pin229),
2656         GPIO_PINGROUP(pin230),
2657         GPIO_PINGROUP(pin231),
2658         GPIO_PINGROUP(pin232),
2659         GPIO_PINGROUP(pin233),
2660         GPIO_PINGROUP(pin234),
2661         GPIO_PINGROUP(pin235),
2662         GPIO_PINGROUP(pin236),
2663         GPIO_PINGROUP(pin237),
2664         GPIO_PINGROUP(pin238),
2665         GPIO_PINGROUP(pin239),
2666         GPIO_PINGROUP(pin240),
2667         GPIO_PINGROUP(pin241),
2668         GPIO_PINGROUP(pin242),
2669         GPIO_PINGROUP(pin243),
2670         GPIO_PINGROUP(pin244),
2671         GPIO_PINGROUP(pin245),
2672         GPIO_PINGROUP(keyboard_rowcol6_8_pins),
2673         GPIO_PINGROUP(uart0_pins),
2674         GPIO_PINGROUP(uart0_modem_pins),
2675         GPIO_PINGROUP(gpt0_tmr0_pins),
2676         GPIO_PINGROUP(gpt0_tmr1_pins),
2677         GPIO_PINGROUP(gpt1_tmr0_pins),
2678         GPIO_PINGROUP(gpt1_tmr1_pins),
2679         GPIO_PINGROUP(touch_xy_pins),
2680 };
2681 
2682 static struct spear_pinctrl_machdata spear1310_machdata = {
2683         .pins = spear1310_pins,
2684         .npins = ARRAY_SIZE(spear1310_pins),
2685         .groups = spear1310_pingroups,
2686         .ngroups = ARRAY_SIZE(spear1310_pingroups),
2687         .functions = spear1310_functions,
2688         .nfunctions = ARRAY_SIZE(spear1310_functions),
2689         .gpio_pingroups = spear1310_gpio_pingroup,
2690         .ngpio_pingroups = ARRAY_SIZE(spear1310_gpio_pingroup),
2691         .modes_supported = false,
2692 };
2693 
2694 static const struct of_device_id spear1310_pinctrl_of_match[] = {
2695         {
2696                 .compatible = "st,spear1310-pinmux",
2697         },
2698         {},
2699 };
2700 
2701 static int spear1310_pinctrl_probe(struct platform_device *pdev)
2702 {
2703         return spear_pinctrl_probe(pdev, &spear1310_machdata);
2704 }
2705 
2706 static struct platform_driver spear1310_pinctrl_driver = {
2707         .driver = {
2708                 .name = DRIVER_NAME,
2709                 .of_match_table = spear1310_pinctrl_of_match,
2710         },
2711         .probe = spear1310_pinctrl_probe,
2712 };
2713 
2714 static int __init spear1310_pinctrl_init(void)
2715 {
2716         return platform_driver_register(&spear1310_pinctrl_driver);
2717 }
2718 arch_initcall(spear1310_pinctrl_init);

/* [<][>][^][v][top][bottom][index][help] */