drivers/pinctrl/intel/pinctrl-baytrail.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Pinctrl GPIO driver for Intel Baytrail
   4  *
   5  * Copyright (c) 2012-2013, Intel Corporation
   6  * Author: Mathias Nyman <mathias.nyman@linux.intel.com>
   7  */
   8
   9 #include <linux/acpi.h>
  10 #include <linux/bitops.h>
  11 #include <linux/gpio/driver.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/io.h>
  15 #include <linux/kernel.h>
  16 #include <linux/types.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/property.h>
  20 #include <linux/seq_file.h>
  21
  22 #include <linux/pinctrl/pinctrl.h>
  23 #include <linux/pinctrl/pinmux.h>
  24 #include <linux/pinctrl/pinconf.h>
  25 #include <linux/pinctrl/pinconf-generic.h>
  26
  27 #include "pinctrl-intel.h"
  28
  29 /* memory mapped register offsets */
  30 #define BYT_CONF0_REG           0x000
  31 #define BYT_CONF1_REG           0x004
  32 #define BYT_VAL_REG             0x008
  33 #define BYT_DFT_REG             0x00c
  34 #define BYT_INT_STAT_REG        0x800
  35 #define BYT_DEBOUNCE_REG        0x9d0
  36
  37 /* BYT_CONF0_REG register bits */
  38 #define BYT_IODEN               BIT(31)
  39 #define BYT_DIRECT_IRQ_EN       BIT(27)
  40 #define BYT_TRIG_MASK           GENMASK(26, 24)
  41 #define BYT_TRIG_NEG            BIT(26)
  42 #define BYT_TRIG_POS            BIT(25)
  43 #define BYT_TRIG_LVL            BIT(24)
  44 #define BYT_DEBOUNCE_EN         BIT(20)
  45 #define BYT_GLITCH_FILTER_EN    BIT(19)
  46 #define BYT_GLITCH_F_SLOW_CLK   BIT(17)
  47 #define BYT_GLITCH_F_FAST_CLK   BIT(16)
  48 #define BYT_PULL_STR_SHIFT      9
  49 #define BYT_PULL_STR_MASK       GENMASK(10, 9)
  50 #define BYT_PULL_STR_2K         (0 << BYT_PULL_STR_SHIFT)
  51 #define BYT_PULL_STR_10K        (1 << BYT_PULL_STR_SHIFT)
  52 #define BYT_PULL_STR_20K        (2 << BYT_PULL_STR_SHIFT)
  53 #define BYT_PULL_STR_40K        (3 << BYT_PULL_STR_SHIFT)
  54 #define BYT_PULL_ASSIGN_SHIFT   7
  55 #define BYT_PULL_ASSIGN_MASK    GENMASK(8, 7)
  56 #define BYT_PULL_ASSIGN_UP      (1 << BYT_PULL_ASSIGN_SHIFT)
  57 #define BYT_PULL_ASSIGN_DOWN    (2 << BYT_PULL_ASSIGN_SHIFT)
  58 #define BYT_PIN_MUX             GENMASK(2, 0)
  59
  60 /* BYT_VAL_REG register bits */
  61 #define BYT_DIR_MASK            GENMASK(2, 1)
  62 #define BYT_INPUT_EN            BIT(2)  /* 0: input enabled (active low)*/
  63 #define BYT_OUTPUT_EN           BIT(1)  /* 0: output enabled (active low)*/
  64 #define BYT_LEVEL               BIT(0)
  65
  66 #define BYT_CONF0_RESTORE_MASK  (BYT_DIRECT_IRQ_EN | BYT_TRIG_MASK | BYT_PIN_MUX)
  67 #define BYT_VAL_RESTORE_MASK    (BYT_DIR_MASK | BYT_LEVEL)
  68
  69 /* BYT_DEBOUNCE_REG bits */
  70 #define BYT_DEBOUNCE_PULSE_MASK         GENMASK(2, 0)
  71 #define BYT_DEBOUNCE_PULSE_375US        1
  72 #define BYT_DEBOUNCE_PULSE_750US        2
  73 #define BYT_DEBOUNCE_PULSE_1500US       3
  74 #define BYT_DEBOUNCE_PULSE_3MS          4
  75 #define BYT_DEBOUNCE_PULSE_6MS          5
  76 #define BYT_DEBOUNCE_PULSE_12MS         6
  77 #define BYT_DEBOUNCE_PULSE_24MS         7
  78
  79 #define BYT_NGPIO_SCORE         102
  80 #define BYT_NGPIO_NCORE         28
  81 #define BYT_NGPIO_SUS           44
  82
  83 #define BYT_SCORE_ACPI_UID      "1"
  84 #define BYT_NCORE_ACPI_UID      "2"
  85 #define BYT_SUS_ACPI_UID        "3"
  86
  87 /*
  88  * This is the function value most pins have for GPIO muxing. If the value
  89  * differs from the default one, it must be explicitly mentioned. Otherwise, the
  90  * pin control implementation will set the muxing value to default GPIO if it
  91  * does not find a match for the requested function.
  92  */
  93 #define BYT_DEFAULT_GPIO_MUX    0
  94 #define BYT_ALTER_GPIO_MUX      1
  95
  96 struct intel_pad_context {
  97         u32 conf0;
  98         u32 val;
  99 };
 100
 101 #define COMMUNITY(p, n, map)            \
 102         {                               \
 103                 .pin_base       = (p),  \
 104                 .npins          = (n),  \
 105                 .pad_map        = (map),\
 106         }
 107
 108 /* SCORE pins, aka GPIOC_<pin_no> or GPIO_S0_SC[<pin_no>] */
 109 static const struct pinctrl_pin_desc byt_score_pins[] = {
 110         PINCTRL_PIN(0, "SATA_GP0"),
 111         PINCTRL_PIN(1, "SATA_GP1"),
 112         PINCTRL_PIN(2, "SATA_LED#"),
 113         PINCTRL_PIN(3, "PCIE_CLKREQ0"),
 114         PINCTRL_PIN(4, "PCIE_CLKREQ1"),
 115         PINCTRL_PIN(5, "PCIE_CLKREQ2"),
 116         PINCTRL_PIN(6, "PCIE_CLKREQ3"),
 117         PINCTRL_PIN(7, "SD3_WP"),
 118         PINCTRL_PIN(8, "HDA_RST"),
 119         PINCTRL_PIN(9, "HDA_SYNC"),
 120         PINCTRL_PIN(10, "HDA_CLK"),
 121         PINCTRL_PIN(11, "HDA_SDO"),
 122         PINCTRL_PIN(12, "HDA_SDI0"),
 123         PINCTRL_PIN(13, "HDA_SDI1"),
 124         PINCTRL_PIN(14, "GPIO_S0_SC14"),
 125         PINCTRL_PIN(15, "GPIO_S0_SC15"),
 126         PINCTRL_PIN(16, "MMC1_CLK"),
 127         PINCTRL_PIN(17, "MMC1_D0"),
 128         PINCTRL_PIN(18, "MMC1_D1"),
 129         PINCTRL_PIN(19, "MMC1_D2"),
 130         PINCTRL_PIN(20, "MMC1_D3"),
 131         PINCTRL_PIN(21, "MMC1_D4"),
 132         PINCTRL_PIN(22, "MMC1_D5"),
 133         PINCTRL_PIN(23, "MMC1_D6"),
 134         PINCTRL_PIN(24, "MMC1_D7"),
 135         PINCTRL_PIN(25, "MMC1_CMD"),
 136         PINCTRL_PIN(26, "MMC1_RST"),
 137         PINCTRL_PIN(27, "SD2_CLK"),
 138         PINCTRL_PIN(28, "SD2_D0"),
 139         PINCTRL_PIN(29, "SD2_D1"),
 140         PINCTRL_PIN(30, "SD2_D2"),
 141         PINCTRL_PIN(31, "SD2_D3_CD"),
 142         PINCTRL_PIN(32, "SD2_CMD"),
 143         PINCTRL_PIN(33, "SD3_CLK"),
 144         PINCTRL_PIN(34, "SD3_D0"),
 145         PINCTRL_PIN(35, "SD3_D1"),
 146         PINCTRL_PIN(36, "SD3_D2"),
 147         PINCTRL_PIN(37, "SD3_D3"),
 148         PINCTRL_PIN(38, "SD3_CD"),
 149         PINCTRL_PIN(39, "SD3_CMD"),
 150         PINCTRL_PIN(40, "SD3_1P8EN"),
 151         PINCTRL_PIN(41, "SD3_PWREN#"),
 152         PINCTRL_PIN(42, "ILB_LPC_AD0"),
 153         PINCTRL_PIN(43, "ILB_LPC_AD1"),
 154         PINCTRL_PIN(44, "ILB_LPC_AD2"),
 155         PINCTRL_PIN(45, "ILB_LPC_AD3"),
 156         PINCTRL_PIN(46, "ILB_LPC_FRAME"),
 157         PINCTRL_PIN(47, "ILB_LPC_CLK0"),
 158         PINCTRL_PIN(48, "ILB_LPC_CLK1"),
 159         PINCTRL_PIN(49, "ILB_LPC_CLKRUN"),
 160         PINCTRL_PIN(50, "ILB_LPC_SERIRQ"),
 161         PINCTRL_PIN(51, "PCU_SMB_DATA"),
 162         PINCTRL_PIN(52, "PCU_SMB_CLK"),
 163         PINCTRL_PIN(53, "PCU_SMB_ALERT"),
 164         PINCTRL_PIN(54, "ILB_8254_SPKR"),
 165         PINCTRL_PIN(55, "GPIO_S0_SC55"),
 166         PINCTRL_PIN(56, "GPIO_S0_SC56"),
 167         PINCTRL_PIN(57, "GPIO_S0_SC57"),
 168         PINCTRL_PIN(58, "GPIO_S0_SC58"),
 169         PINCTRL_PIN(59, "GPIO_S0_SC59"),
 170         PINCTRL_PIN(60, "GPIO_S0_SC60"),
 171         PINCTRL_PIN(61, "GPIO_S0_SC61"),
 172         PINCTRL_PIN(62, "LPE_I2S2_CLK"),
 173         PINCTRL_PIN(63, "LPE_I2S2_FRM"),
 174         PINCTRL_PIN(64, "LPE_I2S2_DATAIN"),
 175         PINCTRL_PIN(65, "LPE_I2S2_DATAOUT"),
 176         PINCTRL_PIN(66, "SIO_SPI_CS"),
 177         PINCTRL_PIN(67, "SIO_SPI_MISO"),
 178         PINCTRL_PIN(68, "SIO_SPI_MOSI"),
 179         PINCTRL_PIN(69, "SIO_SPI_CLK"),
 180         PINCTRL_PIN(70, "SIO_UART1_RXD"),
 181         PINCTRL_PIN(71, "SIO_UART1_TXD"),
 182         PINCTRL_PIN(72, "SIO_UART1_RTS"),
 183         PINCTRL_PIN(73, "SIO_UART1_CTS"),
 184         PINCTRL_PIN(74, "SIO_UART2_RXD"),
 185         PINCTRL_PIN(75, "SIO_UART2_TXD"),
 186         PINCTRL_PIN(76, "SIO_UART2_RTS"),
 187         PINCTRL_PIN(77, "SIO_UART2_CTS"),
 188         PINCTRL_PIN(78, "SIO_I2C0_DATA"),
 189         PINCTRL_PIN(79, "SIO_I2C0_CLK"),
 190         PINCTRL_PIN(80, "SIO_I2C1_DATA"),
 191         PINCTRL_PIN(81, "SIO_I2C1_CLK"),
 192         PINCTRL_PIN(82, "SIO_I2C2_DATA"),
 193         PINCTRL_PIN(83, "SIO_I2C2_CLK"),
 194         PINCTRL_PIN(84, "SIO_I2C3_DATA"),
 195         PINCTRL_PIN(85, "SIO_I2C3_CLK"),
 196         PINCTRL_PIN(86, "SIO_I2C4_DATA"),
 197         PINCTRL_PIN(87, "SIO_I2C4_CLK"),
 198         PINCTRL_PIN(88, "SIO_I2C5_DATA"),
 199         PINCTRL_PIN(89, "SIO_I2C5_CLK"),
 200         PINCTRL_PIN(90, "SIO_I2C6_DATA"),
 201         PINCTRL_PIN(91, "SIO_I2C6_CLK"),
 202         PINCTRL_PIN(92, "GPIO_S0_SC92"),
 203         PINCTRL_PIN(93, "GPIO_S0_SC93"),
 204         PINCTRL_PIN(94, "SIO_PWM0"),
 205         PINCTRL_PIN(95, "SIO_PWM1"),
 206         PINCTRL_PIN(96, "PMC_PLT_CLK0"),
 207         PINCTRL_PIN(97, "PMC_PLT_CLK1"),
 208         PINCTRL_PIN(98, "PMC_PLT_CLK2"),
 209         PINCTRL_PIN(99, "PMC_PLT_CLK3"),
 210         PINCTRL_PIN(100, "PMC_PLT_CLK4"),
 211         PINCTRL_PIN(101, "PMC_PLT_CLK5"),
 212 };
 213
 214 static const unsigned int byt_score_pins_map[BYT_NGPIO_SCORE] = {
 215         85, 89, 93, 96, 99, 102, 98, 101, 34, 37,
 216         36, 38, 39, 35, 40, 84, 62, 61, 64, 59,
 217         54, 56, 60, 55, 63, 57, 51, 50, 53, 47,
 218         52, 49, 48, 43, 46, 41, 45, 42, 58, 44,
 219         95, 105, 70, 68, 67, 66, 69, 71, 65, 72,
 220         86, 90, 88, 92, 103, 77, 79, 83, 78, 81,
 221         80, 82, 13, 12, 15, 14, 17, 18, 19, 16,
 222         2, 1, 0, 4, 6, 7, 9, 8, 33, 32,
 223         31, 30, 29, 27, 25, 28, 26, 23, 21, 20,
 224         24, 22, 5, 3, 10, 11, 106, 87, 91, 104,
 225         97, 100,
 226 };
 227
 228 /* SCORE groups */
 229 static const unsigned int byt_score_uart1_pins[] = { 70, 71, 72, 73 };
 230 static const unsigned int byt_score_uart2_pins[] = { 74, 75, 76, 77 };
 231
 232 static const unsigned int byt_score_pwm0_pins[] = { 94 };
 233 static const unsigned int byt_score_pwm1_pins[] = { 95 };
 234
 235 static const unsigned int byt_score_sio_spi_pins[] = { 66, 67, 68, 69 };
 236
 237 static const unsigned int byt_score_i2c5_pins[] = { 88, 89 };
 238 static const unsigned int byt_score_i2c6_pins[] = { 90, 91 };
 239 static const unsigned int byt_score_i2c4_pins[] = { 86, 87 };
 240 static const unsigned int byt_score_i2c3_pins[] = { 84, 85 };
 241 static const unsigned int byt_score_i2c2_pins[] = { 82, 83 };
 242 static const unsigned int byt_score_i2c1_pins[] = { 80, 81 };
 243 static const unsigned int byt_score_i2c0_pins[] = { 78, 79 };
 244
 245 static const unsigned int byt_score_ssp0_pins[] = { 8, 9, 10, 11 };
 246 static const unsigned int byt_score_ssp1_pins[] = { 12, 13, 14, 15 };
 247 static const unsigned int byt_score_ssp2_pins[] = { 62, 63, 64, 65 };
 248
 249 static const unsigned int byt_score_sdcard_pins[] = {
 250         7, 33, 34, 35, 36, 37, 38, 39, 40, 41,
 251 };
 252 static const unsigned int byt_score_sdcard_mux_values[] = {
 253         2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 254 };
 255
 256 static const unsigned int byt_score_sdio_pins[] = { 27, 28, 29, 30, 31, 32 };
 257
 258 static const unsigned int byt_score_emmc_pins[] = {
 259         16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
 260 };
 261
 262 static const unsigned int byt_score_ilb_lpc_pins[] = {
 263         42, 43, 44, 45, 46, 47, 48, 49, 50,
 264 };
 265
 266 static const unsigned int byt_score_sata_pins[] = { 0, 1, 2 };
 267
 268 static const unsigned int byt_score_plt_clk0_pins[] = { 96 };
 269 static const unsigned int byt_score_plt_clk1_pins[] = { 97 };
 270 static const unsigned int byt_score_plt_clk2_pins[] = { 98 };
 271 static const unsigned int byt_score_plt_clk3_pins[] = { 99 };
 272 static const unsigned int byt_score_plt_clk4_pins[] = { 100 };
 273 static const unsigned int byt_score_plt_clk5_pins[] = { 101 };
 274
 275 static const unsigned int byt_score_smbus_pins[] = { 51, 52, 53 };
 276
 277 static const struct intel_pingroup byt_score_groups[] = {
 278         PIN_GROUP("uart1_grp", byt_score_uart1_pins, 1),
 279         PIN_GROUP("uart2_grp", byt_score_uart2_pins, 1),
 280         PIN_GROUP("pwm0_grp", byt_score_pwm0_pins, 1),
 281         PIN_GROUP("pwm1_grp", byt_score_pwm1_pins, 1),
 282         PIN_GROUP("ssp2_grp", byt_score_ssp2_pins, 1),
 283         PIN_GROUP("sio_spi_grp", byt_score_sio_spi_pins, 1),
 284         PIN_GROUP("i2c5_grp", byt_score_i2c5_pins, 1),
 285         PIN_GROUP("i2c6_grp", byt_score_i2c6_pins, 1),
 286         PIN_GROUP("i2c4_grp", byt_score_i2c4_pins, 1),
 287         PIN_GROUP("i2c3_grp", byt_score_i2c3_pins, 1),
 288         PIN_GROUP("i2c2_grp", byt_score_i2c2_pins, 1),
 289         PIN_GROUP("i2c1_grp", byt_score_i2c1_pins, 1),
 290         PIN_GROUP("i2c0_grp", byt_score_i2c0_pins, 1),
 291         PIN_GROUP("ssp0_grp", byt_score_ssp0_pins, 1),
 292         PIN_GROUP("ssp1_grp", byt_score_ssp1_pins, 1),
 293         PIN_GROUP("sdcard_grp", byt_score_sdcard_pins, byt_score_sdcard_mux_values),
 294         PIN_GROUP("sdio_grp", byt_score_sdio_pins, 1),
 295         PIN_GROUP("emmc_grp", byt_score_emmc_pins, 1),
 296         PIN_GROUP("lpc_grp", byt_score_ilb_lpc_pins, 1),
 297         PIN_GROUP("sata_grp", byt_score_sata_pins, 1),
 298         PIN_GROUP("plt_clk0_grp", byt_score_plt_clk0_pins, 1),
 299         PIN_GROUP("plt_clk1_grp", byt_score_plt_clk1_pins, 1),
 300         PIN_GROUP("plt_clk2_grp", byt_score_plt_clk2_pins, 1),
 301         PIN_GROUP("plt_clk3_grp", byt_score_plt_clk3_pins, 1),
 302         PIN_GROUP("plt_clk4_grp", byt_score_plt_clk4_pins, 1),
 303         PIN_GROUP("plt_clk5_grp", byt_score_plt_clk5_pins, 1),
 304         PIN_GROUP("smbus_grp", byt_score_smbus_pins, 1),
 305 };
 306
 307 static const char * const byt_score_uart_groups[] = {
 308         "uart1_grp", "uart2_grp",
 309 };
 310 static const char * const byt_score_pwm_groups[] = {
 311         "pwm0_grp", "pwm1_grp",
 312 };
 313 static const char * const byt_score_ssp_groups[] = {
 314         "ssp0_grp", "ssp1_grp", "ssp2_grp",
 315 };
 316 static const char * const byt_score_spi_groups[] = { "sio_spi_grp" };
 317 static const char * const byt_score_i2c_groups[] = {
 318         "i2c0_grp", "i2c1_grp", "i2c2_grp", "i2c3_grp", "i2c4_grp", "i2c5_grp",
 319         "i2c6_grp",
 320 };
 321 static const char * const byt_score_sdcard_groups[] = { "sdcard_grp" };
 322 static const char * const byt_score_sdio_groups[] = { "sdio_grp" };
 323 static const char * const byt_score_emmc_groups[] = { "emmc_grp" };
 324 static const char * const byt_score_lpc_groups[] = { "lpc_grp" };
 325 static const char * const byt_score_sata_groups[] = { "sata_grp" };
 326 static const char * const byt_score_plt_clk_groups[] = {
 327         "plt_clk0_grp", "plt_clk1_grp", "plt_clk2_grp", "plt_clk3_grp",
 328         "plt_clk4_grp", "plt_clk5_grp",
 329 };
 330 static const char * const byt_score_smbus_groups[] = { "smbus_grp" };
 331 static const char * const byt_score_gpio_groups[] = {
 332         "uart1_grp", "uart2_grp", "pwm0_grp", "pwm1_grp", "ssp0_grp",
 333         "ssp1_grp", "ssp2_grp", "sio_spi_grp", "i2c0_grp", "i2c1_grp",
 334         "i2c2_grp", "i2c3_grp", "i2c4_grp", "i2c5_grp", "i2c6_grp",
 335         "sdcard_grp", "sdio_grp", "emmc_grp", "lpc_grp", "sata_grp",
 336         "plt_clk0_grp", "plt_clk1_grp", "plt_clk2_grp", "plt_clk3_grp",
 337         "plt_clk4_grp", "plt_clk5_grp", "smbus_grp",
 338 };
 339
 340 static const struct intel_function byt_score_functions[] = {
 341         FUNCTION("uart", byt_score_uart_groups),
 342         FUNCTION("pwm", byt_score_pwm_groups),
 343         FUNCTION("ssp", byt_score_ssp_groups),
 344         FUNCTION("spi", byt_score_spi_groups),
 345         FUNCTION("i2c", byt_score_i2c_groups),
 346         FUNCTION("sdcard", byt_score_sdcard_groups),
 347         FUNCTION("sdio", byt_score_sdio_groups),
 348         FUNCTION("emmc", byt_score_emmc_groups),
 349         FUNCTION("lpc", byt_score_lpc_groups),
 350         FUNCTION("sata", byt_score_sata_groups),
 351         FUNCTION("plt_clk", byt_score_plt_clk_groups),
 352         FUNCTION("smbus", byt_score_smbus_groups),
 353         FUNCTION("gpio", byt_score_gpio_groups),
 354 };
 355
 356 static const struct intel_community byt_score_communities[] = {
 357         COMMUNITY(0, BYT_NGPIO_SCORE, byt_score_pins_map),
 358 };
 359
 360 static const struct intel_pinctrl_soc_data byt_score_soc_data = {
 361         .uid            = BYT_SCORE_ACPI_UID,
 362         .pins           = byt_score_pins,
 363         .npins          = ARRAY_SIZE(byt_score_pins),
 364         .groups         = byt_score_groups,
 365         .ngroups        = ARRAY_SIZE(byt_score_groups),
 366         .functions      = byt_score_functions,
 367         .nfunctions     = ARRAY_SIZE(byt_score_functions),
 368         .communities    = byt_score_communities,
 369         .ncommunities   = ARRAY_SIZE(byt_score_communities),
 370 };
 371
 372 /* SUS pins, aka GPIOS_<pin_no> or GPIO_S5[<pin_no>]  */
 373 static const struct pinctrl_pin_desc byt_sus_pins[] = {
 374         PINCTRL_PIN(0, "GPIO_S50"),
 375         PINCTRL_PIN(1, "GPIO_S51"),
 376         PINCTRL_PIN(2, "GPIO_S52"),
 377         PINCTRL_PIN(3, "GPIO_S53"),
 378         PINCTRL_PIN(4, "GPIO_S54"),
 379         PINCTRL_PIN(5, "GPIO_S55"),
 380         PINCTRL_PIN(6, "GPIO_S56"),
 381         PINCTRL_PIN(7, "GPIO_S57"),
 382         PINCTRL_PIN(8, "GPIO_S58"),
 383         PINCTRL_PIN(9, "GPIO_S59"),
 384         PINCTRL_PIN(10, "GPIO_S510"),
 385         PINCTRL_PIN(11, "PMC_SUSPWRDNACK"),
 386         PINCTRL_PIN(12, "PMC_SUSCLK0"),
 387         PINCTRL_PIN(13, "GPIO_S513"),
 388         PINCTRL_PIN(14, "USB_ULPI_RST"),
 389         PINCTRL_PIN(15, "PMC_WAKE_PCIE0#"),
 390         PINCTRL_PIN(16, "PMC_PWRBTN"),
 391         PINCTRL_PIN(17, "GPIO_S517"),
 392         PINCTRL_PIN(18, "PMC_SUS_STAT"),
 393         PINCTRL_PIN(19, "USB_OC0"),
 394         PINCTRL_PIN(20, "USB_OC1"),
 395         PINCTRL_PIN(21, "PCU_SPI_CS1"),
 396         PINCTRL_PIN(22, "GPIO_S522"),
 397         PINCTRL_PIN(23, "GPIO_S523"),
 398         PINCTRL_PIN(24, "GPIO_S524"),
 399         PINCTRL_PIN(25, "GPIO_S525"),
 400         PINCTRL_PIN(26, "GPIO_S526"),
 401         PINCTRL_PIN(27, "GPIO_S527"),
 402         PINCTRL_PIN(28, "GPIO_S528"),
 403         PINCTRL_PIN(29, "GPIO_S529"),
 404         PINCTRL_PIN(30, "GPIO_S530"),
 405         PINCTRL_PIN(31, "USB_ULPI_CLK"),
 406         PINCTRL_PIN(32, "USB_ULPI_DATA0"),
 407         PINCTRL_PIN(33, "USB_ULPI_DATA1"),
 408         PINCTRL_PIN(34, "USB_ULPI_DATA2"),
 409         PINCTRL_PIN(35, "USB_ULPI_DATA3"),
 410         PINCTRL_PIN(36, "USB_ULPI_DATA4"),
 411         PINCTRL_PIN(37, "USB_ULPI_DATA5"),
 412         PINCTRL_PIN(38, "USB_ULPI_DATA6"),
 413         PINCTRL_PIN(39, "USB_ULPI_DATA7"),
 414         PINCTRL_PIN(40, "USB_ULPI_DIR"),
 415         PINCTRL_PIN(41, "USB_ULPI_NXT"),
 416         PINCTRL_PIN(42, "USB_ULPI_STP"),
 417         PINCTRL_PIN(43, "USB_ULPI_REFCLK"),
 418 };
 419
 420 static const unsigned int byt_sus_pins_map[BYT_NGPIO_SUS] = {
 421         29, 33, 30, 31, 32, 34, 36, 35, 38, 37,
 422         18, 7, 11, 20, 17, 1, 8, 10, 19, 12,
 423         0, 2, 23, 39, 28, 27, 22, 21, 24, 25,
 424         26, 51, 56, 54, 49, 55, 48, 57, 50, 58,
 425         52, 53, 59, 40,
 426 };
 427
 428 static const unsigned int byt_sus_usb_over_current_pins[] = { 19, 20 };
 429 static const unsigned int byt_sus_usb_over_current_mode_values[] = { 0, 0 };
 430 static const unsigned int byt_sus_usb_over_current_gpio_mode_values[] = { 1, 1 };
 431
 432 static const unsigned int byt_sus_usb_ulpi_pins[] = {
 433         14, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 434 };
 435 static const unsigned int byt_sus_usb_ulpi_mode_values[] = {
 436         2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 437 };
 438 static const unsigned int byt_sus_usb_ulpi_gpio_mode_values[] = {
 439         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 440 };
 441
 442 static const unsigned int byt_sus_pcu_spi_pins[] = { 21 };
 443 static const unsigned int byt_sus_pcu_spi_mode_values[] = { 0 };
 444 static const unsigned int byt_sus_pcu_spi_gpio_mode_values[] = { 1 };
 445
 446 static const struct intel_pingroup byt_sus_groups[] = {
 447         PIN_GROUP("usb_oc_grp", byt_sus_usb_over_current_pins, byt_sus_usb_over_current_mode_values),
 448         PIN_GROUP("usb_ulpi_grp", byt_sus_usb_ulpi_pins, byt_sus_usb_ulpi_mode_values),
 449         PIN_GROUP("pcu_spi_grp", byt_sus_pcu_spi_pins, byt_sus_pcu_spi_mode_values),
 450         PIN_GROUP("usb_oc_grp_gpio", byt_sus_usb_over_current_pins, byt_sus_usb_over_current_gpio_mode_values),
 451         PIN_GROUP("usb_ulpi_grp_gpio", byt_sus_usb_ulpi_pins, byt_sus_usb_ulpi_gpio_mode_values),
 452         PIN_GROUP("pcu_spi_grp_gpio", byt_sus_pcu_spi_pins, byt_sus_pcu_spi_gpio_mode_values),
 453 };
 454
 455 static const char * const byt_sus_usb_groups[] = {
 456         "usb_oc_grp", "usb_ulpi_grp",
 457 };
 458 static const char * const byt_sus_spi_groups[] = { "pcu_spi_grp" };
 459 static const char * const byt_sus_gpio_groups[] = {
 460         "usb_oc_grp_gpio", "usb_ulpi_grp_gpio", "pcu_spi_grp_gpio",
 461 };
 462
 463 static const struct intel_function byt_sus_functions[] = {
 464         FUNCTION("usb", byt_sus_usb_groups),
 465         FUNCTION("spi", byt_sus_spi_groups),
 466         FUNCTION("gpio", byt_sus_gpio_groups),
 467 };
 468
 469 static const struct intel_community byt_sus_communities[] = {
 470         COMMUNITY(0, BYT_NGPIO_SUS, byt_sus_pins_map),
 471 };
 472
 473 static const struct intel_pinctrl_soc_data byt_sus_soc_data = {
 474         .uid            = BYT_SUS_ACPI_UID,
 475         .pins           = byt_sus_pins,
 476         .npins          = ARRAY_SIZE(byt_sus_pins),
 477         .groups         = byt_sus_groups,
 478         .ngroups        = ARRAY_SIZE(byt_sus_groups),
 479         .functions      = byt_sus_functions,
 480         .nfunctions     = ARRAY_SIZE(byt_sus_functions),
 481         .communities    = byt_sus_communities,
 482         .ncommunities   = ARRAY_SIZE(byt_sus_communities),
 483 };
 484
 485 static const struct pinctrl_pin_desc byt_ncore_pins[] = {
 486         PINCTRL_PIN(0, "HV_DDI0_HPD"),
 487         PINCTRL_PIN(1, "HV_DDI0_DDC_SDA"),
 488         PINCTRL_PIN(2, "HV_DDI0_DDC_SCL"),
 489         PINCTRL_PIN(3, "PANEL0_VDDEN"),
 490         PINCTRL_PIN(4, "PANEL0_BKLTEN"),
 491         PINCTRL_PIN(5, "PANEL0_BKLTCTL"),
 492         PINCTRL_PIN(6, "HV_DDI1_HPD"),
 493         PINCTRL_PIN(7, "HV_DDI1_DDC_SDA"),
 494         PINCTRL_PIN(8, "HV_DDI1_DDC_SCL"),
 495         PINCTRL_PIN(9, "PANEL1_VDDEN"),
 496         PINCTRL_PIN(10, "PANEL1_BKLTEN"),
 497         PINCTRL_PIN(11, "PANEL1_BKLTCTL"),
 498         PINCTRL_PIN(12, "GP_INTD_DSI_TE1"),
 499         PINCTRL_PIN(13, "HV_DDI2_DDC_SDA"),
 500         PINCTRL_PIN(14, "HV_DDI2_DDC_SCL"),
 501         PINCTRL_PIN(15, "GP_CAMERASB00"),
 502         PINCTRL_PIN(16, "GP_CAMERASB01"),
 503         PINCTRL_PIN(17, "GP_CAMERASB02"),
 504         PINCTRL_PIN(18, "GP_CAMERASB03"),
 505         PINCTRL_PIN(19, "GP_CAMERASB04"),
 506         PINCTRL_PIN(20, "GP_CAMERASB05"),
 507         PINCTRL_PIN(21, "GP_CAMERASB06"),
 508         PINCTRL_PIN(22, "GP_CAMERASB07"),
 509         PINCTRL_PIN(23, "GP_CAMERASB08"),
 510         PINCTRL_PIN(24, "GP_CAMERASB09"),
 511         PINCTRL_PIN(25, "GP_CAMERASB10"),
 512         PINCTRL_PIN(26, "GP_CAMERASB11"),
 513         PINCTRL_PIN(27, "GP_INTD_DSI_TE2"),
 514 };
 515
 516 static const unsigned int byt_ncore_pins_map[BYT_NGPIO_NCORE] = {
 517         19, 18, 17, 20, 21, 22, 24, 25, 23, 16,
 518         14, 15, 12, 26, 27, 1, 4, 8, 11, 0,
 519         3, 6, 10, 13, 2, 5, 9, 7,
 520 };
 521
 522 static const struct intel_community byt_ncore_communities[] = {
 523         COMMUNITY(0, BYT_NGPIO_NCORE, byt_ncore_pins_map),
 524 };
 525
 526 static const struct intel_pinctrl_soc_data byt_ncore_soc_data = {
 527         .uid            = BYT_NCORE_ACPI_UID,
 528         .pins           = byt_ncore_pins,
 529         .npins          = ARRAY_SIZE(byt_ncore_pins),
 530         .communities    = byt_ncore_communities,
 531         .ncommunities   = ARRAY_SIZE(byt_ncore_communities),
 532 };
 533
 534 static const struct intel_pinctrl_soc_data *byt_soc_data[] = {
 535         &byt_score_soc_data,
 536         &byt_sus_soc_data,
 537         &byt_ncore_soc_data,
 538         NULL
 539 };
 540
 541 static DEFINE_RAW_SPINLOCK(byt_lock);
 542
 543 static struct intel_community *byt_get_community(struct intel_pinctrl *vg,
 544                                                  unsigned int pin)
 545 {
 546         struct intel_community *comm;
 547         int i;
 548
 549         for (i = 0; i < vg->ncommunities; i++) {
 550                 comm = vg->communities + i;
 551                 if (pin < comm->pin_base + comm->npins && pin >= comm->pin_base)
 552                         return comm;
 553         }
 554
 555         return NULL;
 556 }
 557
 558 static void __iomem *byt_gpio_reg(struct intel_pinctrl *vg, unsigned int offset,
 559                                   int reg)
 560 {
 561         struct intel_community *comm = byt_get_community(vg, offset);
 562         u32 reg_offset;
 563
 564         if (!comm)
 565                 return NULL;
 566
 567         offset -= comm->pin_base;
 568         switch (reg) {
 569         case BYT_INT_STAT_REG:
 570                 reg_offset = (offset / 32) * 4;
 571                 break;
 572         case BYT_DEBOUNCE_REG:
 573                 reg_offset = 0;
 574                 break;
 575         default:
 576                 reg_offset = comm->pad_map[offset] * 16;
 577                 break;
 578         }
 579
 580         return comm->pad_regs + reg_offset + reg;
 581 }
 582
 583 static int byt_get_groups_count(struct pinctrl_dev *pctldev)
 584 {
 585         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 586
 587         return vg->soc->ngroups;
 588 }
 589
 590 static const char *byt_get_group_name(struct pinctrl_dev *pctldev,
 591                                       unsigned int selector)
 592 {
 593         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 594
 595         return vg->soc->groups[selector].name;
 596 }
 597
 598 static int byt_get_group_pins(struct pinctrl_dev *pctldev,
 599                               unsigned int selector,
 600                               const unsigned int **pins,
 601                               unsigned int *num_pins)
 602 {
 603         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 604
 605         *pins           = vg->soc->groups[selector].pins;
 606         *num_pins       = vg->soc->groups[selector].npins;
 607
 608         return 0;
 609 }
 610
 611 static const struct pinctrl_ops byt_pinctrl_ops = {
 612         .get_groups_count       = byt_get_groups_count,
 613         .get_group_name         = byt_get_group_name,
 614         .get_group_pins         = byt_get_group_pins,
 615 };
 616
 617 static int byt_get_functions_count(struct pinctrl_dev *pctldev)
 618 {
 619         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 620
 621         return vg->soc->nfunctions;
 622 }
 623
 624 static const char *byt_get_function_name(struct pinctrl_dev *pctldev,
 625                                          unsigned int selector)
 626 {
 627         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 628
 629         return vg->soc->functions[selector].name;
 630 }
 631
 632 static int byt_get_function_groups(struct pinctrl_dev *pctldev,
 633                                    unsigned int selector,
 634                                    const char * const **groups,
 635                                    unsigned int *num_groups)
 636 {
 637         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 638
 639         *groups         = vg->soc->functions[selector].groups;
 640         *num_groups     = vg->soc->functions[selector].ngroups;
 641
 642         return 0;
 643 }
 644
 645 static void byt_set_group_simple_mux(struct intel_pinctrl *vg,
 646                                      const struct intel_pingroup group,
 647                                      unsigned int func)
 648 {
 649         unsigned long flags;
 650         int i;
 651
 652         raw_spin_lock_irqsave(&byt_lock, flags);
 653
 654         for (i = 0; i < group.npins; i++) {
 655                 void __iomem *padcfg0;
 656                 u32 value;
 657
 658                 padcfg0 = byt_gpio_reg(vg, group.pins[i], BYT_CONF0_REG);
 659                 if (!padcfg0) {
 660                         dev_warn(vg->dev,
 661                                  "Group %s, pin %i not muxed (no padcfg0)\n",
 662                                  group.name, i);
 663                         continue;
 664                 }
 665
 666                 value = readl(padcfg0);
 667                 value &= ~BYT_PIN_MUX;
 668                 value |= func;
 669                 writel(value, padcfg0);
 670         }
 671
 672         raw_spin_unlock_irqrestore(&byt_lock, flags);
 673 }
 674
 675 static void byt_set_group_mixed_mux(struct intel_pinctrl *vg,
 676                                     const struct intel_pingroup group,
 677                                     const unsigned int *func)
 678 {
 679         unsigned long flags;
 680         int i;
 681
 682         raw_spin_lock_irqsave(&byt_lock, flags);
 683
 684         for (i = 0; i < group.npins; i++) {
 685                 void __iomem *padcfg0;
 686                 u32 value;
 687
 688                 padcfg0 = byt_gpio_reg(vg, group.pins[i], BYT_CONF0_REG);
 689                 if (!padcfg0) {
 690                         dev_warn(vg->dev,
 691                                  "Group %s, pin %i not muxed (no padcfg0)\n",
 692                                  group.name, i);
 693                         continue;
 694                 }
 695
 696                 value = readl(padcfg0);
 697                 value &= ~BYT_PIN_MUX;
 698                 value |= func[i];
 699                 writel(value, padcfg0);
 700         }
 701
 702         raw_spin_unlock_irqrestore(&byt_lock, flags);
 703 }
 704
 705 static int byt_set_mux(struct pinctrl_dev *pctldev, unsigned int func_selector,
 706                        unsigned int group_selector)
 707 {
 708         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctldev);
 709         const struct intel_function func = vg->soc->functions[func_selector];
 710         const struct intel_pingroup group = vg->soc->groups[group_selector];
 711
 712         if (group.modes)
 713                 byt_set_group_mixed_mux(vg, group, group.modes);
 714         else if (!strcmp(func.name, "gpio"))
 715                 byt_set_group_simple_mux(vg, group, BYT_DEFAULT_GPIO_MUX);
 716         else
 717                 byt_set_group_simple_mux(vg, group, group.mode);
 718
 719         return 0;
 720 }
 721
 722 static u32 byt_get_gpio_mux(struct intel_pinctrl *vg, unsigned int offset)
 723 {
 724         /* SCORE pin 92-93 */
 725         if (!strcmp(vg->soc->uid, BYT_SCORE_ACPI_UID) &&
 726             offset >= 92 && offset <= 93)
 727                 return BYT_ALTER_GPIO_MUX;
 728
 729         /* SUS pin 11-21 */
 730         if (!strcmp(vg->soc->uid, BYT_SUS_ACPI_UID) &&
 731             offset >= 11 && offset <= 21)
 732                 return BYT_ALTER_GPIO_MUX;
 733
 734         return BYT_DEFAULT_GPIO_MUX;
 735 }
 736
 737 static void byt_gpio_clear_triggering(struct intel_pinctrl *vg, unsigned int offset)
 738 {
 739         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
 740         unsigned long flags;
 741         u32 value;
 742
 743         raw_spin_lock_irqsave(&byt_lock, flags);
 744         value = readl(reg);
 745
 746         /* Do not clear direct-irq enabled IRQs (from gpio_disable_free) */
 747         if (value & BYT_DIRECT_IRQ_EN)
 748                 /* nothing to do */ ;
 749         else
 750                 value &= ~(BYT_TRIG_POS | BYT_TRIG_NEG | BYT_TRIG_LVL);
 751
 752         writel(value, reg);
 753         raw_spin_unlock_irqrestore(&byt_lock, flags);
 754 }
 755
 756 static int byt_gpio_request_enable(struct pinctrl_dev *pctl_dev,
 757                                    struct pinctrl_gpio_range *range,
 758                                    unsigned int offset)
 759 {
 760         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctl_dev);
 761         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
 762         u32 value, gpio_mux;
 763         unsigned long flags;
 764
 765         raw_spin_lock_irqsave(&byt_lock, flags);
 766
 767         /*
 768          * In most cases, func pin mux 000 means GPIO function.
 769          * But, some pins may have func pin mux 001 represents
 770          * GPIO function.
 771          *
 772          * Because there are devices out there where some pins were not
 773          * configured correctly we allow changing the mux value from
 774          * request (but print out warning about that).
 775          */
 776         value = readl(reg) & BYT_PIN_MUX;
 777         gpio_mux = byt_get_gpio_mux(vg, offset);
 778         if (gpio_mux != value) {
 779                 value = readl(reg) & ~BYT_PIN_MUX;
 780                 value |= gpio_mux;
 781                 writel(value, reg);
 782
 783                 dev_warn(vg->dev, FW_BUG "pin %u forcibly re-configured as GPIO\n", offset);
 784         }
 785
 786         raw_spin_unlock_irqrestore(&byt_lock, flags);
 787
 788         pm_runtime_get(vg->dev);
 789
 790         return 0;
 791 }
 792
 793 static void byt_gpio_disable_free(struct pinctrl_dev *pctl_dev,
 794                                   struct pinctrl_gpio_range *range,
 795                                   unsigned int offset)
 796 {
 797         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctl_dev);
 798
 799         byt_gpio_clear_triggering(vg, offset);
 800         pm_runtime_put(vg->dev);
 801 }
 802
 803 static void byt_gpio_direct_irq_check(struct intel_pinctrl *vg,
 804                                       unsigned int offset)
 805 {
 806         void __iomem *conf_reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
 807
 808         /*
 809          * Before making any direction modifications, do a check if gpio is set
 810          * for direct IRQ. On Bay Trail, setting GPIO to output does not make
 811          * sense, so let's at least inform the caller before they shoot
 812          * themselves in the foot.
 813          */
 814         if (readl(conf_reg) & BYT_DIRECT_IRQ_EN)
 815                 dev_info_once(vg->dev, "Potential Error: Setting GPIO with direct_irq_en to output");
 816 }
 817
 818 static int byt_gpio_set_direction(struct pinctrl_dev *pctl_dev,
 819                                   struct pinctrl_gpio_range *range,
 820                                   unsigned int offset,
 821                                   bool input)
 822 {
 823         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctl_dev);
 824         void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
 825         unsigned long flags;
 826         u32 value;
 827
 828         raw_spin_lock_irqsave(&byt_lock, flags);
 829
 830         value = readl(val_reg);
 831         value &= ~BYT_DIR_MASK;
 832         if (input)
 833                 value |= BYT_OUTPUT_EN;
 834         else
 835                 byt_gpio_direct_irq_check(vg, offset);
 836
 837         writel(value, val_reg);
 838
 839         raw_spin_unlock_irqrestore(&byt_lock, flags);
 840
 841         return 0;
 842 }
 843
 844 static const struct pinmux_ops byt_pinmux_ops = {
 845         .get_functions_count    = byt_get_functions_count,
 846         .get_function_name      = byt_get_function_name,
 847         .get_function_groups    = byt_get_function_groups,
 848         .set_mux                = byt_set_mux,
 849         .gpio_request_enable    = byt_gpio_request_enable,
 850         .gpio_disable_free      = byt_gpio_disable_free,
 851         .gpio_set_direction     = byt_gpio_set_direction,
 852 };
 853
 854 static void byt_get_pull_strength(u32 reg, u16 *strength)
 855 {
 856         switch (reg & BYT_PULL_STR_MASK) {
 857         case BYT_PULL_STR_2K:
 858                 *strength = 2000;
 859                 break;
 860         case BYT_PULL_STR_10K:
 861                 *strength = 10000;
 862                 break;
 863         case BYT_PULL_STR_20K:
 864                 *strength = 20000;
 865                 break;
 866         case BYT_PULL_STR_40K:
 867                 *strength = 40000;
 868                 break;
 869         }
 870 }
 871
 872 static int byt_set_pull_strength(u32 *reg, u16 strength)
 873 {
 874         *reg &= ~BYT_PULL_STR_MASK;
 875
 876         switch (strength) {
 877         case 2000:
 878                 *reg |= BYT_PULL_STR_2K;
 879                 break;
 880         case 10000:
 881                 *reg |= BYT_PULL_STR_10K;
 882                 break;
 883         case 20000:
 884                 *reg |= BYT_PULL_STR_20K;
 885                 break;
 886         case 40000:
 887                 *reg |= BYT_PULL_STR_40K;
 888                 break;
 889         default:
 890                 return -EINVAL;
 891         }
 892
 893         return 0;
 894 }
 895
 896 static int byt_pin_config_get(struct pinctrl_dev *pctl_dev, unsigned int offset,
 897                               unsigned long *config)
 898 {
 899         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctl_dev);
 900         enum pin_config_param param = pinconf_to_config_param(*config);
 901         void __iomem *conf_reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
 902         void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
 903         void __iomem *db_reg = byt_gpio_reg(vg, offset, BYT_DEBOUNCE_REG);
 904         unsigned long flags;
 905         u32 conf, pull, val, debounce;
 906         u16 arg = 0;
 907
 908         raw_spin_lock_irqsave(&byt_lock, flags);
 909         conf = readl(conf_reg);
 910         pull = conf & BYT_PULL_ASSIGN_MASK;
 911         val = readl(val_reg);
 912         raw_spin_unlock_irqrestore(&byt_lock, flags);
 913
 914         switch (param) {
 915         case PIN_CONFIG_BIAS_DISABLE:
 916                 if (pull)
 917                         return -EINVAL;
 918                 break;
 919         case PIN_CONFIG_BIAS_PULL_DOWN:
 920                 /* Pull assignment is only applicable in input mode */
 921                 if ((val & BYT_INPUT_EN) || pull != BYT_PULL_ASSIGN_DOWN)
 922                         return -EINVAL;
 923
 924                 byt_get_pull_strength(conf, &arg);
 925
 926                 break;
 927         case PIN_CONFIG_BIAS_PULL_UP:
 928                 /* Pull assignment is only applicable in input mode */
 929                 if ((val & BYT_INPUT_EN) || pull != BYT_PULL_ASSIGN_UP)
 930                         return -EINVAL;
 931
 932                 byt_get_pull_strength(conf, &arg);
 933
 934                 break;
 935         case PIN_CONFIG_INPUT_DEBOUNCE:
 936                 if (!(conf & BYT_DEBOUNCE_EN))
 937                         return -EINVAL;
 938
 939                 raw_spin_lock_irqsave(&byt_lock, flags);
 940                 debounce = readl(db_reg);
 941                 raw_spin_unlock_irqrestore(&byt_lock, flags);
 942
 943                 switch (debounce & BYT_DEBOUNCE_PULSE_MASK) {
 944                 case BYT_DEBOUNCE_PULSE_375US:
 945                         arg = 375;
 946                         break;
 947                 case BYT_DEBOUNCE_PULSE_750US:
 948                         arg = 750;
 949                         break;
 950                 case BYT_DEBOUNCE_PULSE_1500US:
 951                         arg = 1500;
 952                         break;
 953                 case BYT_DEBOUNCE_PULSE_3MS:
 954                         arg = 3000;
 955                         break;
 956                 case BYT_DEBOUNCE_PULSE_6MS:
 957                         arg = 6000;
 958                         break;
 959                 case BYT_DEBOUNCE_PULSE_12MS:
 960                         arg = 12000;
 961                         break;
 962                 case BYT_DEBOUNCE_PULSE_24MS:
 963                         arg = 24000;
 964                         break;
 965                 default:
 966                         return -EINVAL;
 967                 }
 968
 969                 break;
 970         default:
 971                 return -ENOTSUPP;
 972         }
 973
 974         *config = pinconf_to_config_packed(param, arg);
 975
 976         return 0;
 977 }
 978
 979 static int byt_pin_config_set(struct pinctrl_dev *pctl_dev,
 980                               unsigned int offset,
 981                               unsigned long *configs,
 982                               unsigned int num_configs)
 983 {
 984         struct intel_pinctrl *vg = pinctrl_dev_get_drvdata(pctl_dev);
 985         unsigned int param, arg;
 986         void __iomem *conf_reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
 987         void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
 988         void __iomem *db_reg = byt_gpio_reg(vg, offset, BYT_DEBOUNCE_REG);
 989         unsigned long flags;
 990         u32 conf, val, debounce;
 991         int i, ret = 0;
 992
 993         raw_spin_lock_irqsave(&byt_lock, flags);
 994
 995         conf = readl(conf_reg);
 996         val = readl(val_reg);
 997
 998         for (i = 0; i < num_configs; i++) {
 999                 param = pinconf_to_config_param(configs[i]);
1000                 arg = pinconf_to_config_argument(configs[i]);
1001
1002                 switch (param) {
1003                 case PIN_CONFIG_BIAS_DISABLE:
1004                         conf &= ~BYT_PULL_ASSIGN_MASK;
1005                         break;
1006                 case PIN_CONFIG_BIAS_PULL_DOWN:
1007                         /* Set default strength value in case none is given */
1008                         if (arg == 1)
1009                                 arg = 2000;
1010
1011                         /*
1012                          * Pull assignment is only applicable in input mode. If
1013                          * chip is not in input mode, set it and warn about it.
1014                          */
1015                         if (val & BYT_INPUT_EN) {
1016                                 val &= ~BYT_INPUT_EN;
1017                                 writel(val, val_reg);
1018                                 dev_warn(vg->dev,
1019                                          "pin %u forcibly set to input mode\n",
1020                                          offset);
1021                         }
1022
1023                         conf &= ~BYT_PULL_ASSIGN_MASK;
1024                         conf |= BYT_PULL_ASSIGN_DOWN;
1025                         ret = byt_set_pull_strength(&conf, arg);
1026
1027                         break;
1028                 case PIN_CONFIG_BIAS_PULL_UP:
1029                         /* Set default strength value in case none is given */
1030                         if (arg == 1)
1031                                 arg = 2000;
1032
1033                         /*
1034                          * Pull assignment is only applicable in input mode. If
1035                          * chip is not in input mode, set it and warn about it.
1036                          */
1037                         if (val & BYT_INPUT_EN) {
1038                                 val &= ~BYT_INPUT_EN;
1039                                 writel(val, val_reg);
1040                                 dev_warn(vg->dev,
1041                                          "pin %u forcibly set to input mode\n",
1042                                          offset);
1043                         }
1044
1045                         conf &= ~BYT_PULL_ASSIGN_MASK;
1046                         conf |= BYT_PULL_ASSIGN_UP;
1047                         ret = byt_set_pull_strength(&conf, arg);
1048
1049                         break;
1050                 case PIN_CONFIG_INPUT_DEBOUNCE:
1051                         debounce = readl(db_reg);
1052
1053                         if (arg)
1054                                 conf |= BYT_DEBOUNCE_EN;
1055                         else
1056                                 conf &= ~BYT_DEBOUNCE_EN;
1057
1058                         switch (arg) {
1059                         case 375:
1060                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1061                                 debounce |= BYT_DEBOUNCE_PULSE_375US;
1062                                 break;
1063                         case 750:
1064                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1065                                 debounce |= BYT_DEBOUNCE_PULSE_750US;
1066                                 break;
1067                         case 1500:
1068                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1069                                 debounce |= BYT_DEBOUNCE_PULSE_1500US;
1070                                 break;
1071                         case 3000:
1072                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1073                                 debounce |= BYT_DEBOUNCE_PULSE_3MS;
1074                                 break;
1075                         case 6000:
1076                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1077                                 debounce |= BYT_DEBOUNCE_PULSE_6MS;
1078                                 break;
1079                         case 12000:
1080                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1081                                 debounce |= BYT_DEBOUNCE_PULSE_12MS;
1082                                 break;
1083                         case 24000:
1084                                 debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
1085                                 debounce |= BYT_DEBOUNCE_PULSE_24MS;
1086                                 break;
1087                         default:
1088                                 if (arg)
1089                                         ret = -EINVAL;
1090                                 break;
1091                         }
1092
1093                         if (!ret)
1094                                 writel(debounce, db_reg);
1095                         break;
1096                 default:
1097                         ret = -ENOTSUPP;
1098                 }
1099
1100                 if (ret)
1101                         break;
1102         }
1103
1104         if (!ret)
1105                 writel(conf, conf_reg);
1106
1107         raw_spin_unlock_irqrestore(&byt_lock, flags);
1108
1109         return ret;
1110 }
1111
1112 static const struct pinconf_ops byt_pinconf_ops = {
1113         .is_generic     = true,
1114         .pin_config_get = byt_pin_config_get,
1115         .pin_config_set = byt_pin_config_set,
1116 };
1117
1118 static const struct pinctrl_desc byt_pinctrl_desc = {
1119         .pctlops        = &byt_pinctrl_ops,
1120         .pmxops         = &byt_pinmux_ops,
1121         .confops        = &byt_pinconf_ops,
1122         .owner          = THIS_MODULE,
1123 };
1124
1125 static int byt_gpio_get(struct gpio_chip *chip, unsigned int offset)
1126 {
1127         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1128         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
1129         unsigned long flags;
1130         u32 val;
1131
1132         raw_spin_lock_irqsave(&byt_lock, flags);
1133         val = readl(reg);
1134         raw_spin_unlock_irqrestore(&byt_lock, flags);
1135
1136         return !!(val & BYT_LEVEL);
1137 }
1138
1139 static void byt_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
1140 {
1141         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1142         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
1143         unsigned long flags;
1144         u32 old_val;
1145
1146         if (!reg)
1147                 return;
1148
1149         raw_spin_lock_irqsave(&byt_lock, flags);
1150         old_val = readl(reg);
1151         if (value)
1152                 writel(old_val | BYT_LEVEL, reg);
1153         else
1154                 writel(old_val & ~BYT_LEVEL, reg);
1155         raw_spin_unlock_irqrestore(&byt_lock, flags);
1156 }
1157
1158 static int byt_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
1159 {
1160         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1161         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
1162         unsigned long flags;
1163         u32 value;
1164
1165         if (!reg)
1166                 return -EINVAL;
1167
1168         raw_spin_lock_irqsave(&byt_lock, flags);
1169         value = readl(reg);
1170         raw_spin_unlock_irqrestore(&byt_lock, flags);
1171
1172         if (!(value & BYT_OUTPUT_EN))
1173                 return GPIO_LINE_DIRECTION_OUT;
1174         if (!(value & BYT_INPUT_EN))
1175                 return GPIO_LINE_DIRECTION_IN;
1176
1177         return -EINVAL;
1178 }
1179
1180 static int byt_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
1181 {
1182         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1183         void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
1184         unsigned long flags;
1185         u32 reg;
1186
1187         raw_spin_lock_irqsave(&byt_lock, flags);
1188
1189         reg = readl(val_reg);
1190         reg &= ~BYT_DIR_MASK;
1191         reg |= BYT_OUTPUT_EN;
1192         writel(reg, val_reg);
1193
1194         raw_spin_unlock_irqrestore(&byt_lock, flags);
1195         return 0;
1196 }
1197
1198 /*
1199  * Note despite the temptation this MUST NOT be converted into a call to
1200  * pinctrl_gpio_direction_output() + byt_gpio_set() that does not work this
1201  * MUST be done as a single BYT_VAL_REG register write.
1202  * See the commit message of the commit adding this comment for details.
1203  */
1204 static int byt_gpio_direction_output(struct gpio_chip *chip,
1205                                      unsigned int offset, int value)
1206 {
1207         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1208         void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG);
1209         unsigned long flags;
1210         u32 reg;
1211
1212         raw_spin_lock_irqsave(&byt_lock, flags);
1213
1214         byt_gpio_direct_irq_check(vg, offset);
1215
1216         reg = readl(val_reg);
1217         reg &= ~BYT_DIR_MASK;
1218         if (value)
1219                 reg |= BYT_LEVEL;
1220         else
1221                 reg &= ~BYT_LEVEL;
1222
1223         writel(reg, val_reg);
1224
1225         raw_spin_unlock_irqrestore(&byt_lock, flags);
1226         return 0;
1227 }
1228
1229 static void byt_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
1230 {
1231         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1232         int i;
1233         u32 conf0, val;
1234
1235         for (i = 0; i < vg->soc->npins; i++) {
1236                 const struct intel_community *comm;
1237                 const char *pull_str = NULL;
1238                 const char *pull = NULL;
1239                 void __iomem *reg;
1240                 unsigned long flags;
1241                 const char *label;
1242                 unsigned int pin;
1243
1244                 raw_spin_lock_irqsave(&byt_lock, flags);
1245                 pin = vg->soc->pins[i].number;
1246                 reg = byt_gpio_reg(vg, pin, BYT_CONF0_REG);
1247                 if (!reg) {
1248                         seq_printf(s,
1249                                    "Could not retrieve pin %i conf0 reg\n",
1250                                    pin);
1251                         raw_spin_unlock_irqrestore(&byt_lock, flags);
1252                         continue;
1253                 }
1254                 conf0 = readl(reg);
1255
1256                 reg = byt_gpio_reg(vg, pin, BYT_VAL_REG);
1257                 if (!reg) {
1258                         seq_printf(s,
1259                                    "Could not retrieve pin %i val reg\n", pin);
1260                         raw_spin_unlock_irqrestore(&byt_lock, flags);
1261                         continue;
1262                 }
1263                 val = readl(reg);
1264                 raw_spin_unlock_irqrestore(&byt_lock, flags);
1265
1266                 comm = byt_get_community(vg, pin);
1267                 if (!comm) {
1268                         seq_printf(s,
1269                                    "Could not get community for pin %i\n", pin);
1270                         continue;
1271                 }
1272                 label = gpiochip_is_requested(chip, i);
1273                 if (!label)
1274                         label = "Unrequested";
1275
1276                 switch (conf0 & BYT_PULL_ASSIGN_MASK) {
1277                 case BYT_PULL_ASSIGN_UP:
1278                         pull = "up";
1279                         break;
1280                 case BYT_PULL_ASSIGN_DOWN:
1281                         pull = "down";
1282                         break;
1283                 }
1284
1285                 switch (conf0 & BYT_PULL_STR_MASK) {
1286                 case BYT_PULL_STR_2K:
1287                         pull_str = "2k";
1288                         break;
1289                 case BYT_PULL_STR_10K:
1290                         pull_str = "10k";
1291                         break;
1292                 case BYT_PULL_STR_20K:
1293                         pull_str = "20k";
1294                         break;
1295                 case BYT_PULL_STR_40K:
1296                         pull_str = "40k";
1297                         break;
1298                 }
1299
1300                 seq_printf(s,
1301                            " gpio-%-3d (%-20.20s) %s %s %s pad-%-3d offset:0x%03x mux:%d %s%s%s",
1302                            pin,
1303                            label,
1304                            val & BYT_INPUT_EN ? "  " : "in",
1305                            val & BYT_OUTPUT_EN ? "   " : "out",
1306                            val & BYT_LEVEL ? "hi" : "lo",
1307                            comm->pad_map[i], comm->pad_map[i] * 16,
1308                            conf0 & 0x7,
1309                            conf0 & BYT_TRIG_NEG ? " fall" : "     ",
1310                            conf0 & BYT_TRIG_POS ? " rise" : "     ",
1311                            conf0 & BYT_TRIG_LVL ? " level" : "      ");
1312
1313                 if (pull && pull_str)
1314                         seq_printf(s, " %-4s %-3s", pull, pull_str);
1315                 else
1316                         seq_puts(s, "          ");
1317
1318                 if (conf0 & BYT_IODEN)
1319                         seq_puts(s, " open-drain");
1320
1321                 seq_puts(s, "\n");
1322         }
1323 }
1324
1325 static const struct gpio_chip byt_gpio_chip = {
1326         .owner                  = THIS_MODULE,
1327         .request                = gpiochip_generic_request,
1328         .free                   = gpiochip_generic_free,
1329         .get_direction          = byt_gpio_get_direction,
1330         .direction_input        = byt_gpio_direction_input,
1331         .direction_output       = byt_gpio_direction_output,
1332         .get                    = byt_gpio_get,
1333         .set                    = byt_gpio_set,
1334         .set_config             = gpiochip_generic_config,
1335         .dbg_show               = byt_gpio_dbg_show,
1336 };
1337
1338 static void byt_irq_ack(struct irq_data *d)
1339 {
1340         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1341         struct intel_pinctrl *vg = gpiochip_get_data(gc);
1342         unsigned int offset = irqd_to_hwirq(d);
1343         void __iomem *reg;
1344
1345         reg = byt_gpio_reg(vg, offset, BYT_INT_STAT_REG);
1346         if (!reg)
1347                 return;
1348
1349         raw_spin_lock(&byt_lock);
1350         writel(BIT(offset % 32), reg);
1351         raw_spin_unlock(&byt_lock);
1352 }
1353
1354 static void byt_irq_mask(struct irq_data *d)
1355 {
1356         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1357         struct intel_pinctrl *vg = gpiochip_get_data(gc);
1358
1359         byt_gpio_clear_triggering(vg, irqd_to_hwirq(d));
1360 }
1361
1362 static void byt_irq_unmask(struct irq_data *d)
1363 {
1364         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
1365         struct intel_pinctrl *vg = gpiochip_get_data(gc);
1366         unsigned int offset = irqd_to_hwirq(d);
1367         unsigned long flags;
1368         void __iomem *reg;
1369         u32 value;
1370
1371         reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
1372         if (!reg)
1373                 return;
1374
1375         raw_spin_lock_irqsave(&byt_lock, flags);
1376         value = readl(reg);
1377
1378         switch (irqd_get_trigger_type(d)) {
1379         case IRQ_TYPE_LEVEL_HIGH:
1380                 value |= BYT_TRIG_LVL;
1381                 fallthrough;
1382         case IRQ_TYPE_EDGE_RISING:
1383                 value |= BYT_TRIG_POS;
1384                 break;
1385         case IRQ_TYPE_LEVEL_LOW:
1386                 value |= BYT_TRIG_LVL;
1387                 fallthrough;
1388         case IRQ_TYPE_EDGE_FALLING:
1389                 value |= BYT_TRIG_NEG;
1390                 break;
1391         case IRQ_TYPE_EDGE_BOTH:
1392                 value |= (BYT_TRIG_NEG | BYT_TRIG_POS);
1393                 break;
1394         }
1395
1396         writel(value, reg);
1397
1398         raw_spin_unlock_irqrestore(&byt_lock, flags);
1399 }
1400
1401 static int byt_irq_type(struct irq_data *d, unsigned int type)
1402 {
1403         struct intel_pinctrl *vg = gpiochip_get_data(irq_data_get_irq_chip_data(d));
1404         u32 offset = irqd_to_hwirq(d);
1405         u32 value;
1406         unsigned long flags;
1407         void __iomem *reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG);
1408
1409         if (!reg || offset >= vg->chip.ngpio)
1410                 return -EINVAL;
1411
1412         raw_spin_lock_irqsave(&byt_lock, flags);
1413         value = readl(reg);
1414
1415         WARN(value & BYT_DIRECT_IRQ_EN,
1416              "Bad pad config for io mode, force direct_irq_en bit clearing");
1417
1418         /* For level trigges the BYT_TRIG_POS and BYT_TRIG_NEG bits
1419          * are used to indicate high and low level triggering
1420          */
1421         value &= ~(BYT_DIRECT_IRQ_EN | BYT_TRIG_POS | BYT_TRIG_NEG |
1422                    BYT_TRIG_LVL);
1423         /* Enable glitch filtering */
1424         value |= BYT_GLITCH_FILTER_EN | BYT_GLITCH_F_SLOW_CLK |
1425                  BYT_GLITCH_F_FAST_CLK;
1426
1427         writel(value, reg);
1428
1429         if (type & IRQ_TYPE_EDGE_BOTH)
1430                 irq_set_handler_locked(d, handle_edge_irq);
1431         else if (type & IRQ_TYPE_LEVEL_MASK)
1432                 irq_set_handler_locked(d, handle_level_irq);
1433
1434         raw_spin_unlock_irqrestore(&byt_lock, flags);
1435
1436         return 0;
1437 }
1438
1439 static void byt_gpio_irq_handler(struct irq_desc *desc)
1440 {
1441         struct irq_data *data = irq_desc_get_irq_data(desc);
1442         struct intel_pinctrl *vg = gpiochip_get_data(irq_desc_get_handler_data(desc));
1443         struct irq_chip *chip = irq_data_get_irq_chip(data);
1444         u32 base, pin;
1445         void __iomem *reg;
1446         unsigned long pending;
1447
1448         /* check from GPIO controller which pin triggered the interrupt */
1449         for (base = 0; base < vg->chip.ngpio; base += 32) {
1450                 reg = byt_gpio_reg(vg, base, BYT_INT_STAT_REG);
1451
1452                 if (!reg) {
1453                         dev_warn(vg->dev,
1454                                  "Pin %i: could not retrieve interrupt status register\n",
1455                                  base);
1456                         continue;
1457                 }
1458
1459                 raw_spin_lock(&byt_lock);
1460                 pending = readl(reg);
1461                 raw_spin_unlock(&byt_lock);
1462                 for_each_set_bit(pin, &pending, 32)
1463                         generic_handle_domain_irq(vg->chip.irq.domain, base + pin);
1464         }
1465         chip->irq_eoi(data);
1466 }
1467
1468 static void byt_init_irq_valid_mask(struct gpio_chip *chip,
1469                                     unsigned long *valid_mask,
1470                                     unsigned int ngpios)
1471 {
1472         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1473         void __iomem *reg;
1474         u32 value;
1475         int i;
1476
1477         /*
1478          * Clear interrupt triggers for all pins that are GPIOs and
1479          * do not use direct IRQ mode. This will prevent spurious
1480          * interrupts from misconfigured pins.
1481          */
1482         for (i = 0; i < vg->soc->npins; i++) {
1483                 unsigned int pin = vg->soc->pins[i].number;
1484
1485                 reg = byt_gpio_reg(vg, pin, BYT_CONF0_REG);
1486                 if (!reg) {
1487                         dev_warn(vg->dev,
1488                                  "Pin %i: could not retrieve conf0 register\n",
1489                                  i);
1490                         continue;
1491                 }
1492
1493                 value = readl(reg);
1494                 if (value & BYT_DIRECT_IRQ_EN) {
1495                         clear_bit(i, valid_mask);
1496                         dev_dbg(vg->dev, "excluding GPIO %d from IRQ domain\n", i);
1497                 } else if ((value & BYT_PIN_MUX) == byt_get_gpio_mux(vg, i)) {
1498                         byt_gpio_clear_triggering(vg, i);
1499                         dev_dbg(vg->dev, "disabling GPIO %d\n", i);
1500                 }
1501         }
1502 }
1503
1504 static int byt_gpio_irq_init_hw(struct gpio_chip *chip)
1505 {
1506         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1507         void __iomem *reg;
1508         u32 base, value;
1509
1510         /* clear interrupt status trigger registers */
1511         for (base = 0; base < vg->soc->npins; base += 32) {
1512                 reg = byt_gpio_reg(vg, base, BYT_INT_STAT_REG);
1513
1514                 if (!reg) {
1515                         dev_warn(vg->dev,
1516                                  "Pin %i: could not retrieve irq status reg\n",
1517                                  base);
1518                         continue;
1519                 }
1520
1521                 writel(0xffffffff, reg);
1522                 /* make sure trigger bits are cleared, if not then a pin
1523                    might be misconfigured in bios */
1524                 value = readl(reg);
1525                 if (value)
1526                         dev_err(vg->dev,
1527                                 "GPIO interrupt error, pins misconfigured. INT_STAT%u: 0x%08x\n",
1528                                 base / 32, value);
1529         }
1530
1531         return 0;
1532 }
1533
1534 static int byt_gpio_add_pin_ranges(struct gpio_chip *chip)
1535 {
1536         struct intel_pinctrl *vg = gpiochip_get_data(chip);
1537         struct device *dev = vg->dev;
1538         int ret;
1539
1540         ret = gpiochip_add_pin_range(chip, dev_name(dev), 0, 0, vg->soc->npins);
1541         if (ret)
1542                 dev_err(dev, "failed to add GPIO pin range\n");
1543
1544         return ret;
1545 }
1546
1547 static int byt_gpio_probe(struct intel_pinctrl *vg)
1548 {
1549         struct platform_device *pdev = to_platform_device(vg->dev);
1550         struct gpio_chip *gc;
1551         int irq, ret;
1552
1553         /* Set up gpio chip */
1554         vg->chip        = byt_gpio_chip;
1555         gc              = &vg->chip;
1556         gc->label       = dev_name(vg->dev);
1557         gc->base        = -1;
1558         gc->can_sleep   = false;
1559         gc->add_pin_ranges = byt_gpio_add_pin_ranges;
1560         gc->parent      = vg->dev;
1561         gc->ngpio       = vg->soc->npins;
1562
1563 #ifdef CONFIG_PM_SLEEP
1564         vg->context.pads = devm_kcalloc(vg->dev, gc->ngpio, sizeof(*vg->context.pads),
1565                                         GFP_KERNEL);
1566         if (!vg->context.pads)
1567                 return -ENOMEM;
1568 #endif
1569
1570         /* set up interrupts  */
1571         irq = platform_get_irq_optional(pdev, 0);
1572         if (irq > 0) {
1573                 struct gpio_irq_chip *girq;
1574
1575                 vg->irqchip.name = "BYT-GPIO",
1576                 vg->irqchip.irq_ack = byt_irq_ack,
1577                 vg->irqchip.irq_mask = byt_irq_mask,
1578                 vg->irqchip.irq_unmask = byt_irq_unmask,
1579                 vg->irqchip.irq_set_type = byt_irq_type,
1580                 vg->irqchip.flags = IRQCHIP_SKIP_SET_WAKE,
1581
1582                 girq = &gc->irq;
1583                 girq->chip = &vg->irqchip;
1584                 girq->init_hw = byt_gpio_irq_init_hw;
1585                 girq->init_valid_mask = byt_init_irq_valid_mask;
1586                 girq->parent_handler = byt_gpio_irq_handler;
1587                 girq->num_parents = 1;
1588                 girq->parents = devm_kcalloc(vg->dev, girq->num_parents,
1589                                              sizeof(*girq->parents), GFP_KERNEL);
1590                 if (!girq->parents)
1591                         return -ENOMEM;
1592                 girq->parents[0] = irq;
1593                 girq->default_type = IRQ_TYPE_NONE;
1594                 girq->handler = handle_bad_irq;
1595         }
1596
1597         ret = devm_gpiochip_add_data(vg->dev, gc, vg);
1598         if (ret) {
1599                 dev_err(vg->dev, "failed adding byt-gpio chip\n");
1600                 return ret;
1601         }
1602
1603         return ret;
1604 }
1605
1606 static int byt_set_soc_data(struct intel_pinctrl *vg,
1607                             const struct intel_pinctrl_soc_data *soc)
1608 {
1609         struct platform_device *pdev = to_platform_device(vg->dev);
1610         int i;
1611
1612         vg->soc = soc;
1613
1614         vg->ncommunities = vg->soc->ncommunities;
1615         vg->communities = devm_kcalloc(vg->dev, vg->ncommunities,
1616                                        sizeof(*vg->communities), GFP_KERNEL);
1617         if (!vg->communities)
1618                 return -ENOMEM;
1619
1620         for (i = 0; i < vg->soc->ncommunities; i++) {
1621                 struct intel_community *comm = vg->communities + i;
1622
1623                 *comm = vg->soc->communities[i];
1624
1625                 comm->pad_regs = devm_platform_ioremap_resource(pdev, 0);
1626                 if (IS_ERR(comm->pad_regs))
1627                         return PTR_ERR(comm->pad_regs);
1628         }
1629
1630         return 0;
1631 }
1632
1633 static const struct acpi_device_id byt_gpio_acpi_match[] = {
1634         { "INT33B2", (kernel_ulong_t)byt_soc_data },
1635         { "INT33FC", (kernel_ulong_t)byt_soc_data },
1636         { }
1637 };
1638
1639 static int byt_pinctrl_probe(struct platform_device *pdev)
1640 {
1641         const struct intel_pinctrl_soc_data *soc_data;
1642         struct device *dev = &pdev->dev;
1643         struct intel_pinctrl *vg;
1644         int ret;
1645
1646         soc_data = intel_pinctrl_get_soc_data(pdev);
1647         if (IS_ERR(soc_data))
1648                 return PTR_ERR(soc_data);
1649
1650         vg = devm_kzalloc(dev, sizeof(*vg), GFP_KERNEL);
1651         if (!vg)
1652                 return -ENOMEM;
1653
1654         vg->dev = dev;
1655         ret = byt_set_soc_data(vg, soc_data);
1656         if (ret) {
1657                 dev_err(dev, "failed to set soc data\n");
1658                 return ret;
1659         }
1660
1661         vg->pctldesc            = byt_pinctrl_desc;
1662         vg->pctldesc.name       = dev_name(dev);
1663         vg->pctldesc.pins       = vg->soc->pins;
1664         vg->pctldesc.npins      = vg->soc->npins;
1665
1666         vg->pctldev = devm_pinctrl_register(dev, &vg->pctldesc, vg);
1667         if (IS_ERR(vg->pctldev)) {
1668                 dev_err(dev, "failed to register pinctrl driver\n");
1669                 return PTR_ERR(vg->pctldev);
1670         }
1671
1672         ret = byt_gpio_probe(vg);
1673         if (ret)
1674                 return ret;
1675
1676         platform_set_drvdata(pdev, vg);
1677         pm_runtime_enable(dev);
1678
1679         return 0;
1680 }
1681
1682 #ifdef CONFIG_PM_SLEEP
1683 static int byt_gpio_suspend(struct device *dev)
1684 {
1685         struct intel_pinctrl *vg = dev_get_drvdata(dev);
1686         unsigned long flags;
1687         int i;
1688
1689         raw_spin_lock_irqsave(&byt_lock, flags);
1690
1691         for (i = 0; i < vg->soc->npins; i++) {
1692                 void __iomem *reg;
1693                 u32 value;
1694                 unsigned int pin = vg->soc->pins[i].number;
1695
1696                 reg = byt_gpio_reg(vg, pin, BYT_CONF0_REG);
1697                 if (!reg) {
1698                         dev_warn(vg->dev,
1699                                  "Pin %i: could not retrieve conf0 register\n",
1700                                  i);
1701                         continue;
1702                 }
1703                 value = readl(reg) & BYT_CONF0_RESTORE_MASK;
1704                 vg->context.pads[i].conf0 = value;
1705
1706                 reg = byt_gpio_reg(vg, pin, BYT_VAL_REG);
1707                 value = readl(reg) & BYT_VAL_RESTORE_MASK;
1708                 vg->context.pads[i].val = value;
1709         }
1710
1711         raw_spin_unlock_irqrestore(&byt_lock, flags);
1712         return 0;
1713 }
1714
1715 static int byt_gpio_resume(struct device *dev)
1716 {
1717         struct intel_pinctrl *vg = dev_get_drvdata(dev);
1718         unsigned long flags;
1719         int i;
1720
1721         raw_spin_lock_irqsave(&byt_lock, flags);
1722
1723         for (i = 0; i < vg->soc->npins; i++) {
1724                 void __iomem *reg;
1725                 u32 value;
1726                 unsigned int pin = vg->soc->pins[i].number;
1727
1728                 reg = byt_gpio_reg(vg, pin, BYT_CONF0_REG);
1729                 if (!reg) {
1730                         dev_warn(vg->dev,
1731                                  "Pin %i: could not retrieve conf0 register\n",
1732                                  i);
1733                         continue;
1734                 }
1735                 value = readl(reg);
1736                 if ((value & BYT_CONF0_RESTORE_MASK) !=
1737                      vg->context.pads[i].conf0) {
1738                         value &= ~BYT_CONF0_RESTORE_MASK;
1739                         value |= vg->context.pads[i].conf0;
1740                         writel(value, reg);
1741                         dev_info(dev, "restored pin %d conf0 %#08x", i, value);
1742                 }
1743
1744                 reg = byt_gpio_reg(vg, pin, BYT_VAL_REG);
1745                 value = readl(reg);
1746                 if ((value & BYT_VAL_RESTORE_MASK) !=
1747                      vg->context.pads[i].val) {
1748                         u32 v;
1749
1750                         v = value & ~BYT_VAL_RESTORE_MASK;
1751                         v |= vg->context.pads[i].val;
1752                         if (v != value) {
1753                                 writel(v, reg);
1754                                 dev_dbg(dev, "restored pin %d val %#08x\n",
1755                                         i, v);
1756                         }
1757                 }
1758         }
1759
1760         raw_spin_unlock_irqrestore(&byt_lock, flags);
1761         return 0;
1762 }
1763 #endif
1764
1765 #ifdef CONFIG_PM
1766 static int byt_gpio_runtime_suspend(struct device *dev)
1767 {
1768         return 0;
1769 }
1770
1771 static int byt_gpio_runtime_resume(struct device *dev)
1772 {
1773         return 0;
1774 }
1775 #endif
1776
1777 static const struct dev_pm_ops byt_gpio_pm_ops = {
1778         SET_LATE_SYSTEM_SLEEP_PM_OPS(byt_gpio_suspend, byt_gpio_resume)
1779         SET_RUNTIME_PM_OPS(byt_gpio_runtime_suspend, byt_gpio_runtime_resume,
1780                            NULL)
1781 };
1782
1783 static struct platform_driver byt_gpio_driver = {
1784         .probe          = byt_pinctrl_probe,
1785         .driver         = {
1786                 .name                   = "byt_gpio",
1787                 .pm                     = &byt_gpio_pm_ops,
1788                 .acpi_match_table       = byt_gpio_acpi_match,
1789                 .suppress_bind_attrs    = true,
1790         },
1791 };
1792
1793 static int __init byt_gpio_init(void)
1794 {
1795         return platform_driver_register(&byt_gpio_driver);
1796 }
1797 subsys_initcall(byt_gpio_init);