linux/drivers/pinctrl/bcm/pinctrl-bcm281xx.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2013-2017 Broadcom
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public License as
   6 * published by the Free Software Foundation version 2.
   7 *
   8 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
   9 * kind, whether express or implied; without even the implied warranty
  10 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 * GNU General Public License for more details.
  12 */
  13
  14#include <linux/err.h>
  15#include <linux/io.h>
  16#include <linux/init.h>
  17#include <linux/of.h>
  18#include <linux/platform_device.h>
  19#include <linux/pinctrl/pinctrl.h>
  20#include <linux/pinctrl/pinmux.h>
  21#include <linux/pinctrl/pinconf.h>
  22#include <linux/pinctrl/pinconf-generic.h>
  23#include <linux/regmap.h>
  24#include <linux/slab.h>
  25#include "../core.h"
  26#include "../pinctrl-utils.h"
  27
  28/* BCM281XX Pin Control Registers Definitions */
  29
  30/* Function Select bits are the same for all pin control registers */
  31#define BCM281XX_PIN_REG_F_SEL_MASK             0x0700
  32#define BCM281XX_PIN_REG_F_SEL_SHIFT            8
  33
  34/* Standard pin register */
  35#define BCM281XX_STD_PIN_REG_DRV_STR_MASK       0x0007
  36#define BCM281XX_STD_PIN_REG_DRV_STR_SHIFT      0
  37#define BCM281XX_STD_PIN_REG_INPUT_DIS_MASK     0x0008
  38#define BCM281XX_STD_PIN_REG_INPUT_DIS_SHIFT    3
  39#define BCM281XX_STD_PIN_REG_SLEW_MASK          0x0010
  40#define BCM281XX_STD_PIN_REG_SLEW_SHIFT         4
  41#define BCM281XX_STD_PIN_REG_PULL_UP_MASK       0x0020
  42#define BCM281XX_STD_PIN_REG_PULL_UP_SHIFT      5
  43#define BCM281XX_STD_PIN_REG_PULL_DN_MASK       0x0040
  44#define BCM281XX_STD_PIN_REG_PULL_DN_SHIFT      6
  45#define BCM281XX_STD_PIN_REG_HYST_MASK          0x0080
  46#define BCM281XX_STD_PIN_REG_HYST_SHIFT         7
  47
  48/* I2C pin register */
  49#define BCM281XX_I2C_PIN_REG_INPUT_DIS_MASK     0x0004
  50#define BCM281XX_I2C_PIN_REG_INPUT_DIS_SHIFT    2
  51#define BCM281XX_I2C_PIN_REG_SLEW_MASK          0x0008
  52#define BCM281XX_I2C_PIN_REG_SLEW_SHIFT         3
  53#define BCM281XX_I2C_PIN_REG_PULL_UP_STR_MASK   0x0070
  54#define BCM281XX_I2C_PIN_REG_PULL_UP_STR_SHIFT  4
  55
  56/* HDMI pin register */
  57#define BCM281XX_HDMI_PIN_REG_INPUT_DIS_MASK    0x0008
  58#define BCM281XX_HDMI_PIN_REG_INPUT_DIS_SHIFT   3
  59#define BCM281XX_HDMI_PIN_REG_MODE_MASK         0x0010
  60#define BCM281XX_HDMI_PIN_REG_MODE_SHIFT        4
  61
  62/**
  63 * bcm281xx_pin_type - types of pin register
  64 */
  65enum bcm281xx_pin_type {
  66        BCM281XX_PIN_TYPE_UNKNOWN = 0,
  67        BCM281XX_PIN_TYPE_STD,
  68        BCM281XX_PIN_TYPE_I2C,
  69        BCM281XX_PIN_TYPE_HDMI,
  70};
  71
  72static enum bcm281xx_pin_type std_pin = BCM281XX_PIN_TYPE_STD;
  73static enum bcm281xx_pin_type i2c_pin = BCM281XX_PIN_TYPE_I2C;
  74static enum bcm281xx_pin_type hdmi_pin = BCM281XX_PIN_TYPE_HDMI;
  75
  76/**
  77 * bcm281xx_pin_function- define pin function
  78 */
  79struct bcm281xx_pin_function {
  80        const char *name;
  81        const char * const *groups;
  82        const unsigned ngroups;
  83};
  84
  85/**
  86 * bcm281xx_pinctrl_data - Broadcom-specific pinctrl data
  87 * @reg_base - base of pinctrl registers
  88 */
  89struct bcm281xx_pinctrl_data {
  90        void __iomem *reg_base;
  91
  92        /* List of all pins */
  93        const struct pinctrl_pin_desc *pins;
  94        const unsigned npins;
  95
  96        const struct bcm281xx_pin_function *functions;
  97        const unsigned nfunctions;
  98
  99        struct regmap *regmap;
 100};
 101
 102/*
 103 * Pin number definition.  The order here must be the same as defined in the
 104 * PADCTRLREG block in the RDB.
 105 */
 106#define BCM281XX_PIN_ADCSYNC            0
 107#define BCM281XX_PIN_BAT_RM             1
 108#define BCM281XX_PIN_BSC1_SCL           2
 109#define BCM281XX_PIN_BSC1_SDA           3
 110#define BCM281XX_PIN_BSC2_SCL           4
 111#define BCM281XX_PIN_BSC2_SDA           5
 112#define BCM281XX_PIN_CLASSGPWR          6
 113#define BCM281XX_PIN_CLK_CX8            7
 114#define BCM281XX_PIN_CLKOUT_0           8
 115#define BCM281XX_PIN_CLKOUT_1           9
 116#define BCM281XX_PIN_CLKOUT_2           10
 117#define BCM281XX_PIN_CLKOUT_3           11
 118#define BCM281XX_PIN_CLKREQ_IN_0        12
 119#define BCM281XX_PIN_CLKREQ_IN_1        13
 120#define BCM281XX_PIN_CWS_SYS_REQ1       14
 121#define BCM281XX_PIN_CWS_SYS_REQ2       15
 122#define BCM281XX_PIN_CWS_SYS_REQ3       16
 123#define BCM281XX_PIN_DIGMIC1_CLK        17
 124#define BCM281XX_PIN_DIGMIC1_DQ         18
 125#define BCM281XX_PIN_DIGMIC2_CLK        19
 126#define BCM281XX_PIN_DIGMIC2_DQ         20
 127#define BCM281XX_PIN_GPEN13             21
 128#define BCM281XX_PIN_GPEN14             22
 129#define BCM281XX_PIN_GPEN15             23
 130#define BCM281XX_PIN_GPIO00             24
 131#define BCM281XX_PIN_GPIO01             25
 132#define BCM281XX_PIN_GPIO02             26
 133#define BCM281XX_PIN_GPIO03             27
 134#define BCM281XX_PIN_GPIO04             28
 135#define BCM281XX_PIN_GPIO05             29
 136#define BCM281XX_PIN_GPIO06             30
 137#define BCM281XX_PIN_GPIO07             31
 138#define BCM281XX_PIN_GPIO08             32
 139#define BCM281XX_PIN_GPIO09             33
 140#define BCM281XX_PIN_GPIO10             34
 141#define BCM281XX_PIN_GPIO11             35
 142#define BCM281XX_PIN_GPIO12             36
 143#define BCM281XX_PIN_GPIO13             37
 144#define BCM281XX_PIN_GPIO14             38
 145#define BCM281XX_PIN_GPS_PABLANK        39
 146#define BCM281XX_PIN_GPS_TMARK          40
 147#define BCM281XX_PIN_HDMI_SCL           41
 148#define BCM281XX_PIN_HDMI_SDA           42
 149#define BCM281XX_PIN_IC_DM              43
 150#define BCM281XX_PIN_IC_DP              44
 151#define BCM281XX_PIN_KP_COL_IP_0        45
 152#define BCM281XX_PIN_KP_COL_IP_1        46
 153#define BCM281XX_PIN_KP_COL_IP_2        47
 154#define BCM281XX_PIN_KP_COL_IP_3        48
 155#define BCM281XX_PIN_KP_ROW_OP_0        49
 156#define BCM281XX_PIN_KP_ROW_OP_1        50
 157#define BCM281XX_PIN_KP_ROW_OP_2        51
 158#define BCM281XX_PIN_KP_ROW_OP_3        52
 159#define BCM281XX_PIN_LCD_B_0            53
 160#define BCM281XX_PIN_LCD_B_1            54
 161#define BCM281XX_PIN_LCD_B_2            55
 162#define BCM281XX_PIN_LCD_B_3            56
 163#define BCM281XX_PIN_LCD_B_4            57
 164#define BCM281XX_PIN_LCD_B_5            58
 165#define BCM281XX_PIN_LCD_B_6            59
 166#define BCM281XX_PIN_LCD_B_7            60
 167#define BCM281XX_PIN_LCD_G_0            61
 168#define BCM281XX_PIN_LCD_G_1            62
 169#define BCM281XX_PIN_LCD_G_2            63
 170#define BCM281XX_PIN_LCD_G_3            64
 171#define BCM281XX_PIN_LCD_G_4            65
 172#define BCM281XX_PIN_LCD_G_5            66
 173#define BCM281XX_PIN_LCD_G_6            67
 174#define BCM281XX_PIN_LCD_G_7            68
 175#define BCM281XX_PIN_LCD_HSYNC          69
 176#define BCM281XX_PIN_LCD_OE             70
 177#define BCM281XX_PIN_LCD_PCLK           71
 178#define BCM281XX_PIN_LCD_R_0            72
 179#define BCM281XX_PIN_LCD_R_1            73
 180#define BCM281XX_PIN_LCD_R_2            74
 181#define BCM281XX_PIN_LCD_R_3            75
 182#define BCM281XX_PIN_LCD_R_4            76
 183#define BCM281XX_PIN_LCD_R_5            77
 184#define BCM281XX_PIN_LCD_R_6            78
 185#define BCM281XX_PIN_LCD_R_7            79
 186#define BCM281XX_PIN_LCD_VSYNC          80
 187#define BCM281XX_PIN_MDMGPIO0           81
 188#define BCM281XX_PIN_MDMGPIO1           82
 189#define BCM281XX_PIN_MDMGPIO2           83
 190#define BCM281XX_PIN_MDMGPIO3           84
 191#define BCM281XX_PIN_MDMGPIO4           85
 192#define BCM281XX_PIN_MDMGPIO5           86
 193#define BCM281XX_PIN_MDMGPIO6           87
 194#define BCM281XX_PIN_MDMGPIO7           88
 195#define BCM281XX_PIN_MDMGPIO8           89
 196#define BCM281XX_PIN_MPHI_DATA_0        90
 197#define BCM281XX_PIN_MPHI_DATA_1        91
 198#define BCM281XX_PIN_MPHI_DATA_2        92
 199#define BCM281XX_PIN_MPHI_DATA_3        93
 200#define BCM281XX_PIN_MPHI_DATA_4        94
 201#define BCM281XX_PIN_MPHI_DATA_5        95
 202#define BCM281XX_PIN_MPHI_DATA_6        96
 203#define BCM281XX_PIN_MPHI_DATA_7        97
 204#define BCM281XX_PIN_MPHI_DATA_8        98
 205#define BCM281XX_PIN_MPHI_DATA_9        99
 206#define BCM281XX_PIN_MPHI_DATA_10       100
 207#define BCM281XX_PIN_MPHI_DATA_11       101
 208#define BCM281XX_PIN_MPHI_DATA_12       102
 209#define BCM281XX_PIN_MPHI_DATA_13       103
 210#define BCM281XX_PIN_MPHI_DATA_14       104
 211#define BCM281XX_PIN_MPHI_DATA_15       105
 212#define BCM281XX_PIN_MPHI_HA0           106
 213#define BCM281XX_PIN_MPHI_HAT0          107
 214#define BCM281XX_PIN_MPHI_HAT1          108
 215#define BCM281XX_PIN_MPHI_HCE0_N        109
 216#define BCM281XX_PIN_MPHI_HCE1_N        110
 217#define BCM281XX_PIN_MPHI_HRD_N         111
 218#define BCM281XX_PIN_MPHI_HWR_N         112
 219#define BCM281XX_PIN_MPHI_RUN0          113
 220#define BCM281XX_PIN_MPHI_RUN1          114
 221#define BCM281XX_PIN_MTX_SCAN_CLK       115
 222#define BCM281XX_PIN_MTX_SCAN_DATA      116
 223#define BCM281XX_PIN_NAND_AD_0          117
 224#define BCM281XX_PIN_NAND_AD_1          118
 225#define BCM281XX_PIN_NAND_AD_2          119
 226#define BCM281XX_PIN_NAND_AD_3          120
 227#define BCM281XX_PIN_NAND_AD_4          121
 228#define BCM281XX_PIN_NAND_AD_5          122
 229#define BCM281XX_PIN_NAND_AD_6          123
 230#define BCM281XX_PIN_NAND_AD_7          124
 231#define BCM281XX_PIN_NAND_ALE           125
 232#define BCM281XX_PIN_NAND_CEN_0         126
 233#define BCM281XX_PIN_NAND_CEN_1         127
 234#define BCM281XX_PIN_NAND_CLE           128
 235#define BCM281XX_PIN_NAND_OEN           129
 236#define BCM281XX_PIN_NAND_RDY_0         130
 237#define BCM281XX_PIN_NAND_RDY_1         131
 238#define BCM281XX_PIN_NAND_WEN           132
 239#define BCM281XX_PIN_NAND_WP            133
 240#define BCM281XX_PIN_PC1                134
 241#define BCM281XX_PIN_PC2                135
 242#define BCM281XX_PIN_PMU_INT            136
 243#define BCM281XX_PIN_PMU_SCL            137
 244#define BCM281XX_PIN_PMU_SDA            138
 245#define BCM281XX_PIN_RFST2G_MTSLOTEN3G  139
 246#define BCM281XX_PIN_RGMII_0_RX_CTL     140
 247#define BCM281XX_PIN_RGMII_0_RXC        141
 248#define BCM281XX_PIN_RGMII_0_RXD_0      142
 249#define BCM281XX_PIN_RGMII_0_RXD_1      143
 250#define BCM281XX_PIN_RGMII_0_RXD_2      144
 251#define BCM281XX_PIN_RGMII_0_RXD_3      145
 252#define BCM281XX_PIN_RGMII_0_TX_CTL     146
 253#define BCM281XX_PIN_RGMII_0_TXC        147
 254#define BCM281XX_PIN_RGMII_0_TXD_0      148
 255#define BCM281XX_PIN_RGMII_0_TXD_1      149
 256#define BCM281XX_PIN_RGMII_0_TXD_2      150
 257#define BCM281XX_PIN_RGMII_0_TXD_3      151
 258#define BCM281XX_PIN_RGMII_1_RX_CTL     152
 259#define BCM281XX_PIN_RGMII_1_RXC        153
 260#define BCM281XX_PIN_RGMII_1_RXD_0      154
 261#define BCM281XX_PIN_RGMII_1_RXD_1      155
 262#define BCM281XX_PIN_RGMII_1_RXD_2      156
 263#define BCM281XX_PIN_RGMII_1_RXD_3      157
 264#define BCM281XX_PIN_RGMII_1_TX_CTL     158
 265#define BCM281XX_PIN_RGMII_1_TXC        159
 266#define BCM281XX_PIN_RGMII_1_TXD_0      160
 267#define BCM281XX_PIN_RGMII_1_TXD_1      161
 268#define BCM281XX_PIN_RGMII_1_TXD_2      162
 269#define BCM281XX_PIN_RGMII_1_TXD_3      163
 270#define BCM281XX_PIN_RGMII_GPIO_0       164
 271#define BCM281XX_PIN_RGMII_GPIO_1       165
 272#define BCM281XX_PIN_RGMII_GPIO_2       166
 273#define BCM281XX_PIN_RGMII_GPIO_3       167
 274#define BCM281XX_PIN_RTXDATA2G_TXDATA3G1        168
 275#define BCM281XX_PIN_RTXEN2G_TXDATA3G2  169
 276#define BCM281XX_PIN_RXDATA3G0          170
 277#define BCM281XX_PIN_RXDATA3G1          171
 278#define BCM281XX_PIN_RXDATA3G2          172
 279#define BCM281XX_PIN_SDIO1_CLK          173
 280#define BCM281XX_PIN_SDIO1_CMD          174
 281#define BCM281XX_PIN_SDIO1_DATA_0       175
 282#define BCM281XX_PIN_SDIO1_DATA_1       176
 283#define BCM281XX_PIN_SDIO1_DATA_2       177
 284#define BCM281XX_PIN_SDIO1_DATA_3       178
 285#define BCM281XX_PIN_SDIO4_CLK          179
 286#define BCM281XX_PIN_SDIO4_CMD          180
 287#define BCM281XX_PIN_SDIO4_DATA_0       181
 288#define BCM281XX_PIN_SDIO4_DATA_1       182
 289#define BCM281XX_PIN_SDIO4_DATA_2       183
 290#define BCM281XX_PIN_SDIO4_DATA_3       184
 291#define BCM281XX_PIN_SIM_CLK            185
 292#define BCM281XX_PIN_SIM_DATA           186
 293#define BCM281XX_PIN_SIM_DET            187
 294#define BCM281XX_PIN_SIM_RESETN         188
 295#define BCM281XX_PIN_SIM2_CLK           189
 296#define BCM281XX_PIN_SIM2_DATA          190
 297#define BCM281XX_PIN_SIM2_DET           191
 298#define BCM281XX_PIN_SIM2_RESETN        192
 299#define BCM281XX_PIN_SRI_C              193
 300#define BCM281XX_PIN_SRI_D              194
 301#define BCM281XX_PIN_SRI_E              195
 302#define BCM281XX_PIN_SSP_EXTCLK         196
 303#define BCM281XX_PIN_SSP0_CLK           197
 304#define BCM281XX_PIN_SSP0_FS            198
 305#define BCM281XX_PIN_SSP0_RXD           199
 306#define BCM281XX_PIN_SSP0_TXD           200
 307#define BCM281XX_PIN_SSP2_CLK           201
 308#define BCM281XX_PIN_SSP2_FS_0          202
 309#define BCM281XX_PIN_SSP2_FS_1          203
 310#define BCM281XX_PIN_SSP2_FS_2          204
 311#define BCM281XX_PIN_SSP2_FS_3          205
 312#define BCM281XX_PIN_SSP2_RXD_0         206
 313#define BCM281XX_PIN_SSP2_RXD_1         207
 314#define BCM281XX_PIN_SSP2_TXD_0         208
 315#define BCM281XX_PIN_SSP2_TXD_1         209
 316#define BCM281XX_PIN_SSP3_CLK           210
 317#define BCM281XX_PIN_SSP3_FS            211
 318#define BCM281XX_PIN_SSP3_RXD           212
 319#define BCM281XX_PIN_SSP3_TXD           213
 320#define BCM281XX_PIN_SSP4_CLK           214
 321#define BCM281XX_PIN_SSP4_FS            215
 322#define BCM281XX_PIN_SSP4_RXD           216
 323#define BCM281XX_PIN_SSP4_TXD           217
 324#define BCM281XX_PIN_SSP5_CLK           218
 325#define BCM281XX_PIN_SSP5_FS            219
 326#define BCM281XX_PIN_SSP5_RXD           220
 327#define BCM281XX_PIN_SSP5_TXD           221
 328#define BCM281XX_PIN_SSP6_CLK           222
 329#define BCM281XX_PIN_SSP6_FS            223
 330#define BCM281XX_PIN_SSP6_RXD           224
 331#define BCM281XX_PIN_SSP6_TXD           225
 332#define BCM281XX_PIN_STAT_1             226
 333#define BCM281XX_PIN_STAT_2             227
 334#define BCM281XX_PIN_SYSCLKEN           228
 335#define BCM281XX_PIN_TRACECLK           229
 336#define BCM281XX_PIN_TRACEDT00          230
 337#define BCM281XX_PIN_TRACEDT01          231
 338#define BCM281XX_PIN_TRACEDT02          232
 339#define BCM281XX_PIN_TRACEDT03          233
 340#define BCM281XX_PIN_TRACEDT04          234
 341#define BCM281XX_PIN_TRACEDT05          235
 342#define BCM281XX_PIN_TRACEDT06          236
 343#define BCM281XX_PIN_TRACEDT07          237
 344#define BCM281XX_PIN_TRACEDT08          238
 345#define BCM281XX_PIN_TRACEDT09          239
 346#define BCM281XX_PIN_TRACEDT10          240
 347#define BCM281XX_PIN_TRACEDT11          241
 348#define BCM281XX_PIN_TRACEDT12          242
 349#define BCM281XX_PIN_TRACEDT13          243
 350#define BCM281XX_PIN_TRACEDT14          244
 351#define BCM281XX_PIN_TRACEDT15          245
 352#define BCM281XX_PIN_TXDATA3G0          246
 353#define BCM281XX_PIN_TXPWRIND           247
 354#define BCM281XX_PIN_UARTB1_UCTS        248
 355#define BCM281XX_PIN_UARTB1_URTS        249
 356#define BCM281XX_PIN_UARTB1_URXD        250
 357#define BCM281XX_PIN_UARTB1_UTXD        251
 358#define BCM281XX_PIN_UARTB2_URXD        252
 359#define BCM281XX_PIN_UARTB2_UTXD        253
 360#define BCM281XX_PIN_UARTB3_UCTS        254
 361#define BCM281XX_PIN_UARTB3_URTS        255
 362#define BCM281XX_PIN_UARTB3_URXD        256
 363#define BCM281XX_PIN_UARTB3_UTXD        257
 364#define BCM281XX_PIN_UARTB4_UCTS        258
 365#define BCM281XX_PIN_UARTB4_URTS        259
 366#define BCM281XX_PIN_UARTB4_URXD        260
 367#define BCM281XX_PIN_UARTB4_UTXD        261
 368#define BCM281XX_PIN_VC_CAM1_SCL        262
 369#define BCM281XX_PIN_VC_CAM1_SDA        263
 370#define BCM281XX_PIN_VC_CAM2_SCL        264
 371#define BCM281XX_PIN_VC_CAM2_SDA        265
 372#define BCM281XX_PIN_VC_CAM3_SCL        266
 373#define BCM281XX_PIN_VC_CAM3_SDA        267
 374
 375#define BCM281XX_PIN_DESC(a, b, c) \
 376        { .number = a, .name = b, .drv_data = &c##_pin }
 377
 378/*
 379 * Pin description definition.  The order here must be the same as defined in
 380 * the PADCTRLREG block in the RDB, since the pin number is used as an index
 381 * into this array.
 382 */
 383static const struct pinctrl_pin_desc bcm281xx_pinctrl_pins[] = {
 384        BCM281XX_PIN_DESC(BCM281XX_PIN_ADCSYNC, "adcsync", std),
 385        BCM281XX_PIN_DESC(BCM281XX_PIN_BAT_RM, "bat_rm", std),
 386        BCM281XX_PIN_DESC(BCM281XX_PIN_BSC1_SCL, "bsc1_scl", i2c),
 387        BCM281XX_PIN_DESC(BCM281XX_PIN_BSC1_SDA, "bsc1_sda", i2c),
 388        BCM281XX_PIN_DESC(BCM281XX_PIN_BSC2_SCL, "bsc2_scl", i2c),
 389        BCM281XX_PIN_DESC(BCM281XX_PIN_BSC2_SDA, "bsc2_sda", i2c),
 390        BCM281XX_PIN_DESC(BCM281XX_PIN_CLASSGPWR, "classgpwr", std),
 391        BCM281XX_PIN_DESC(BCM281XX_PIN_CLK_CX8, "clk_cx8", std),
 392        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKOUT_0, "clkout_0", std),
 393        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKOUT_1, "clkout_1", std),
 394        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKOUT_2, "clkout_2", std),
 395        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKOUT_3, "clkout_3", std),
 396        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKREQ_IN_0, "clkreq_in_0", std),
 397        BCM281XX_PIN_DESC(BCM281XX_PIN_CLKREQ_IN_1, "clkreq_in_1", std),
 398        BCM281XX_PIN_DESC(BCM281XX_PIN_CWS_SYS_REQ1, "cws_sys_req1", std),
 399        BCM281XX_PIN_DESC(BCM281XX_PIN_CWS_SYS_REQ2, "cws_sys_req2", std),
 400        BCM281XX_PIN_DESC(BCM281XX_PIN_CWS_SYS_REQ3, "cws_sys_req3", std),
 401        BCM281XX_PIN_DESC(BCM281XX_PIN_DIGMIC1_CLK, "digmic1_clk", std),
 402        BCM281XX_PIN_DESC(BCM281XX_PIN_DIGMIC1_DQ, "digmic1_dq", std),
 403        BCM281XX_PIN_DESC(BCM281XX_PIN_DIGMIC2_CLK, "digmic2_clk", std),
 404        BCM281XX_PIN_DESC(BCM281XX_PIN_DIGMIC2_DQ, "digmic2_dq", std),
 405        BCM281XX_PIN_DESC(BCM281XX_PIN_GPEN13, "gpen13", std),
 406        BCM281XX_PIN_DESC(BCM281XX_PIN_GPEN14, "gpen14", std),
 407        BCM281XX_PIN_DESC(BCM281XX_PIN_GPEN15, "gpen15", std),
 408        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO00, "gpio00", std),
 409        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO01, "gpio01", std),
 410        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO02, "gpio02", std),
 411        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO03, "gpio03", std),
 412        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO04, "gpio04", std),
 413        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO05, "gpio05", std),
 414        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO06, "gpio06", std),
 415        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO07, "gpio07", std),
 416        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO08, "gpio08", std),
 417        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO09, "gpio09", std),
 418        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO10, "gpio10", std),
 419        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO11, "gpio11", std),
 420        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO12, "gpio12", std),
 421        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO13, "gpio13", std),
 422        BCM281XX_PIN_DESC(BCM281XX_PIN_GPIO14, "gpio14", std),
 423        BCM281XX_PIN_DESC(BCM281XX_PIN_GPS_PABLANK, "gps_pablank", std),
 424        BCM281XX_PIN_DESC(BCM281XX_PIN_GPS_TMARK, "gps_tmark", std),
 425        BCM281XX_PIN_DESC(BCM281XX_PIN_HDMI_SCL, "hdmi_scl", hdmi),
 426        BCM281XX_PIN_DESC(BCM281XX_PIN_HDMI_SDA, "hdmi_sda", hdmi),
 427        BCM281XX_PIN_DESC(BCM281XX_PIN_IC_DM, "ic_dm", std),
 428        BCM281XX_PIN_DESC(BCM281XX_PIN_IC_DP, "ic_dp", std),
 429        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_COL_IP_0, "kp_col_ip_0", std),
 430        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_COL_IP_1, "kp_col_ip_1", std),
 431        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_COL_IP_2, "kp_col_ip_2", std),
 432        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_COL_IP_3, "kp_col_ip_3", std),
 433        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_ROW_OP_0, "kp_row_op_0", std),
 434        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_ROW_OP_1, "kp_row_op_1", std),
 435        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_ROW_OP_2, "kp_row_op_2", std),
 436        BCM281XX_PIN_DESC(BCM281XX_PIN_KP_ROW_OP_3, "kp_row_op_3", std),
 437        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_0, "lcd_b_0", std),
 438        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_1, "lcd_b_1", std),
 439        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_2, "lcd_b_2", std),
 440        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_3, "lcd_b_3", std),
 441        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_4, "lcd_b_4", std),
 442        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_5, "lcd_b_5", std),
 443        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_6, "lcd_b_6", std),
 444        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_B_7, "lcd_b_7", std),
 445        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_0, "lcd_g_0", std),
 446        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_1, "lcd_g_1", std),
 447        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_2, "lcd_g_2", std),
 448        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_3, "lcd_g_3", std),
 449        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_4, "lcd_g_4", std),
 450        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_5, "lcd_g_5", std),
 451        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_6, "lcd_g_6", std),
 452        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_G_7, "lcd_g_7", std),
 453        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_HSYNC, "lcd_hsync", std),
 454        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_OE, "lcd_oe", std),
 455        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_PCLK, "lcd_pclk", std),
 456        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_0, "lcd_r_0", std),
 457        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_1, "lcd_r_1", std),
 458        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_2, "lcd_r_2", std),
 459        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_3, "lcd_r_3", std),
 460        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_4, "lcd_r_4", std),
 461        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_5, "lcd_r_5", std),
 462        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_6, "lcd_r_6", std),
 463        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_R_7, "lcd_r_7", std),
 464        BCM281XX_PIN_DESC(BCM281XX_PIN_LCD_VSYNC, "lcd_vsync", std),
 465        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO0, "mdmgpio0", std),
 466        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO1, "mdmgpio1", std),
 467        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO2, "mdmgpio2", std),
 468        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO3, "mdmgpio3", std),
 469        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO4, "mdmgpio4", std),
 470        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO5, "mdmgpio5", std),
 471        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO6, "mdmgpio6", std),
 472        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO7, "mdmgpio7", std),
 473        BCM281XX_PIN_DESC(BCM281XX_PIN_MDMGPIO8, "mdmgpio8", std),
 474        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_0, "mphi_data_0", std),
 475        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_1, "mphi_data_1", std),
 476        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_2, "mphi_data_2", std),
 477        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_3, "mphi_data_3", std),
 478        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_4, "mphi_data_4", std),
 479        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_5, "mphi_data_5", std),
 480        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_6, "mphi_data_6", std),
 481        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_7, "mphi_data_7", std),
 482        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_8, "mphi_data_8", std),
 483        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_9, "mphi_data_9", std),
 484        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_10, "mphi_data_10", std),
 485        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_11, "mphi_data_11", std),
 486        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_12, "mphi_data_12", std),
 487        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_13, "mphi_data_13", std),
 488        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_14, "mphi_data_14", std),
 489        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_DATA_15, "mphi_data_15", std),
 490        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HA0, "mphi_ha0", std),
 491        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HAT0, "mphi_hat0", std),
 492        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HAT1, "mphi_hat1", std),
 493        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HCE0_N, "mphi_hce0_n", std),
 494        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HCE1_N, "mphi_hce1_n", std),
 495        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HRD_N, "mphi_hrd_n", std),
 496        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_HWR_N, "mphi_hwr_n", std),
 497        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_RUN0, "mphi_run0", std),
 498        BCM281XX_PIN_DESC(BCM281XX_PIN_MPHI_RUN1, "mphi_run1", std),
 499        BCM281XX_PIN_DESC(BCM281XX_PIN_MTX_SCAN_CLK, "mtx_scan_clk", std),
 500        BCM281XX_PIN_DESC(BCM281XX_PIN_MTX_SCAN_DATA, "mtx_scan_data", std),
 501        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_0, "nand_ad_0", std),
 502        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_1, "nand_ad_1", std),
 503        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_2, "nand_ad_2", std),
 504        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_3, "nand_ad_3", std),
 505        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_4, "nand_ad_4", std),
 506        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_5, "nand_ad_5", std),
 507        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_6, "nand_ad_6", std),
 508        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_AD_7, "nand_ad_7", std),
 509        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_ALE, "nand_ale", std),
 510        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_CEN_0, "nand_cen_0", std),
 511        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_CEN_1, "nand_cen_1", std),
 512        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_CLE, "nand_cle", std),
 513        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_OEN, "nand_oen", std),
 514        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_RDY_0, "nand_rdy_0", std),
 515        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_RDY_1, "nand_rdy_1", std),
 516        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_WEN, "nand_wen", std),
 517        BCM281XX_PIN_DESC(BCM281XX_PIN_NAND_WP, "nand_wp", std),
 518        BCM281XX_PIN_DESC(BCM281XX_PIN_PC1, "pc1", std),
 519        BCM281XX_PIN_DESC(BCM281XX_PIN_PC2, "pc2", std),
 520        BCM281XX_PIN_DESC(BCM281XX_PIN_PMU_INT, "pmu_int", std),
 521        BCM281XX_PIN_DESC(BCM281XX_PIN_PMU_SCL, "pmu_scl", i2c),
 522        BCM281XX_PIN_DESC(BCM281XX_PIN_PMU_SDA, "pmu_sda", i2c),
 523        BCM281XX_PIN_DESC(BCM281XX_PIN_RFST2G_MTSLOTEN3G, "rfst2g_mtsloten3g",
 524                std),
 525        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RX_CTL, "rgmii_0_rx_ctl", std),
 526        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RXC, "rgmii_0_rxc", std),
 527        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RXD_0, "rgmii_0_rxd_0", std),
 528        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RXD_1, "rgmii_0_rxd_1", std),
 529        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RXD_2, "rgmii_0_rxd_2", std),
 530        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_RXD_3, "rgmii_0_rxd_3", std),
 531        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TX_CTL, "rgmii_0_tx_ctl", std),
 532        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TXC, "rgmii_0_txc", std),
 533        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TXD_0, "rgmii_0_txd_0", std),
 534        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TXD_1, "rgmii_0_txd_1", std),
 535        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TXD_2, "rgmii_0_txd_2", std),
 536        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_0_TXD_3, "rgmii_0_txd_3", std),
 537        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RX_CTL, "rgmii_1_rx_ctl", std),
 538        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RXC, "rgmii_1_rxc", std),
 539        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RXD_0, "rgmii_1_rxd_0", std),
 540        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RXD_1, "rgmii_1_rxd_1", std),
 541        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RXD_2, "rgmii_1_rxd_2", std),
 542        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_RXD_3, "rgmii_1_rxd_3", std),
 543        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TX_CTL, "rgmii_1_tx_ctl", std),
 544        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TXC, "rgmii_1_txc", std),
 545        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TXD_0, "rgmii_1_txd_0", std),
 546        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TXD_1, "rgmii_1_txd_1", std),
 547        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TXD_2, "rgmii_1_txd_2", std),
 548        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_1_TXD_3, "rgmii_1_txd_3", std),
 549        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_GPIO_0, "rgmii_gpio_0", std),
 550        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_GPIO_1, "rgmii_gpio_1", std),
 551        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_GPIO_2, "rgmii_gpio_2", std),
 552        BCM281XX_PIN_DESC(BCM281XX_PIN_RGMII_GPIO_3, "rgmii_gpio_3", std),
 553        BCM281XX_PIN_DESC(BCM281XX_PIN_RTXDATA2G_TXDATA3G1,
 554                "rtxdata2g_txdata3g1", std),
 555        BCM281XX_PIN_DESC(BCM281XX_PIN_RTXEN2G_TXDATA3G2, "rtxen2g_txdata3g2",
 556                std),
 557        BCM281XX_PIN_DESC(BCM281XX_PIN_RXDATA3G0, "rxdata3g0", std),
 558        BCM281XX_PIN_DESC(BCM281XX_PIN_RXDATA3G1, "rxdata3g1", std),
 559        BCM281XX_PIN_DESC(BCM281XX_PIN_RXDATA3G2, "rxdata3g2", std),
 560        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_CLK, "sdio1_clk", std),
 561        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_CMD, "sdio1_cmd", std),
 562        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_DATA_0, "sdio1_data_0", std),
 563        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_DATA_1, "sdio1_data_1", std),
 564        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_DATA_2, "sdio1_data_2", std),
 565        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO1_DATA_3, "sdio1_data_3", std),
 566        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_CLK, "sdio4_clk", std),
 567        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_CMD, "sdio4_cmd", std),
 568        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_DATA_0, "sdio4_data_0", std),
 569        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_DATA_1, "sdio4_data_1", std),
 570        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_DATA_2, "sdio4_data_2", std),
 571        BCM281XX_PIN_DESC(BCM281XX_PIN_SDIO4_DATA_3, "sdio4_data_3", std),
 572        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM_CLK, "sim_clk", std),
 573        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM_DATA, "sim_data", std),
 574        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM_DET, "sim_det", std),
 575        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM_RESETN, "sim_resetn", std),
 576        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM2_CLK, "sim2_clk", std),
 577        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM2_DATA, "sim2_data", std),
 578        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM2_DET, "sim2_det", std),
 579        BCM281XX_PIN_DESC(BCM281XX_PIN_SIM2_RESETN, "sim2_resetn", std),
 580        BCM281XX_PIN_DESC(BCM281XX_PIN_SRI_C, "sri_c", std),
 581        BCM281XX_PIN_DESC(BCM281XX_PIN_SRI_D, "sri_d", std),
 582        BCM281XX_PIN_DESC(BCM281XX_PIN_SRI_E, "sri_e", std),
 583        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP_EXTCLK, "ssp_extclk", std),
 584        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP0_CLK, "ssp0_clk", std),
 585        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP0_FS, "ssp0_fs", std),
 586        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP0_RXD, "ssp0_rxd", std),
 587        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP0_TXD, "ssp0_txd", std),
 588        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_CLK, "ssp2_clk", std),
 589        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_FS_0, "ssp2_fs_0", std),
 590        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_FS_1, "ssp2_fs_1", std),
 591        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_FS_2, "ssp2_fs_2", std),
 592        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_FS_3, "ssp2_fs_3", std),
 593        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_RXD_0, "ssp2_rxd_0", std),
 594        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_RXD_1, "ssp2_rxd_1", std),
 595        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_TXD_0, "ssp2_txd_0", std),
 596        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP2_TXD_1, "ssp2_txd_1", std),
 597        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP3_CLK, "ssp3_clk", std),
 598        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP3_FS, "ssp3_fs", std),
 599        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP3_RXD, "ssp3_rxd", std),
 600        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP3_TXD, "ssp3_txd", std),
 601        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP4_CLK, "ssp4_clk", std),
 602        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP4_FS, "ssp4_fs", std),
 603        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP4_RXD, "ssp4_rxd", std),
 604        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP4_TXD, "ssp4_txd", std),
 605        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP5_CLK, "ssp5_clk", std),
 606        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP5_FS, "ssp5_fs", std),
 607        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP5_RXD, "ssp5_rxd", std),
 608        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP5_TXD, "ssp5_txd", std),
 609        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP6_CLK, "ssp6_clk", std),
 610        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP6_FS, "ssp6_fs", std),
 611        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP6_RXD, "ssp6_rxd", std),
 612        BCM281XX_PIN_DESC(BCM281XX_PIN_SSP6_TXD, "ssp6_txd", std),
 613        BCM281XX_PIN_DESC(BCM281XX_PIN_STAT_1, "stat_1", std),
 614        BCM281XX_PIN_DESC(BCM281XX_PIN_STAT_2, "stat_2", std),
 615        BCM281XX_PIN_DESC(BCM281XX_PIN_SYSCLKEN, "sysclken", std),
 616        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACECLK, "traceclk", std),
 617        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT00, "tracedt00", std),
 618        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT01, "tracedt01", std),
 619        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT02, "tracedt02", std),
 620        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT03, "tracedt03", std),
 621        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT04, "tracedt04", std),
 622        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT05, "tracedt05", std),
 623        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT06, "tracedt06", std),
 624        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT07, "tracedt07", std),
 625        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT08, "tracedt08", std),
 626        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT09, "tracedt09", std),
 627        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT10, "tracedt10", std),
 628        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT11, "tracedt11", std),
 629        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT12, "tracedt12", std),
 630        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT13, "tracedt13", std),
 631        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT14, "tracedt14", std),
 632        BCM281XX_PIN_DESC(BCM281XX_PIN_TRACEDT15, "tracedt15", std),
 633        BCM281XX_PIN_DESC(BCM281XX_PIN_TXDATA3G0, "txdata3g0", std),
 634        BCM281XX_PIN_DESC(BCM281XX_PIN_TXPWRIND, "txpwrind", std),
 635        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB1_UCTS, "uartb1_ucts", std),
 636        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB1_URTS, "uartb1_urts", std),
 637        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB1_URXD, "uartb1_urxd", std),
 638        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB1_UTXD, "uartb1_utxd", std),
 639        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB2_URXD, "uartb2_urxd", std),
 640        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB2_UTXD, "uartb2_utxd", std),
 641        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB3_UCTS, "uartb3_ucts", std),
 642        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB3_URTS, "uartb3_urts", std),
 643        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB3_URXD, "uartb3_urxd", std),
 644        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB3_UTXD, "uartb3_utxd", std),
 645        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB4_UCTS, "uartb4_ucts", std),
 646        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB4_URTS, "uartb4_urts", std),
 647        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB4_URXD, "uartb4_urxd", std),
 648        BCM281XX_PIN_DESC(BCM281XX_PIN_UARTB4_UTXD, "uartb4_utxd", std),
 649        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM1_SCL, "vc_cam1_scl", i2c),
 650        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM1_SDA, "vc_cam1_sda", i2c),
 651        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM2_SCL, "vc_cam2_scl", i2c),
 652        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM2_SDA, "vc_cam2_sda", i2c),
 653        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM3_SCL, "vc_cam3_scl", i2c),
 654        BCM281XX_PIN_DESC(BCM281XX_PIN_VC_CAM3_SDA, "vc_cam3_sda", i2c),
 655};
 656
 657static const char * const bcm281xx_alt_groups[] = {
 658        "adcsync",
 659        "bat_rm",
 660        "bsc1_scl",
 661        "bsc1_sda",
 662        "bsc2_scl",
 663        "bsc2_sda",
 664        "classgpwr",
 665        "clk_cx8",
 666        "clkout_0",
 667        "clkout_1",
 668        "clkout_2",
 669        "clkout_3",
 670        "clkreq_in_0",
 671        "clkreq_in_1",
 672        "cws_sys_req1",
 673        "cws_sys_req2",
 674        "cws_sys_req3",
 675        "digmic1_clk",
 676        "digmic1_dq",
 677        "digmic2_clk",
 678        "digmic2_dq",
 679        "gpen13",
 680        "gpen14",
 681        "gpen15",
 682        "gpio00",
 683        "gpio01",
 684        "gpio02",
 685        "gpio03",
 686        "gpio04",
 687        "gpio05",
 688        "gpio06",
 689        "gpio07",
 690        "gpio08",
 691        "gpio09",
 692        "gpio10",
 693        "gpio11",
 694        "gpio12",
 695        "gpio13",
 696        "gpio14",
 697        "gps_pablank",
 698        "gps_tmark",
 699        "hdmi_scl",
 700        "hdmi_sda",
 701        "ic_dm",
 702        "ic_dp",
 703        "kp_col_ip_0",
 704        "kp_col_ip_1",
 705        "kp_col_ip_2",
 706        "kp_col_ip_3",
 707        "kp_row_op_0",
 708        "kp_row_op_1",
 709        "kp_row_op_2",
 710        "kp_row_op_3",
 711        "lcd_b_0",
 712        "lcd_b_1",
 713        "lcd_b_2",
 714        "lcd_b_3",
 715        "lcd_b_4",
 716        "lcd_b_5",
 717        "lcd_b_6",
 718        "lcd_b_7",
 719        "lcd_g_0",
 720        "lcd_g_1",
 721        "lcd_g_2",
 722        "lcd_g_3",
 723        "lcd_g_4",
 724        "lcd_g_5",
 725        "lcd_g_6",
 726        "lcd_g_7",
 727        "lcd_hsync",
 728        "lcd_oe",
 729        "lcd_pclk",
 730        "lcd_r_0",
 731        "lcd_r_1",
 732        "lcd_r_2",
 733        "lcd_r_3",
 734        "lcd_r_4",
 735        "lcd_r_5",
 736        "lcd_r_6",
 737        "lcd_r_7",
 738        "lcd_vsync",
 739        "mdmgpio0",
 740        "mdmgpio1",
 741        "mdmgpio2",
 742        "mdmgpio3",
 743        "mdmgpio4",
 744        "mdmgpio5",
 745        "mdmgpio6",
 746        "mdmgpio7",
 747        "mdmgpio8",
 748        "mphi_data_0",
 749        "mphi_data_1",
 750        "mphi_data_2",
 751        "mphi_data_3",
 752        "mphi_data_4",
 753        "mphi_data_5",
 754        "mphi_data_6",
 755        "mphi_data_7",
 756        "mphi_data_8",
 757        "mphi_data_9",
 758        "mphi_data_10",
 759        "mphi_data_11",
 760        "mphi_data_12",
 761        "mphi_data_13",
 762        "mphi_data_14",
 763        "mphi_data_15",
 764        "mphi_ha0",
 765        "mphi_hat0",
 766        "mphi_hat1",
 767        "mphi_hce0_n",
 768        "mphi_hce1_n",
 769        "mphi_hrd_n",
 770        "mphi_hwr_n",
 771        "mphi_run0",
 772        "mphi_run1",
 773        "mtx_scan_clk",
 774        "mtx_scan_data",
 775        "nand_ad_0",
 776        "nand_ad_1",
 777        "nand_ad_2",
 778        "nand_ad_3",
 779        "nand_ad_4",
 780        "nand_ad_5",
 781        "nand_ad_6",
 782        "nand_ad_7",
 783        "nand_ale",
 784        "nand_cen_0",
 785        "nand_cen_1",
 786        "nand_cle",
 787        "nand_oen",
 788        "nand_rdy_0",
 789        "nand_rdy_1",
 790        "nand_wen",
 791        "nand_wp",
 792        "pc1",
 793        "pc2",
 794        "pmu_int",
 795        "pmu_scl",
 796        "pmu_sda",
 797        "rfst2g_mtsloten3g",
 798        "rgmii_0_rx_ctl",
 799        "rgmii_0_rxc",
 800        "rgmii_0_rxd_0",
 801        "rgmii_0_rxd_1",
 802        "rgmii_0_rxd_2",
 803        "rgmii_0_rxd_3",
 804        "rgmii_0_tx_ctl",
 805        "rgmii_0_txc",
 806        "rgmii_0_txd_0",
 807        "rgmii_0_txd_1",
 808        "rgmii_0_txd_2",
 809        "rgmii_0_txd_3",
 810        "rgmii_1_rx_ctl",
 811        "rgmii_1_rxc",
 812        "rgmii_1_rxd_0",
 813        "rgmii_1_rxd_1",
 814        "rgmii_1_rxd_2",
 815        "rgmii_1_rxd_3",
 816        "rgmii_1_tx_ctl",
 817        "rgmii_1_txc",
 818        "rgmii_1_txd_0",
 819        "rgmii_1_txd_1",
 820        "rgmii_1_txd_2",
 821        "rgmii_1_txd_3",
 822        "rgmii_gpio_0",
 823        "rgmii_gpio_1",
 824        "rgmii_gpio_2",
 825        "rgmii_gpio_3",
 826        "rtxdata2g_txdata3g1",
 827        "rtxen2g_txdata3g2",
 828        "rxdata3g0",
 829        "rxdata3g1",
 830        "rxdata3g2",
 831        "sdio1_clk",
 832        "sdio1_cmd",
 833        "sdio1_data_0",
 834        "sdio1_data_1",
 835        "sdio1_data_2",
 836        "sdio1_data_3",
 837        "sdio4_clk",
 838        "sdio4_cmd",
 839        "sdio4_data_0",
 840        "sdio4_data_1",
 841        "sdio4_data_2",
 842        "sdio4_data_3",
 843        "sim_clk",
 844        "sim_data",
 845        "sim_det",
 846        "sim_resetn",
 847        "sim2_clk",
 848        "sim2_data",
 849        "sim2_det",
 850        "sim2_resetn",
 851        "sri_c",
 852        "sri_d",
 853        "sri_e",
 854        "ssp_extclk",
 855        "ssp0_clk",
 856        "ssp0_fs",
 857        "ssp0_rxd",
 858        "ssp0_txd",
 859        "ssp2_clk",
 860        "ssp2_fs_0",
 861        "ssp2_fs_1",
 862        "ssp2_fs_2",
 863        "ssp2_fs_3",
 864        "ssp2_rxd_0",
 865        "ssp2_rxd_1",
 866        "ssp2_txd_0",
 867        "ssp2_txd_1",
 868        "ssp3_clk",
 869        "ssp3_fs",
 870        "ssp3_rxd",
 871        "ssp3_txd",
 872        "ssp4_clk",
 873        "ssp4_fs",
 874        "ssp4_rxd",
 875        "ssp4_txd",
 876        "ssp5_clk",
 877        "ssp5_fs",
 878        "ssp5_rxd",
 879        "ssp5_txd",
 880        "ssp6_clk",
 881        "ssp6_fs",
 882        "ssp6_rxd",
 883        "ssp6_txd",
 884        "stat_1",
 885        "stat_2",
 886        "sysclken",
 887        "traceclk",
 888        "tracedt00",
 889        "tracedt01",
 890        "tracedt02",
 891        "tracedt03",
 892        "tracedt04",
 893        "tracedt05",
 894        "tracedt06",
 895        "tracedt07",
 896        "tracedt08",
 897        "tracedt09",
 898        "tracedt10",
 899        "tracedt11",
 900        "tracedt12",
 901        "tracedt13",
 902        "tracedt14",
 903        "tracedt15",
 904        "txdata3g0",
 905        "txpwrind",
 906        "uartb1_ucts",
 907        "uartb1_urts",
 908        "uartb1_urxd",
 909        "uartb1_utxd",
 910        "uartb2_urxd",
 911        "uartb2_utxd",
 912        "uartb3_ucts",
 913        "uartb3_urts",
 914        "uartb3_urxd",
 915        "uartb3_utxd",
 916        "uartb4_ucts",
 917        "uartb4_urts",
 918        "uartb4_urxd",
 919        "uartb4_utxd",
 920        "vc_cam1_scl",
 921        "vc_cam1_sda",
 922        "vc_cam2_scl",
 923        "vc_cam2_sda",
 924        "vc_cam3_scl",
 925        "vc_cam3_sda",
 926};
 927
 928/* Every pin can implement all ALT1-ALT4 functions */
 929#define BCM281XX_PIN_FUNCTION(fcn_name)                 \
 930{                                                       \
 931        .name = #fcn_name,                              \
 932        .groups = bcm281xx_alt_groups,                  \
 933        .ngroups = ARRAY_SIZE(bcm281xx_alt_groups),     \
 934}
 935
 936static const struct bcm281xx_pin_function bcm281xx_functions[] = {
 937        BCM281XX_PIN_FUNCTION(alt1),
 938        BCM281XX_PIN_FUNCTION(alt2),
 939        BCM281XX_PIN_FUNCTION(alt3),
 940        BCM281XX_PIN_FUNCTION(alt4),
 941};
 942
 943static struct bcm281xx_pinctrl_data bcm281xx_pinctrl = {
 944        .pins = bcm281xx_pinctrl_pins,
 945        .npins = ARRAY_SIZE(bcm281xx_pinctrl_pins),
 946        .functions = bcm281xx_functions,
 947        .nfunctions = ARRAY_SIZE(bcm281xx_functions),
 948};
 949
 950static inline enum bcm281xx_pin_type pin_type_get(struct pinctrl_dev *pctldev,
 951                                                  unsigned pin)
 952{
 953        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 954
 955        if (pin >= pdata->npins)
 956                return BCM281XX_PIN_TYPE_UNKNOWN;
 957
 958        return *(enum bcm281xx_pin_type *)(pdata->pins[pin].drv_data);
 959}
 960
 961#define BCM281XX_PIN_SHIFT(type, param) \
 962        (BCM281XX_ ## type ## _PIN_REG_ ## param ## _SHIFT)
 963
 964#define BCM281XX_PIN_MASK(type, param) \
 965        (BCM281XX_ ## type ## _PIN_REG_ ## param ## _MASK)
 966
 967/*
 968 * This helper function is used to build up the value and mask used to write to
 969 * a pin register, but does not actually write to the register.
 970 */
 971static inline void bcm281xx_pin_update(u32 *reg_val, u32 *reg_mask,
 972                                       u32 param_val, u32 param_shift,
 973                                       u32 param_mask)
 974{
 975        *reg_val &= ~param_mask;
 976        *reg_val |= (param_val << param_shift) & param_mask;
 977        *reg_mask |= param_mask;
 978}
 979
 980static const struct regmap_config bcm281xx_pinctrl_regmap_config = {
 981        .reg_bits = 32,
 982        .reg_stride = 4,
 983        .val_bits = 32,
 984        .max_register = BCM281XX_PIN_VC_CAM3_SDA,
 985};
 986
 987static int bcm281xx_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
 988{
 989        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 990
 991        return pdata->npins;
 992}
 993
 994static const char *bcm281xx_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
 995                                                   unsigned group)
 996{
 997        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
 998
 999        return pdata->pins[group].name;
1000}
1001
1002static int bcm281xx_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
1003                                           unsigned group,
1004                                           const unsigned **pins,
1005                                           unsigned *num_pins)
1006{
1007        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1008
1009        *pins = &pdata->pins[group].number;
1010        *num_pins = 1;
1011
1012        return 0;
1013}
1014
1015static void bcm281xx_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
1016                                          struct seq_file *s,
1017                                          unsigned offset)
1018{
1019        seq_printf(s, " %s", dev_name(pctldev->dev));
1020}
1021
1022static const struct pinctrl_ops bcm281xx_pinctrl_ops = {
1023        .get_groups_count = bcm281xx_pinctrl_get_groups_count,
1024        .get_group_name = bcm281xx_pinctrl_get_group_name,
1025        .get_group_pins = bcm281xx_pinctrl_get_group_pins,
1026        .pin_dbg_show = bcm281xx_pinctrl_pin_dbg_show,
1027        .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
1028        .dt_free_map = pinctrl_utils_free_map,
1029};
1030
1031static int bcm281xx_pinctrl_get_fcns_count(struct pinctrl_dev *pctldev)
1032{
1033        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1034
1035        return pdata->nfunctions;
1036}
1037
1038static const char *bcm281xx_pinctrl_get_fcn_name(struct pinctrl_dev *pctldev,
1039                                                 unsigned function)
1040{
1041        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1042
1043        return pdata->functions[function].name;
1044}
1045
1046static int bcm281xx_pinctrl_get_fcn_groups(struct pinctrl_dev *pctldev,
1047                                           unsigned function,
1048                                           const char * const **groups,
1049                                           unsigned * const num_groups)
1050{
1051        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1052
1053        *groups = pdata->functions[function].groups;
1054        *num_groups = pdata->functions[function].ngroups;
1055
1056        return 0;
1057}
1058
1059static int bcm281xx_pinmux_set(struct pinctrl_dev *pctldev,
1060                               unsigned function,
1061                               unsigned group)
1062{
1063        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1064        const struct bcm281xx_pin_function *f = &pdata->functions[function];
1065        u32 offset = 4 * pdata->pins[group].number;
1066        int rc = 0;
1067
1068        dev_dbg(pctldev->dev,
1069                "%s(): Enable function %s (%d) of pin %s (%d) @offset 0x%x.\n",
1070                __func__, f->name, function, pdata->pins[group].name,
1071                pdata->pins[group].number, offset);
1072
1073        rc = regmap_update_bits(pdata->regmap, offset,
1074                BCM281XX_PIN_REG_F_SEL_MASK,
1075                function << BCM281XX_PIN_REG_F_SEL_SHIFT);
1076        if (rc)
1077                dev_err(pctldev->dev,
1078                        "Error updating register for pin %s (%d).\n",
1079                        pdata->pins[group].name, pdata->pins[group].number);
1080
1081        return rc;
1082}
1083
1084static const struct pinmux_ops bcm281xx_pinctrl_pinmux_ops = {
1085        .get_functions_count = bcm281xx_pinctrl_get_fcns_count,
1086        .get_function_name = bcm281xx_pinctrl_get_fcn_name,
1087        .get_function_groups = bcm281xx_pinctrl_get_fcn_groups,
1088        .set_mux = bcm281xx_pinmux_set,
1089};
1090
1091static int bcm281xx_pinctrl_pin_config_get(struct pinctrl_dev *pctldev,
1092                                           unsigned pin,
1093                                           unsigned long *config)
1094{
1095        return -ENOTSUPP;
1096}
1097
1098
1099/* Goes through the configs and update register val/mask */
1100static int bcm281xx_std_pin_update(struct pinctrl_dev *pctldev,
1101                                   unsigned pin,
1102                                   unsigned long *configs,
1103                                   unsigned num_configs,
1104                                   u32 *val,
1105                                   u32 *mask)
1106{
1107        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1108        int i;
1109        enum pin_config_param param;
1110        u32 arg;
1111
1112        for (i = 0; i < num_configs; i++) {
1113                param = pinconf_to_config_param(configs[i]);
1114                arg = pinconf_to_config_argument(configs[i]);
1115
1116                switch (param) {
1117                case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1118                        arg = (arg >= 1 ? 1 : 0);
1119                        bcm281xx_pin_update(val, mask, arg,
1120                                BCM281XX_PIN_SHIFT(STD, HYST),
1121                                BCM281XX_PIN_MASK(STD, HYST));
1122                        break;
1123                /*
1124                 * The pin bias can only be one of pull-up, pull-down, or
1125                 * disable.  The user does not need to specify a value for the
1126                 * property, and the default value from pinconf-generic is
1127                 * ignored.
1128                 */
1129                case PIN_CONFIG_BIAS_DISABLE:
1130                        bcm281xx_pin_update(val, mask, 0,
1131                                BCM281XX_PIN_SHIFT(STD, PULL_UP),
1132                                BCM281XX_PIN_MASK(STD, PULL_UP));
1133                        bcm281xx_pin_update(val, mask, 0,
1134                                BCM281XX_PIN_SHIFT(STD, PULL_DN),
1135                                BCM281XX_PIN_MASK(STD, PULL_DN));
1136                        break;
1137
1138                case PIN_CONFIG_BIAS_PULL_UP:
1139                        bcm281xx_pin_update(val, mask, 1,
1140                                BCM281XX_PIN_SHIFT(STD, PULL_UP),
1141                                BCM281XX_PIN_MASK(STD, PULL_UP));
1142                        bcm281xx_pin_update(val, mask, 0,
1143                                BCM281XX_PIN_SHIFT(STD, PULL_DN),
1144                                BCM281XX_PIN_MASK(STD, PULL_DN));
1145                        break;
1146
1147                case PIN_CONFIG_BIAS_PULL_DOWN:
1148                        bcm281xx_pin_update(val, mask, 0,
1149                                BCM281XX_PIN_SHIFT(STD, PULL_UP),
1150                                BCM281XX_PIN_MASK(STD, PULL_UP));
1151                        bcm281xx_pin_update(val, mask, 1,
1152                                BCM281XX_PIN_SHIFT(STD, PULL_DN),
1153                                BCM281XX_PIN_MASK(STD, PULL_DN));
1154                        break;
1155
1156                case PIN_CONFIG_SLEW_RATE:
1157                        arg = (arg >= 1 ? 1 : 0);
1158                        bcm281xx_pin_update(val, mask, arg,
1159                                BCM281XX_PIN_SHIFT(STD, SLEW),
1160                                BCM281XX_PIN_MASK(STD, SLEW));
1161                        break;
1162
1163                case PIN_CONFIG_INPUT_ENABLE:
1164                        /* inversed since register is for input _disable_ */
1165                        arg = (arg >= 1 ? 0 : 1);
1166                        bcm281xx_pin_update(val, mask, arg,
1167                                BCM281XX_PIN_SHIFT(STD, INPUT_DIS),
1168                                BCM281XX_PIN_MASK(STD, INPUT_DIS));
1169                        break;
1170
1171                case PIN_CONFIG_DRIVE_STRENGTH:
1172                        /* Valid range is 2-16 mA, even numbers only */
1173                        if ((arg < 2) || (arg > 16) || (arg % 2)) {
1174                                dev_err(pctldev->dev,
1175                                        "Invalid Drive Strength value (%d) for "
1176                                        "pin %s (%d). Valid values are "
1177                                        "(2..16) mA, even numbers only.\n",
1178                                        arg, pdata->pins[pin].name, pin);
1179                                return -EINVAL;
1180                        }
1181                        bcm281xx_pin_update(val, mask, (arg/2)-1,
1182                                BCM281XX_PIN_SHIFT(STD, DRV_STR),
1183                                BCM281XX_PIN_MASK(STD, DRV_STR));
1184                        break;
1185
1186                default:
1187                        dev_err(pctldev->dev,
1188                                "Unrecognized pin config %d for pin %s (%d).\n",
1189                                param, pdata->pins[pin].name, pin);
1190                        return -EINVAL;
1191
1192                } /* switch config */
1193        } /* for each config */
1194
1195        return 0;
1196}
1197
1198/*
1199 * The pull-up strength for an I2C pin is represented by bits 4-6 in the
1200 * register with the following mapping:
1201 *   0b000: No pull-up
1202 *   0b001: 1200 Ohm
1203 *   0b010: 1800 Ohm
1204 *   0b011: 720 Ohm
1205 *   0b100: 2700 Ohm
1206 *   0b101: 831 Ohm
1207 *   0b110: 1080 Ohm
1208 *   0b111: 568 Ohm
1209 * This array maps pull-up strength in Ohms to register values (1+index).
1210 */
1211static const u16 bcm281xx_pullup_map[] = {
1212        1200, 1800, 720, 2700, 831, 1080, 568
1213};
1214
1215/* Goes through the configs and update register val/mask */
1216static int bcm281xx_i2c_pin_update(struct pinctrl_dev *pctldev,
1217                                   unsigned pin,
1218                                   unsigned long *configs,
1219                                   unsigned num_configs,
1220                                   u32 *val,
1221                                   u32 *mask)
1222{
1223        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1224        int i, j;
1225        enum pin_config_param param;
1226        u32 arg;
1227
1228        for (i = 0; i < num_configs; i++) {
1229                param = pinconf_to_config_param(configs[i]);
1230                arg = pinconf_to_config_argument(configs[i]);
1231
1232                switch (param) {
1233                case PIN_CONFIG_BIAS_PULL_UP:
1234                        for (j = 0; j < ARRAY_SIZE(bcm281xx_pullup_map); j++)
1235                                if (bcm281xx_pullup_map[j] == arg)
1236                                        break;
1237
1238                        if (j == ARRAY_SIZE(bcm281xx_pullup_map)) {
1239                                dev_err(pctldev->dev,
1240                                        "Invalid pull-up value (%d) for pin %s "
1241                                        "(%d). Valid values are 568, 720, 831, "
1242                                        "1080, 1200, 1800, 2700 Ohms.\n",
1243                                        arg, pdata->pins[pin].name, pin);
1244                                return -EINVAL;
1245                        }
1246
1247                        bcm281xx_pin_update(val, mask, j+1,
1248                                BCM281XX_PIN_SHIFT(I2C, PULL_UP_STR),
1249                                BCM281XX_PIN_MASK(I2C, PULL_UP_STR));
1250                        break;
1251
1252                case PIN_CONFIG_BIAS_DISABLE:
1253                        bcm281xx_pin_update(val, mask, 0,
1254                                BCM281XX_PIN_SHIFT(I2C, PULL_UP_STR),
1255                                BCM281XX_PIN_MASK(I2C, PULL_UP_STR));
1256                        break;
1257
1258                case PIN_CONFIG_SLEW_RATE:
1259                        arg = (arg >= 1 ? 1 : 0);
1260                        bcm281xx_pin_update(val, mask, arg,
1261                                BCM281XX_PIN_SHIFT(I2C, SLEW),
1262                                BCM281XX_PIN_MASK(I2C, SLEW));
1263                        break;
1264
1265                case PIN_CONFIG_INPUT_ENABLE:
1266                        /* inversed since register is for input _disable_ */
1267                        arg = (arg >= 1 ? 0 : 1);
1268                        bcm281xx_pin_update(val, mask, arg,
1269                                BCM281XX_PIN_SHIFT(I2C, INPUT_DIS),
1270                                BCM281XX_PIN_MASK(I2C, INPUT_DIS));
1271                        break;
1272
1273                default:
1274                        dev_err(pctldev->dev,
1275                                "Unrecognized pin config %d for pin %s (%d).\n",
1276                                param, pdata->pins[pin].name, pin);
1277                        return -EINVAL;
1278
1279                } /* switch config */
1280        } /* for each config */
1281
1282        return 0;
1283}
1284
1285/* Goes through the configs and update register val/mask */
1286static int bcm281xx_hdmi_pin_update(struct pinctrl_dev *pctldev,
1287                                    unsigned pin,
1288                                    unsigned long *configs,
1289                                    unsigned num_configs,
1290                                    u32 *val,
1291                                    u32 *mask)
1292{
1293        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1294        int i;
1295        enum pin_config_param param;
1296        u32 arg;
1297
1298        for (i = 0; i < num_configs; i++) {
1299                param = pinconf_to_config_param(configs[i]);
1300                arg = pinconf_to_config_argument(configs[i]);
1301
1302                switch (param) {
1303                case PIN_CONFIG_SLEW_RATE:
1304                        arg = (arg >= 1 ? 1 : 0);
1305                        bcm281xx_pin_update(val, mask, arg,
1306                                BCM281XX_PIN_SHIFT(HDMI, MODE),
1307                                BCM281XX_PIN_MASK(HDMI, MODE));
1308                        break;
1309
1310                case PIN_CONFIG_INPUT_ENABLE:
1311                        /* inversed since register is for input _disable_ */
1312                        arg = (arg >= 1 ? 0 : 1);
1313                        bcm281xx_pin_update(val, mask, arg,
1314                                BCM281XX_PIN_SHIFT(HDMI, INPUT_DIS),
1315                                BCM281XX_PIN_MASK(HDMI, INPUT_DIS));
1316                        break;
1317
1318                default:
1319                        dev_err(pctldev->dev,
1320                                "Unrecognized pin config %d for pin %s (%d).\n",
1321                                param, pdata->pins[pin].name, pin);
1322                        return -EINVAL;
1323
1324                } /* switch config */
1325        } /* for each config */
1326
1327        return 0;
1328}
1329
1330static int bcm281xx_pinctrl_pin_config_set(struct pinctrl_dev *pctldev,
1331                                           unsigned pin,
1332                                           unsigned long *configs,
1333                                           unsigned num_configs)
1334{
1335        struct bcm281xx_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
1336        enum bcm281xx_pin_type pin_type;
1337        u32 offset = 4 * pin;
1338        u32 cfg_val, cfg_mask;
1339        int rc;
1340
1341        cfg_val = 0;
1342        cfg_mask = 0;
1343        pin_type = pin_type_get(pctldev, pin);
1344
1345        /* Different pins have different configuration options */
1346        switch (pin_type) {
1347        case BCM281XX_PIN_TYPE_STD:
1348                rc = bcm281xx_std_pin_update(pctldev, pin, configs,
1349                        num_configs, &cfg_val, &cfg_mask);
1350                break;
1351
1352        case BCM281XX_PIN_TYPE_I2C:
1353                rc = bcm281xx_i2c_pin_update(pctldev, pin, configs,
1354                        num_configs, &cfg_val, &cfg_mask);
1355                break;
1356
1357        case BCM281XX_PIN_TYPE_HDMI:
1358                rc = bcm281xx_hdmi_pin_update(pctldev, pin, configs,
1359                        num_configs, &cfg_val, &cfg_mask);
1360                break;
1361
1362        default:
1363                dev_err(pctldev->dev, "Unknown pin type for pin %s (%d).\n",
1364                        pdata->pins[pin].name, pin);
1365                return -EINVAL;
1366
1367        } /* switch pin type */
1368
1369        if (rc)
1370                return rc;
1371
1372        dev_dbg(pctldev->dev,
1373                "%s(): Set pin %s (%d) with config 0x%x, mask 0x%x\n",
1374                __func__, pdata->pins[pin].name, pin, cfg_val, cfg_mask);
1375
1376        rc = regmap_update_bits(pdata->regmap, offset, cfg_mask, cfg_val);
1377        if (rc) {
1378                dev_err(pctldev->dev,
1379                        "Error updating register for pin %s (%d).\n",
1380                        pdata->pins[pin].name, pin);
1381                return rc;
1382        }
1383
1384        return 0;
1385}
1386
1387static const struct pinconf_ops bcm281xx_pinctrl_pinconf_ops = {
1388        .pin_config_get = bcm281xx_pinctrl_pin_config_get,
1389        .pin_config_set = bcm281xx_pinctrl_pin_config_set,
1390};
1391
1392static struct pinctrl_desc bcm281xx_pinctrl_desc = {
1393        /* name, pins, npins members initialized in probe function */
1394        .pctlops = &bcm281xx_pinctrl_ops,
1395        .pmxops = &bcm281xx_pinctrl_pinmux_ops,
1396        .confops = &bcm281xx_pinctrl_pinconf_ops,
1397        .owner = THIS_MODULE,
1398};
1399
1400static int __init bcm281xx_pinctrl_probe(struct platform_device *pdev)
1401{
1402        struct bcm281xx_pinctrl_data *pdata = &bcm281xx_pinctrl;
1403        struct resource *res;
1404        struct pinctrl_dev *pctl;
1405
1406        /* So far We can assume there is only 1 bank of registers */
1407        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1408        pdata->reg_base = devm_ioremap_resource(&pdev->dev, res);
1409        if (IS_ERR(pdata->reg_base)) {
1410                dev_err(&pdev->dev, "Failed to ioremap MEM resource\n");
1411                return -ENODEV;
1412        }
1413
1414        /* Initialize the dynamic part of pinctrl_desc */
1415        pdata->regmap = devm_regmap_init_mmio(&pdev->dev, pdata->reg_base,
1416                &bcm281xx_pinctrl_regmap_config);
1417        if (IS_ERR(pdata->regmap)) {
1418                dev_err(&pdev->dev, "Regmap MMIO init failed.\n");
1419                return -ENODEV;
1420        }
1421
1422        bcm281xx_pinctrl_desc.name = dev_name(&pdev->dev);
1423        bcm281xx_pinctrl_desc.pins = bcm281xx_pinctrl.pins;
1424        bcm281xx_pinctrl_desc.npins = bcm281xx_pinctrl.npins;
1425
1426        pctl = devm_pinctrl_register(&pdev->dev, &bcm281xx_pinctrl_desc, pdata);
1427        if (IS_ERR(pctl)) {
1428                dev_err(&pdev->dev, "Failed to register pinctrl\n");
1429                return PTR_ERR(pctl);
1430        }
1431
1432        platform_set_drvdata(pdev, pdata);
1433
1434        return 0;
1435}
1436
1437static const struct of_device_id bcm281xx_pinctrl_of_match[] = {
1438        { .compatible = "brcm,bcm11351-pinctrl", },
1439        { },
1440};
1441
1442static struct platform_driver bcm281xx_pinctrl_driver = {
1443        .driver = {
1444                .name = "bcm281xx-pinctrl",
1445                .of_match_table = bcm281xx_pinctrl_of_match,
1446        },
1447};
1448builtin_platform_driver_probe(bcm281xx_pinctrl_driver, bcm281xx_pinctrl_probe);
1449